From ac6f021e6da0eba9113c69f23a4e651469164e27 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Wed, 5 Mar 2025 12:12:00 -0500
Subject: [PATCH 01/61] Add midi extension

Added midi extension for input/output of midi using the WebMidi API. Still pending documentation and peer-review
---
 extensions/midi/midi.js | 1884 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 1884 insertions(+)
 create mode 100644 extensions/midi/midi.js

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
new file mode 100644
index 0000000000..dbec4a46c6
--- /dev/null
+++ b/extensions/midi/midi.js
@@ -0,0 +1,1884 @@
+// Name: MIDI
+// ID: extmidi
+// Description: An extension to use the WebMidi API for midi input/output.
+// License: MPL-2.0
+
+(function (Scratch) {
+  "use strict";
+
+  if (!Scratch.extensions.unsandboxed) {
+    throw new Error("Midi must be run unsandboxed");
+  }
+
+  const EXT_ID = "extmidi";
+
+  /** 
+   * This section includes logic to map raw data coming from the 'midimessage'
+   * event into a friendly object representation of the event
+   * 
+   * 
+   * // definition for the parsed midi event
+   * @typedef {keyof typeof eventMapping} EventType
+   * @typedef {object} MidiEvent
+   * @property {EventType | 'rest'} type
+   * @property {number} [value1]
+   * @property {number} [value2]
+   * @property {number} [channel]
+   * @property {number} [device]
+   * @property {number} [time]
+   * @property {number} [pitch]
+   * @property {number} [velocity]
+   * @property {number} [cc]
+   * @property {number} [value]
+   * @property {number} [pos]
+   * @property {number} [dur]
+   * @property {string} [_str]
+   * 
+   * 
+   * @typedef {object} FormatOptions
+   * @property {number} [tempo]
+   * @property {boolean} [useFlats]
+   * @property {boolean} [noMinify]
+   * @property {'omit' | 'timestamp' | 'absolute'} [timestampFormat]
+   * @property {number} [startTimestamp]
+   * @property {boolean} [fixedWidth]
+   * @property {boolean} [useHex]
+   * @property {number} [defaultOctave]
+   */
+
+  /**
+   * MIDI commands with code, name, and parameters
+   * From: https://ccrma.stanford.edu/~craig/articles/linuxmidi/misc/essenmidi.html
+   * https://www.midi.org/specifications/item/table-1-summary-of-midi-message
+   *
+   * adapted from https://github.com/fheyen/musicvis-lib/blob/905edbdc8280e8ca76a329ffc83a160f3cda674a/src/fileFormats/Midi.js#L41
+   * 
+   * each key (the "EventType" relates to a raw midi "command". The "shorthand" could
+   * be used to format midi events to string (future). param1 and param2 determine what property of the object the value1 + value2 bytes mean (i.e. noteOn gets pitch + velocity, cc gets cc# and value)
+   */
+  const SHARPS = "C C# D D# E F F# G G# A A# B".split(" ");
+  const FLATS = "C Db D Eb E F Gb G Ab A Bb B".split(" ");
+  function midiPitchToNoteName(midi, { useFlats = false, fixedWidth = false } = {}) {
+    if (!isFinite(midi)) return "";
+    let chroma = (useFlats ? FLATS : SHARPS)[midi % 12];
+    if (fixedWidth) chroma = chroma.padEnd(2, "_");
+    const octave = Math.floor(midi / 12) - 1;
+    return `${chroma}${octave}`;
+  }
+  /**
+   * convert a note string name (or raw midi number) to midi number value
+   * @param {string} note 
+   * @param {number} [defaultOctave] 
+   * @returns {number | null}
+   */
+  function noteNameToMidiPitch(note, defaultOctave = 4) {
+    const parts = /(?<pitch>[A-G])(?<flat>[b♭]+)?(?<sharp>[#♯]+)?_?(?<octave>-?\d+)?/i.exec(note || '');
+    if (!parts?.groups) {
+      const numVal = typeof note === 'string' ? parseInt(note.trim(), 10) : +note;
+      return (numVal >= 0 && numVal <= 127) ? numVal : null;
+    }
+    const { pitch, octave, flat, sharp } = parts.groups;
+    let chroma = SHARPS.indexOf(pitch.toUpperCase()) - (flat?.length || 0) + (sharp?.length || 0);
+    const height = octave ? parseInt(octave, 10) : defaultOctave;
+    return chroma + ((height + 1) * 12);
+  }
+  function parseNumValue(text, defaultValue, opts) {
+    if (!text) return defaultValue;
+    text = text.trim();
+    const useHex = opts?.useHex ?? /[a-f]/.test(text);
+    const radix = useHex ? 16 : 10;
+    const val = parseInt(text, radix);
+    return isNaN(val) ? defaultValue : val;
+  }
+  function formatHex(value, pad = 2) {
+    return Math.round(value).toString(16).padStart(pad, "0");
+  }
+
+  const eventMapping = {
+    ["noteOn" /* Note */]: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
+    ["noteOff" /* NoteOff */]: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
+    ["cc" /* CC */]: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
+    ["polyTouch" /* NoteAftertouch */]: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
+    ["programChange" /* ProgramChange */]: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
+    ["pitchBend" /* PitchBend */]: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
+    ["channelPressure" /* ChannelPressure */]: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
+    ["songPosition" /* SongPosition */]: { shorthand: "songpos", command: 242, description: "Song Position Pointer (Sys Common)", highResParam: "value" },
+    ["songSelect" /* SongSelect */]: { shorthand: "songsel", command: 243, description: "Song Select (Sys Common)", param1: "value" },
+    ["clock" /* Clock */]: { shorthand: "clock", command: 248, description: "Timing Clock (Sys Realtime)" },
+    ["start" /* Start */]: { shorthand: "start", command: 250, description: "Start (Sys Realtime)" },
+    ["continue" /* Continue */]: { shorthand: "continue", command: 251, description: "Continue (Sys Realtime)" },
+    ["stop" /* Stop */]: { shorthand: "stop", command: 252, description: "Stop (Sys Realtime)" },
+    ["activeSensing" /* ActiveSensing */]: { shorthand: "ping", command: 254, description: "Active Sensing (Sys Realtime)" },
+    ["reset" /* Reset */]: { shorthand: "reset", command: 255, description: "System Reset (Sys Realtime)" }
+  };
+  /** @type {Map<number, EventType>} */
+  // @ts-ignore
+  const commandLookup = new Map(Object.entries(eventMapping).map(([key, { command }]) => [command, key]));
+  /** @type {Map<string, EventType>} */
+  // @ts-ignore
+  const shorthandLookup = Object.fromEntries([
+    ...Object.entries(eventMapping).map(([key, { shorthand }]) => [shorthand, key]),
+    ...Object.keys(eventMapping).map(key => [key.toLowerCase(), key])
+  ]);
+  const shorthands = Object.fromEntries(Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand]));
+  /**
+   * @param {string} value 
+   * @returns {EventType | undefined}
+   */
+  function normalizeType(value) {
+    if (typeof value === "number") {
+      return commandLookup.get(value);
+    }
+    if (typeof value !== "string") return undefined;
+    return eventMapping[value] !== undefined
+      ? value
+      : shorthandLookup[value.toLowerCase()];
+  }
+
+  function formatNumValue(value, opts) {
+    const str = opts?.useHex ? formatHex(value) : value.toFixed().padStart(opts?.fixedWidth ? 2 : 3, "0");
+    return str;
+  }
+  function formatDefault(type, value, value2, opts) {
+    return `${type} ${formatNumValue(value, opts)}${value2 != undefined ? " " + formatNumValue(value2, opts) : ""}`;
+  }
+  function formatNoteType(type, note, value, opts = {}) {
+    return `${type ? type + " " : ""}${midiPitchToNoteName(note, opts)} ${formatNumValue(value, opts)}`;
+  }
+  /** @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>} */
+  const formatters = {
+    noteOn({ value1: note, value2: velocity = eventMapping.noteOn.defaults[1] }, opts = {}) {
+      return formatNoteType(opts?.noMinify ? shorthands.noteOn : undefined, note, velocity, opts);
+    },
+    noteOff({ value1: note }, opts = {}) {
+      return formatNoteType(opts?.noMinify ? shorthands.noteOff : undefined, note, 0, opts);
+    },
+    polyTouch({ value1: note, value2: value = eventMapping.polyTouch.defaults[1] }, opts = {}) {
+      return formatNoteType(shorthands.polyTouch, note, value, opts);
+    },
+    cc({ value1: cc, value2: value }, opts) {
+      return formatDefault(shorthands.cc, cc, value, opts);
+    },
+    programChange({ value1: program }, opts) {
+      return formatDefault(shorthands.programChange, program, undefined, opts);
+    },
+    channelPressure: ({ value1: value }, opts) => formatDefault(shorthands.channelPressure, value, undefined, opts),
+    pitchBend({ value1 = 0, value2 = 64 }, opts) {
+      return `${shorthands.pitchBend} ${formatHighResValue(value1, value2, opts)}`;
+    },
+    songPosition({ value1 = 0, value2 = 0 }, opts) {
+      return `${shorthands.songPosition} ${formatHighResValue(value1, value2, opts)}`;
+    },
+    songSelect: ({ value1 }, opts) => formatDefault(shorthands.songSelect, value1, undefined, opts),
+    // tuneRequest: () => shorthands.tuneRequest,
+    continue: () => shorthands.continue,
+    activeSensing: () => shorthands.activeSensing,
+    clock: () => shorthands.clock,
+    start: () => shorthands.start,
+    stop: () => shorthands.stop,
+    reset: () => shorthands.reset
+  };
+
+  const PREFIX_CHANNEL = "ch";
+  const PREFIX_DEVICE = "dev";
+  const PREFIX_WHEN = "@";
+  const PREFIX_POS = 'pos=';
+  const PREFIX_DURATION = 'beats=';
+  /** Used when creating lists - treat ~ as empty no value */
+  const REST_LITERAL = '~';
+
+  // FUTURE - convert everything after data1/data2 to an iterator to parse tokens so they don't need to be in specific order
+  // FUTURE - support unicode note durations https://en.wikipedia.org/wiki/Musical_Symbols_(Unicode_block)
+  const midiStringRegex = /^\s*(?<type>[a-zA-Z]{2,})?\s*(?<pitch>[A-G][#b♯♭_]*-?\d?)?\s*(?<data1>\b-?[0-9a-f]{1,5}\b)?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(ch=?(?<channel>[0-9a-f]{1,2}))?\s*(dev=?(?<device>[0-9a-f]))?\s*((@|time=)\s*(?<time>[\d:.]+))?\s*((pos|offset)=(?<pos>[\d./]+))?\s*((beats|dur)=(?<dur>[\d:./]+))?\s*$/;
+
+  /**
+   * 
+   * @param {MidiEvent} event 
+   * @param {FormatOptions} opts 
+   * @returns 
+   */
+  function midiToString(event, opts = {}) {
+    const { noMinify } = opts;
+    let type = shorthands[event.type];
+    const formatter = formatters[event.type];
+    if (!formatter) {
+      console.debug(`unknown event type ${event.type}`);
+      return "";
+    }
+    let msg = formatter(event, opts);
+    if (event.channel != undefined || noMinify) {
+      msg += formatChannel(event.channel, opts);
+    }
+    if (event.device || noMinify) {
+      msg += formatDevice(event.device, opts);
+    }
+    if (event.time != undefined) {
+      msg += formatTime(event, opts);
+    }
+    if (event.pos) {
+      msg += formatPosition(event.pos, opts);
+    }
+    if (event.dur) {
+      msg += formatDuration(event.dur, opts);
+    }
+    return msg;
+  }
+
+  /**
+   * convert a string representation of a note to a midievent
+   * @param {string} text 
+   * @param {FormatOptions} opts 
+   * @returns {MidiEvent}
+   */
+  function stringToMidi(text, opts = {}) {
+    const match = midiStringRegex.exec(text);
+    if (!match?.groups) return null;
+    let {
+      type: shorthand,
+      pitch,
+      data1,
+      data2,
+      channel: rawChannel,
+      device: rawDevice,
+      time,
+      pos,
+      dur
+    } = match.groups;
+    const value1 = data1 ? parseNumValue(data1, undefined, opts) : undefined;
+    const value2 = data2 ? parseNumValue(data2, undefined, opts) : undefined;
+    /** @type {EventType | 'rest'} */
+    let type = normalizeType(shorthand);
+
+    if (!type && shorthand === REST_LITERAL) {
+      type = 'rest';
+    }
+    type || (type = "noteOn" /* Note */);
+    const spec = eventMapping[type];
+    /** @type {MidiEvent} */
+    const event = {
+      type,
+      channel: parseNumValue(rawChannel, undefined, opts),
+      device: parseNumValue(rawDevice, undefined, opts)
+    };
+    if (time) {
+      event.time = parseTimespan(time);
+    }
+    if (pos) {
+      event.pos = parseFraction(pos);
+      // REVIEW is this right?
+      event.time = (event.time || 0) + event.pos;
+    }
+    if (dur) {
+      event.dur = parseFraction(dur);
+    }
+    switch (type) {
+      case "noteOn" /* Note */:
+      case "noteOff" /* NoteOff */:
+      case "polyTouch" /* NoteAftertouch */:
+        const note = pitch ? noteNameToMidiPitch(pitch, opts.defaultOctave) : value1 || null;
+        if (note == null) return null;
+        const velocity = pitch ? value1 : value2;
+        if (event.type !== "polyTouch" /* NoteAftertouch */ && velocity == 0) {
+          event.type = "noteOff" /* NoteOff */;
+        }
+        event.value1 = note;
+        event.value2 = velocity ?? 64;
+        break;
+      case "cc" /* CC */:
+        if (value1 == undefined || value2 == undefined) return null;
+        event.value1 = value1;
+        event.value2 = value2;
+        break;
+      case "programChange" /* ProgramChange */:
+      case "channelPressure" /* ChannelPressure */:
+      case "songSelect" /* SongSelect */:
+        event.value1 = value1 || 0;
+        break;
+      case "songPosition" /* SongPosition */:
+      case "pitchBend" /* PitchBend */:
+        if (value1 == undefined) return null;
+        const { value: highResValue, ...normedValues } = parseHighResValue(value1, value2);
+        Object.assign(event, normedValues);
+        event[spec.highResParam ?? "value"] = highResValue;
+        break;
+      case "clock" /* Clock */:
+      case "start" /* Start */:
+      case "continue" /* Continue */:
+      case "stop" /* Stop */:
+      case "activeSensing" /* ActiveSensing */:
+      case "reset" /* Reset */:
+        break;
+      case "rest":
+      // do nothing
+    }
+    if (spec?.param1 && event.value1 != undefined) {
+      event[spec.param1] = event.value1;
+    }
+    if (spec?.param2 && event.value2 != undefined) {
+      event[spec.param2] = event.value2;
+    }
+    return event;
+  }
+
+  function formatChannel(channel = 0, opts) {
+    const str = opts?.useHex ? formatHex(channel, 1) : channel.toFixed().padStart(2, "0");
+    return ` ${PREFIX_CHANNEL}${str}`;
+  }
+  function formatDevice(device = 0, opts) {
+    const str = opts?.useHex ? formatHex(device, 1) : device.toFixed();
+    return ` ${PREFIX_DEVICE}${str}`;
+  }
+  function formatTime({ time = undefined }, { noMinify = false, timestampFormat = "absolute", startTimestamp = 0 }) {
+    if (timestampFormat === "omit" || time == undefined) {
+      return "";
+    }
+    if (timestampFormat === "absolute") {
+      return ` ${PREFIX_WHEN}${time.toFixed(3)}`;
+    }
+    const ONE_DAY = 1e3 * 60 * 60 * 24;
+    let val = (time - startTimestamp) % ONE_DAY;
+    return ` ${PREFIX_WHEN}${formatTimespan(val)}`;
+  }
+
+  // TODO FUTURE add in opts flag to use fractions or not
+  function formatPosition(value, opts) {
+    return `${PREFIX_POS}${formatFraction(value)}`
+  }
+
+  // TODO FUTURE add in opts flag to use fractions or not
+  function formatDuration(value, opts) {
+    return `${PREFIX_DURATION}${formatFraction(value)}`
+  }
+
+
+  function formatTimespan(seconds, hoursOptional = true) {
+    const ms = 1e3 * (seconds % 1);
+    let t = Math.floor(seconds);
+    const s = t % 60;
+    const m = Math.floor(t / 60);
+    const h = Math.floor(t / 3600);
+    const parts = hoursOptional && h === 0 ? [m, s] : [h, m, s];
+    return `${parts.map((p) => p.toFixed(0).padStart(2, "0")).join(":")}.${ms.toFixed().padEnd(3, "0")}`;
+  }
+  /**
+   * 
+   * @param {string} text 
+   * @returns 
+   */
+  function parseTimespan(text) {
+    if (!text) return 0;
+    // split into [hh]:mm:ss.000 parts
+    const parts = text.split(':');
+    // somewhat unnecessarily clever method to sum [hh][mm][ss]
+    // by incrementing the scale from [1, 60, 3600].
+    // goes right to left because hours and minutes are optional
+    const [value] = parts.reduceRight(([acc, scale], part) => {
+      const val = (parseFloat(part) || 0) * scale;
+      return [acc + val, scale * 60];
+    }, [0, 1]);
+    return value;
+  }
+  function parseFraction(text) {
+    if (typeof text !== 'string') {
+      return +text || 0;
+    }
+    const [top, bottom] = text.split('/');
+    return (parseFloat(top) / (parseFloat(bottom) || 1)) || 0;
+  }
+  function formatFraction(value, threshold = 2e-3) {
+    for (let d of [4, 3, 10, 8, 1]) {
+      const numerator = value * d;
+      if (Math.abs(numerator % 1) <= threshold) {
+        return `${numerator}/${d}`;
+      }
+    }
+    // truncate to milliseconds (0.001)
+    return `${value}`.replace(/(\.\d{3})\d+$/, '$1');
+  }
+
+  function valueToMsbLsb(value) {
+    return {
+      value1: value & 127,
+      value2: value >> 7
+    };
+  }
+  function msbLsbToValue(lsb, msb) {
+    return (msb << 7) + lsb;
+  }
+  function parseHighResValue(value1, value2) {
+    const value = typeof value2 == undefined ? value1 : msbLsbToValue(value1, value2);
+    return {
+      value,
+      ...valueToMsbLsb(value)
+    };
+  }
+  function formatHighResValue(value1, value2, opts = {}) {
+    if (opts?.useHex) {
+      return `${shorthands.pitchBend} ${formatHex(value1)} ${formatHex(value2)}`;
+    }
+    const value = msbLsbToValue(value1, value2);
+    let txt = value.toFixed();
+    if (opts?.fixedWidth) {
+      txt = txt.padStart(5, " ");
+    }
+    return txt;
+  }
+
+  /**
+   * 
+   * @param {Uint8Array} data 
+   * @returns {MidiEvent | null}
+   */
+  function rawMessageToMidi(data) {
+    const [commandAndChannel, value1, value2] = data;
+    const channel = commandAndChannel % 16;
+    const command = commandAndChannel - channel;
+    const type = commandLookup.get(command);
+    if (!type) {
+      console.debug("unknown command type", command);
+      return null;
+    }
+    /** @type {MidiEvent} */
+    const event = {
+      type,
+      channel: channel + 1,
+      ...value1 != undefined && { value1 },
+      ...value2 != undefined && { value2 }
+    };
+    const spec = eventMapping[type];
+    if (spec?.param1 && event.value1 != undefined) {
+      event[spec.param1] = event.value1;
+    }
+    if (spec?.param2 && event.value2 != undefined) {
+      event[spec.param2] = event.value2;
+    }
+    if (spec.highResParam) {
+      const { value } = parseHighResValue(value1, value2);
+      event[spec.highResParam] = value;
+    }
+    return event;
+  }
+  /**
+   * 
+   * @param {MidiEvent} event
+   * @returns {Uint8Array}
+   */
+  function midiToRawMessage(event) {
+    let {
+      type,
+      value1,
+      value2,
+      channel = 1
+    } = event;
+    const spec = eventMapping[type];
+    // return empty if not valid event
+    if (!spec) return new Uint8Array();
+    const commandAndChannel = spec.command + Math.max(channel - 1, 0);
+    if (spec.param1 && value1 == undefined) {
+      value1 = (event[spec.param1] ?? spec.defaults?.[0]) || 0;
+    }
+    if (spec.param2 && value2 == undefined) {
+      value2 = (event[spec.param2] ?? spec.defaults?.[1]) ?? undefined;
+    }
+    if (spec.highResParam && event.value != undefined) {
+      const highRes = parseHighResValue(event.value);
+      [value1, value2] = [highRes.value1, highRes.value2];
+    }
+    return new Uint8Array([commandAndChannel, value1, ...(value2 !== undefined ? [value2] : [])]);
+  }
+  /**
+   * 
+   * @param {Pick<MidiEvent, 'time' | 'pos' | 'dur'>} event 
+   * @param {number} [offsetMs] time to return relative to. Default is now
+   */
+  function getMidiOffsetTime(event, offsetMs = window.performance.now()) {
+    const { pos = 0, dur } = event;
+    return {
+      start: offsetMs + (pos * 1000),
+      ...(dur > 0) && {
+        end: offsetMs + ((pos + dur) * 1000)
+      }
+    };
+  }
+  function isPitchedEvent(type) {
+    return !!type && (type === "noteOn" /* Note */ || type === "noteOff" /* NoteOff */ || type === "polyTouch" /* NoteAftertouch */);
+  }
+
+  // Make a full array of notes in full midi range from 0 (C-1) to 127 (G-9)
+  const MIDI_NOTES = "_".repeat(11).split('')
+    .flatMap((_, i) => SHARPS.map(c => `${c}${i - 1}`))
+    .slice(0, 128);
+
+  const ANY_TYPE = "*";
+  const eventProps = {
+    type: { key: "type", text: Scratch.translate("Event Type") },
+    pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
+    velocity: { key: "velocity", type: "noteOn" /* Note */, text: Scratch.translate("Velocity") },
+    ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
+    ccValue: { key: "value", type: "cc" /* CC */, text: Scratch.translate("CC Value") },
+    channel: { key: "channel", text: Scratch.translate("Channel") },
+    device: { key: "device", text: Scratch.translate("Device") },
+    pitchbend: { key: "value", type: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
+    aftertouch: { key: "value", type: "polyTouch" /* NoteAftertouch */, text: Scratch.translate("Aftertouch") },
+    time: { key: "time", text: Scratch.translate("Timestamp") }
+  };
+
+  // src/midi/midi-backend.ts
+  class MidiBackend extends EventTarget {
+    constructor() {
+      super();
+      this.status = "pending" /* Initial */;
+      /** @type {MIDIInput[]} */
+      this.inputs = [];
+      /** @type {MIDIOutput[]} */
+      this.outputs = [];
+      this._init = undefined;
+      /** @type {MidiEvent} */
+      this._defaultOutputEvent = {
+        type: 'noteOn',
+        channel: 1,
+        device: 0,
+        pitch: 60,
+        dur: 0.5,
+        velocity: 196
+      }
+      // TIP! If you use arrow functions on class methos then 'this' is automatically bound correctly, even if using as event listener
+      this.refreshDevices = () => {
+        for (const input of this.access.inputs.values()) {
+          if (!this.inputs.some((d) => d.id === input.id)) {
+            input.addEventListener("midimessage", this._onInputEvent);
+            input.addEventListener("statechange", this._onDeviceStateChange);
+            this.inputs.push(input);
+          }
+        }
+        for (const output of this.access.outputs.values()) {
+          if (!this.outputs.some((d) => d.id === output.id)) {
+            this.outputs.push(output);
+          }
+        }
+      };
+      this._onDeviceStateChange = (event) => {
+        const { port } = event;
+        if (!port) return;
+        const { type, id, name } = port;
+        const deviceList = type === "input" ? this.inputs : this.outputs;
+        const index = deviceList.findIndex((dev) => dev.id === id);
+        if (index === -1) {
+          this.refreshDevices();
+          return;
+        }
+        this._emit("device:status", { index, id, name, type, state: port.state });
+      };
+      this._onInputEvent = (event) => {
+        const {
+          target: device,
+          data,
+          timeStamp
+        } = event;
+        if (!data) return;
+        const deviceIndex = this.inputs.indexOf(device);
+        const midiEvent = rawMessageToMidi(data);
+        if (!midiEvent) {
+          console.warn("Unable to parse message", data);
+          this._emit("midi:unhandled", event);
+          return;
+        } else {
+          midiEvent.time = timeStamp / 1000;
+          if (deviceIndex !== -1) {
+            midiEvent.device = deviceIndex;
+          }
+          midiEvent._str = midiToString(midiEvent, { noMinify: true });
+          this._emit("midi", midiEvent);
+        }
+      };
+    }
+    get defaultInput() {
+      return this.inputs.find(d => d.state === 'connected');
+    }
+    get defaultOutput() {
+      return this.outputs.find(d => d.state === 'connected');
+    }
+    async initialize({ sysex = false, force = false, timeoutMS = 1e3 * 30 } = {}) {
+      if (this._init && !force) {
+        return this._init;
+      }
+      if (!navigator.requestMIDIAccess) {
+        return false;
+      }
+      return this._init = (async () => {
+        this.status = "initializing" /* Initializing */;
+        this._emit("status", { status: this.status });
+        try {
+          let timer;
+          const whenTimeout = new Promise((resolve, reject) => {
+            timer = setTimeout(() => reject(new DOMException("Timeout waiting for midi access")), timeoutMS);
+          });
+          const midiAccess = await Promise.race([
+            navigator.requestMIDIAccess({ sysex }),
+            whenTimeout
+          ]);
+          clearTimeout(timer);
+          this.access = midiAccess;
+          midiAccess.addEventListener("statechange", this.refreshDevices);
+          this.refreshDevices();
+          this.status = "connected" /* Connected */;
+          return true;
+        } catch (error) {
+          console.warn("Request failure", error);
+          if (sysex) {
+            return this.initialize({ sysex: false, force: true, timeoutMS });
+          }
+          this.status = "error" /* Error */;
+          return false;
+        } finally {
+          this._emit("status", { status: this.status });
+        }
+      })();
+    }
+    /**
+     * 
+     * @param {MidiEvent | string | number} event
+     * @param {MidiEvent} [defaults]
+     * @param {FormatOptions} [formatOpts]
+     */
+    sendOutputEvent(event, defaults = this._defaultOutputEvent, formatOpts = {}) {
+      /** @type {MidiEvent} */
+      let data;
+      // midi pitch = noteon now for 1/2 beat
+      if (typeof event === 'number') {
+        data = {
+          ...defaults,
+          pitch: event
+        };
+      } else if (typeof event === 'string') {
+        data = {
+          ...defaults,
+          ...stringToMidi(event, formatOpts)
+        };
+      } else if (typeof event === 'object') {
+        data = event;
+      } else {
+        throw new TypeError('Invalid data to send to output - must be midievent object, string or number');
+      }
+
+      // ignore, just placebo rest event
+      if (data.type === 'rest') {
+        return false;
+      }
+
+      const device = (data.device != undefined && this.outputs[data.device]) || this.defaultOutput;
+      if (!device) {
+        // no output. Should this throw error?
+        return false;
+      }
+      // ensure 0 velocity is interpreted as noteOff
+      if (data.type === 'noteOn' && data.velocity === 0) {
+        data.type = 'noteOff';
+      }
+
+      // TODO be able to specify offset time to calculate from?
+      const { start, end } = getMidiOffsetTime(data);
+      let raw = midiToRawMessage(data);
+      device.send(raw, start);
+      // also send off event
+      if (data.type === 'noteOn' && end) {
+        /** @type {MidiEvent} */
+        const offEvent = {
+          ...data,
+          type: 'noteOff',
+          value2: 0,
+          velocity: 0
+        };
+        raw = midiToRawMessage(offEvent);
+        device.send(raw, end);
+      }
+
+      // Keep track of notes so stop events can be sent if necessary
+      this._trackActiveNotes(data, device);
+    }
+
+    /**
+     * Stop all notes on all devices and clear pending
+     */
+    panic() {
+      for (let [device, active] of this._activeNotes.entries()) {
+        if (device.state !== 'connected') continue;
+        for (let key of active) {
+          const [channel, pitch] = key.split('_');
+          const raw = midiToRawMessage({
+            type: 'noteOff',
+            channel: parseInt(channel, 10),
+            pitch: parseInt(pitch)
+          });
+          // console.debug(`Stopping note ${pitch} on ${channel}`);
+          device.send(raw);
+        }
+      }
+      this._activeNotes.clear();
+    }
+    /**
+     * Keep track of events sent to midi devices to allow panic stopping them if necessary
+     * @private
+     * @param {MidiEvent} event 
+     * @param {MIDIOutput} device
+     */
+    _trackActiveNotes(event, device) {
+      // NOTE - same default channel as midiToRawEvent, maybe default should be a magic value?
+      const { type, pitch, channel = 1 } = event;
+      if (!(type === 'noteOn' || type === 'noteOff')) {
+        return;
+      }
+      const key = `${channel}_${pitch}`;
+      if (!this._activeNotes.has(device)) {
+        this._activeNotes.set(device, new Set());
+      }
+      const list = this._activeNotes.get(device);
+      if (type === 'noteOn') {
+        list.add(key);
+      } else {
+        list.delete(key);
+      }
+    }
+    /** @type {Map<MIDIOutput, Set<string>>} */
+    _activeNotes = new Map();
+    _emit(name, data) {
+      const event = new CustomEvent(name, { detail: data });
+      this.dispatchEvent(event);
+    }
+    // @ts-ignore
+    _whenEvent(event, { target = this, signal, timeoutMS = 1e3 * 60 } = {}) {
+      const events = Array.isArray(event) ? event : [event];
+      let timer;
+      return new Promise((resolve, reject) => {
+        events.forEach((name) => target.addEventListener(name, resolve, { once: true, signal }));
+        timer = setTimeout(() => {
+          events.forEach((name) => target.removeEventListener(name, resolve));
+          reject(new DOMException("Timeout", "TimeoutError"));
+        }, timeoutMS);
+      }).finally(() => clearTimeout(timer));
+    }
+    on(type, callback, options) {
+      return super.addEventListener(type, callback, options);
+    }
+    off(type, callback) {
+      return super.removeEventListener(type, callback);
+    }
+  };
+
+  // src/midi/midi-recorder.ts
+  class MidiRecorder extends EventTarget {
+    constructor() {
+      super();
+      this.active = /* @__PURE__ */ new Map();
+      // REVIEW should this just be a {[key: channel]: Map()}  instead?
+      this.activeByChannel = /* @__PURE__ */ new Map();
+      this.ccs = {};
+      this.lastNotes = {};
+      this.buffer = [];
+      this.paused = false;
+      this.recordStart = 0;
+      // 5 minute record time should be safe...midi doesn't take up much memory
+      this.bufferSeconds = 60 * 5;
+      this.maxEntries = 256 * 256;
+    }
+    _now() {
+      return (globalThis.performance ? globalThis.performance.now() : Date.now()) / 1000;
+    }
+    /**
+     * REVIEW should record start be a protection against purging?
+     */
+    startRecording(waitForEvent = true) {
+      if (!waitForEvent) {
+        this.recordStart = this._now();
+      }
+      this.paused = false;
+    }
+    /**
+     * REVIEW should stop recording pause collecting events? probably bad
+     */
+    stopRecording() {
+      this.paused = true;
+      const { recordStart } = this;
+      this.recordStart = 0;
+      return recordStart ? this.buffer.filter((evt) => evt.when >= recordStart) : this.buffer;
+    }
+    /**
+     * add note to buffer
+     * @param evt 
+     * @param when -- note, only used for setting "when" of active notes...evt should already have time value
+     * @returns 
+     */
+    add(evt, when = this._now()) {
+      const doc = { ...evt, when };
+      if (!this.paused) {
+        this.buffer.push(doc);
+        this._prune(when);
+      }
+      switch (evt.type) {
+        case "noteOn" /* Note */:
+          this._onNoteOn(evt);
+          break;
+        case "noteOff" /* NoteOff */:
+          this._onNoteOff(doc);
+          break;
+        case "polyTouch" /* NoteAftertouch */:
+          this._onNoteTouch(doc);
+          break;
+        case "cc" /* CC */:
+          Object.assign(this.ccs, {
+            [`${evt.cc}_${evt.channel}`]: evt,
+            [`${evt.cc}`]: evt
+          });
+          break;
+      }
+    }
+    _onNoteOn(evt) {
+      if (evt.pitch == undefined) return;
+      this.active.set(evt.pitch, evt);
+      this.lastNotes[`${evt.pitch}`] = evt;
+      if (evt.channel) {
+        this.lastNotes[`${evt.pitch}_${evt.channel}`] = evt;
+      }
+      this.activeByChannel.set(channelKeyForEvent(evt.pitch, evt.channel), evt);
+    }
+    _onNoteOff(evt) {
+      const { pitch, channel } = evt;
+      if (pitch == undefined) return;
+      const key = channelKeyForEvent(pitch, channel);
+      const existing = this.activeByChannel.get(key) || this.active.get(pitch);
+      if (!existing) return;
+      existing.duration = evt.when - existing.when;
+      this.active.delete(pitch);
+      this.activeByChannel.delete(key);
+    }
+    _onNoteTouch(evt) {
+      const { pitch, channel } = evt;
+      if (pitch == undefined) return;
+      const key = channelKeyForEvent(pitch, channel);
+      const existing = this.activeByChannel.get(key) || this.active.get(pitch);
+      if (!existing) return;
+      existing.aftertouch = evt.value;
+    }
+    isNoteActive(pitch, channel) {
+      if (channel == undefined) {
+        return this.active.has(pitch);
+      }
+      const key = channelKeyForEvent(pitch, channel);
+      return this.activeByChannel.has(key);
+    }
+    getActiveNote(pitch, channel) {
+      if (pitch == undefined) {
+        const list = this.getActiveNotes(channel);
+        return list.length == 0 ? undefined : list.reduce((a, b) => a.when > b.when ? a : b);
+      }
+      if (channel == undefined) {
+        return this.active.get(pitch);
+      }
+      const key = channelKeyForEvent(pitch, channel);
+      return this.activeByChannel.get(key);
+    }
+    getActiveNotes(channel) {
+      if (channel == undefined) {
+        return [...this.active.values()];
+      }
+      return [...this.activeByChannel.values()].filter((c) => c.channel == channel);
+      ;
+    }
+    clear(newStartTime = 0) {
+      this.lastNotes = {};
+      this.active.clear();
+      this.activeByChannel.clear();
+      this.ccs = {};
+      this.recordStart = newStartTime;
+      // remove old events
+      this._prune(newStartTime + this.bufferSeconds);
+    }
+    getRange(start = this.recordStart ?? 0, end) {
+      const first = this.buffer.findIndex((e) => (e.time ?? e.when) >= start);
+      if (!end) {
+        return this.buffer.slice(first);
+      }
+      const last = findLastIndex(this.buffer, (e) => (e.time ?? e.when) <= end);
+      return this.buffer.slice(first, last);
+    }
+    getLastEvent(channel) {
+      return this.getLast(undefined, undefined, channel);
+    }
+    getLastNote(pitch, channel) {
+      return this.getLast("noteOn" /* Note */, pitch, channel);
+    }
+    getLastCC(cc, channel) {
+      return this.getLast("cc" /* CC */, cc, channel);
+    }
+    getLastAftertouch(pitch, channel) {
+      return this.getLast("polyTouch" /* NoteAftertouch */, pitch, channel);
+    }
+    getLast(type, value1, channel) {
+      if (type === value1 === channel === undefined) {
+        return this.buffer[this.buffer.length - 1];
+      }
+      if (type === "cc" /* CC */ && value1) {
+        const key = channel != undefined ? `${value1}_${channel}` : `${value1}`;
+        const foundCC = this.ccs[key];
+        if (foundCC) return foundCC;
+      }
+      for (let i = this.buffer.length - 1; i >= 0; i--) {
+        const evt = this.buffer[i];
+        if (value1 != undefined && evt.value1 != value1) continue;
+        if (channel != undefined && evt.channel != channel) continue;
+        if (type) {
+          const eType = evt.type;
+          const isType = Array.isArray(type) ? type.includes(eType) : type === eType;
+          if (!isType) continue;
+        }
+        return evt;
+      }
+    }
+    *streamLast(type) {
+      for (let i = this.buffer.length; i >= 0; i--) {
+        const evt = this.buffer[i];
+        if (type && evt.type != type) continue;
+        yield evt;
+      }
+    }
+    _prune(when = this._now()) {
+      this.recordStart || (this.recordStart = when);
+      const threshold = when - this.bufferSeconds;
+      const n = this.buffer.length;
+      if (this.buffer.length > this.maxEntries) {
+        this.buffer = this.buffer.slice(-1 * this.maxEntries);
+      }
+      const firstNonStaleEvent = this.buffer.findIndex((e) => e.when >= threshold);
+      if (firstNonStaleEvent === -1) {
+        this.buffer = [];
+      } else {
+        this.buffer = this.buffer.slice(firstNonStaleEvent);
+      }
+    }
+  };
+  // polyfill for findLastIndex for 5% of browsers without it
+  const findLastIndex = (arr, cb) => {
+    if (typeof arr.findLastIndex === 'function') {
+      return arr.findLastIndex(cb);
+    }
+    let i = arr.length - 1;
+    while (i > -1 && !cb(arr[i], i, arr)) {
+      i -= 1;
+    }
+    return i;
+  }
+
+  function channelKeyForEvent(value = 0, channel = 0) {
+    return msbLsbToValue(value, channel);
+  }
+
+  // src/midi/midi-thread.ts
+  const TARGET_MIDI_KEY = "_midi";
+  /**
+   * 
+   * @param {import("scratch-vm").Thread} thread 
+   * @returns {MidiEvent | undefined}
+   */
+  function getThreadMidiValue(thread) {
+    return thread[TARGET_MIDI_KEY];
+  }
+  function setThreadMidiValue(thread, evt) {
+    thread[TARGET_MIDI_KEY] = evt;
+  }
+  function setThreadActiveNotes(thread, value) {
+    thread._activeNotes = value;
+  }
+  function getThreadActiveNotes(thread) {
+    return thread._activeNotes;
+  }
+  /**
+   * Get the current tempo.
+   * @return {number} - the current tempo, in beats per minute.
+   */
+  function getTempo() {
+    const stage = Scratch.vm.runtime.getTargetForStage();
+    if (stage) {
+      return stage.tempo;
+    }
+    return 60;
+  }
+  function beatsToSeconds(beats = 1, tempo = getTempo()) {
+    return beats * 60 / tempo;
+  }
+  function secondsToBeats(seconds = 1, tempo = getTempo()) {
+    return seconds * tempo / 60;
+  }
+
+  //#endregion
+
+  //#region Scratch Extension
+
+  const HATS = {
+    NOTE: `${EXT_ID}_whenNoteOnOff`,
+    NOTEANY: `${EXT_ID}_whenAnyNoteOnOff`,
+    MIDI: `${EXT_ID}_whenMidiEvent`
+  };
+  /** @type {'---'} */
+  const SEPARATOR = '---';
+  const { Cast } = Scratch;
+  class MidiExtension {
+    constructor() {
+      this.midi = new MidiBackend();
+      this.recorder = new MidiRecorder();
+      this._ensureInitialize = (evt) => {
+        if (this.midi.status === "pending" /* Initial */) {
+          this.initialize().catch(() => {
+          });
+        }
+      };
+      this._addListeners();
+      // globalThis.midiExt = this;
+      const vm = Scratch.vm;
+      vm.runtime.once("BEFORE_EXECUTE", this._ensureInitialize);
+    }
+    /**
+     * This helper actually glues together the extension with the MidiBackend / recorder. In particular it triggers HATS when incoming midi events occur
+     */
+    _addListeners() {
+      const vm = globalThis.Scratch.vm;
+      this.midi.on("midi", (domEvent) => {
+        const midiEvent = domEvent.detail;
+        this.recorder.add(midiEvent);
+        const threads = vm.runtime.startHats(HATS.MIDI);
+        // set the thread local variable to the passed in midi event for use with the "input event" reporter
+        for (let thread of threads) {
+          setThreadMidiValue(thread, midiEvent);
+        }
+        switch (midiEvent.type) {
+          case "noteOn":
+          case "noteOff":
+            vm.runtime.startHats(HATS.NOTE);
+            vm.runtime.startHats(HATS.NOTEANY);
+            break;
+          // case "cc" /* CC */:
+          //   vm.runtime.startHats(HATS.CC);
+          //   break;
+        }
+      });
+    }
+    getInfo() {
+      const EVENT_TYPES_ITEMS = [
+        { value: "noteOn" /* Note */, text: Scratch.translate("Note On") },
+        { value: "noteOff" /* NoteOff */, text: Scratch.translate("Note Off") },
+        { value: "cc" /* CC */, text: Scratch.translate("CC") },
+        { value: "polyTouch" /* NoteAftertouch */, text: Scratch.translate("AfterTouch") },
+        { value: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
+        { value: "programChange" /* ProgramChange */, text: Scratch.translate("Program Change") },
+        { value: "channelPressure" /* ChannelPressure */, text: Scratch.translate("Channel Pressure") }
+      ];
+
+      return {
+        id: EXT_ID,
+        name: Scratch.translate("Midi"),
+        menuIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
+        blockIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
+        blocks: [
+          // {
+          //   opcode: "initialize",
+          //   text: Scratch.translate("Initialize force? [FORCE]"),
+          //   blockType: Scratch.BlockType.COMMAND,
+          //   arguments: {
+          //     FORCE: {
+          //       type: Scratch.ArgumentType.NUMBER,
+          //       defaultValue: 1
+          //     }
+          //   }
+          // },
+          {
+            opcode: "numDevices",
+            text: Scratch.translate("number of [DEVICE_TYPE] devices"),
+            blockType: Scratch.BlockType.REPORTER,
+            arguments: {
+              DEVICE_TYPE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: 'DEVICE_TYPES',
+                defaultValue: 'input'
+              }
+            }
+          },
+          {
+            opcode: "getDeviceInfo",
+            text: Scratch.translate("[DEVICE_PROP] of [DEVICE_TYPE] device at [INDEX]"),
+            blockType: Scratch.BlockType.REPORTER,
+            arguments: {
+              DEVICE_PROP: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "DEVICE_PROPS",
+                defaultValue: "name"
+              },
+              DEVICE_TYPE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: 'DEVICE_TYPES',
+                defaultValue: 'input'
+              },
+              INDEX: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              }
+            }
+          },
+          SEPARATOR,
+          {
+            opcode: "whenNoteOnOff",
+            blockType: Scratch.BlockType.HAT,
+            text: Scratch.translate("when note [NOTE] [PRESS]"),
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              PRESS: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "NOTE_EVENT_TYPE",
+                defaultValue: ANY_TYPE
+              }
+            }
+          },
+          {
+            opcode: "whenAnyNoteOnOff",
+            blockType: Scratch.BlockType.HAT,
+            text: Scratch.translate("when any note [PRESS]"),
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            arguments: {
+              PRESS: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "NOTE_EVENT_TYPE",
+                defaultValue: ANY_TYPE
+              }
+            }
+          },
+          {
+            opcode: "whenMidiEvent",
+            blockType: Scratch.BlockType.HAT,
+            text: Scratch.translate("when input event [TYPE]"),
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            arguments: {
+              TYPE: {
+                menu: "EVENT_TYPES_OPTIONAL",
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: ANY_TYPE
+              }
+            }
+          },
+          {
+            opcode: "lastEvent",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Input Event"),
+            disableMonitor: true,
+            allowDropAnywhere: true
+          },
+          {
+            opcode: "getEventProp",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("[PROP] of [EVENT]"),
+            arguments: {
+              EVENT: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "note C4 82 ch1 dev0 @1000"
+              },
+              PROP: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "type",
+                menu: "PROPS"
+              }
+            }
+          },
+          {
+            opcode: "isNoteActive",
+            blockType: Scratch.BlockType.BOOLEAN,
+            text: Scratch.translate("Is Note [NOTE] Pressed?"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              CHANNEL: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "CHANNELS",
+                defaultValue: "0"
+              }
+            }
+          },
+          {
+            opcode: "isEventOfType",
+            blockType: Scratch.BlockType.BOOLEAN,
+            text: Scratch.translate("Is input event [TYPE]?"),
+            arguments: {
+              TYPE: {
+                menu: "EVENT_TYPES",
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "noteOn"
+              }
+            }
+          },
+          SEPARATOR,
+          {
+            opcode: "getActiveNotes",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Active Notes")
+          },
+          {
+            opcode: "numActiveNotes",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("length of active notes")
+          },
+          {
+            opcode: "getActiveNoteByIndex",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Note [INDEX] of active notes"),
+            arguments: {
+              INDEX: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              }
+            }
+          },
+          {
+            opcode: "setActiveNoteList",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("Set list [LIST] to Active Notes"),
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              }
+            }
+          },
+          SEPARATOR,
+          {
+            opcode: "playNoteForBeats",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("play midi note [NOTE] for [BEATS] beats"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              BEATS: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0.25
+              }
+            }
+          },
+          {
+            opcode: "sendOutputEvent",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("schedule [EVENT] for [POS] beats from now"),
+            arguments: {
+              EVENT: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "Eb4 beats=1/4"
+              },
+              POS: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              }
+            }
+          },
+          {
+            opcode: "makeOutputNote",
+            blockType: Scratch.BlockType.REPORTER,
+            // FUTURE - event_types has "any" type...should rename to EVENT_TYPES_OPTIONAL and make EVENT_TYPES that doesn't have "any"
+            text: Scratch.translate("Note [NOTE] Duration [BEATS] Volume [VELOCITY]% [CHANNEL] [DEVICE]"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              BEATS: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0.25
+              },
+              VELOCITY: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 96
+              },
+              CHANNEL: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "CHANNELS",
+                defaultValue: "1"
+              },
+              DEVICE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "OUTPUT_DEVICES"
+              }
+            }
+          },
+          {
+            opcode: "makeOutputEvent",
+            blockType: Scratch.BlockType.REPORTER,
+            // FUTURE - event_types has "any" type...should rename to EVENT_TYPES_OPTIONAL and make EVENT_TYPES that doesn't have "any"
+            text: Scratch.translate("Event [TYPE] [VALUE1] [VALUE2] [CHANNEL] [DEVICE]"),
+            arguments: {
+              TYPE: {
+                menu: "EVENT_TYPES",
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: 'cc'
+              },
+              VALUE1: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              },
+              VALUE2: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              },
+              CHANNEL: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "CHANNELS",
+                defaultValue: "1"
+              },
+              DEVICE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "OUTPUT_DEVICES"
+              }
+            }
+          },
+          {
+            opcode: "stopAllNotes",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("stop all notes on output devices")
+          },
+          SEPARATOR,
+
+          {
+            opcode: "noteForName",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("MIDI Note # [NOTE]"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "NOTE_NAMES",
+                defaultValue: "C4"
+              }
+            }
+          },
+          {
+            opcode: "nameForNote",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Pitch Name of [NOTE] (use [ACCIDENTAL])"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              ACCIDENTAL: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "ACCIDENTALS",
+                defaultValue: 'sharps'
+              }
+            }
+          },
+          {
+            opcode: "normalizeMidiVal",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Scale MIDI Value [VALUE] to min=[MIN] max=[MAX]"),
+            arguments: {
+              VALUE: { type: Scratch.ArgumentType.NUMBER, defaultValue: 0 },
+              MIN: { type: Scratch.ArgumentType.NUMBER, defaultValue: -1 },
+              MAX: { type: Scratch.ArgumentType.NUMBER, defaultValue: 1 }
+            }
+          },
+          {
+            opcode: "eventToJSON",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Convert MIDI Event [EVENT] to JSON"),
+            arguments: {
+              EVENT: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "note Eb4 96 pos=0.25 beats=1/4"
+              }
+            }
+          },
+          {
+            opcode: "jsonToEvent",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Convert JSON [JSON] to MIDI Event"),
+            arguments: {
+              JSON: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}'
+              }
+            }
+          },
+          SEPARATOR,
+          {
+            opcode: "getMidiStartTime",
+            text: Scratch.translate("MIDI Start Time"),
+            blockType: Scratch.BlockType.REPORTER
+          },
+          {
+            opcode: "getMidiCurrentTime",
+            text: Scratch.translate("MIDI Current Time"),
+            blockType: Scratch.BlockType.REPORTER
+          },
+          {
+            opcode: "clearEvents",
+            text: Scratch.translate("Clear event buffer"),
+            blockType: Scratch.BlockType.COMMAND,
+            arguments: {
+              TIME: {
+                type: Scratch.ArgumentType.NUMBER
+              }
+            }
+          },
+          {
+            opcode: "setMidiEventList",
+            text: Scratch.translate("Set list [LIST] to events in last [TIME] seconds"),
+            blockType: Scratch.BlockType.COMMAND,
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              TIME: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 5
+              }
+            }
+          }
+        ],
+        menus: {
+          EVENT_TYPES: {
+            acceptReporters: true,
+            items: EVENT_TYPES_ITEMS
+          },
+          EVENT_TYPES_OPTIONAL: {
+            acceptReporters: true,
+            items: [
+              ...EVENT_TYPES_ITEMS,
+              { value: ANY_TYPE, text: Scratch.translate("Any") }
+            ]
+          },
+          INPUT_DEVICES: {
+            acceptReporters: true,
+            items: "inputDevicesMenu"
+          },
+          OUTPUT_DEVICES: {
+            acceptReporters: true,
+            items: "outputDevicesMenu"
+          },
+          DEVICE_TYPES: {
+            acceptReporters: true,
+            items: [
+              { value: 'input', text: Scratch.translate("input") },
+              { value: 'output', text: Scratch.translate("output") },
+            ]
+          },
+          DEVICE_PROP: {
+            acceptReporters: true,
+            items: [
+              { value: "id", text: Scratch.translate("Device ID") },
+              { value: "manufacturer", text: Scratch.translate("Manufacturer") },
+              { value: "name", text: Scratch.translate("Device Name") },
+              { value: "state", text: Scratch.translate("State") }
+            ]
+          },
+          NOTE_EVENT_TYPE: {
+            acceptReporters: true,
+            items: [
+              { value: ANY_TYPE, text: Scratch.translate("Note On/Off") },
+              { value: "noteOn" /* Note */, text: Scratch.translate("Note On") },
+              { value: "noteOff" /* NoteOff */, text: Scratch.translate("Note Off") }
+            ]
+          },
+          ACCIDENTALS: {
+            acceptReporters: true,
+            items: [
+              { value: "sharps", text: `♯ ${Scratch.translate("Sharps")}` },
+              { value: "flats", text: `♭ ${Scratch.translate("Flats")}` }
+            ]
+          },
+          NOTE_NAMES: {
+            acceptReporters: true,
+            // the result of these don't need translation - they're just "C4" or "G#6"
+            items: [...MIDI_NOTES.entries()]
+              .map(([index, text]) => ({ value: `${index}`, text }))
+          },
+          CHANNELS: {
+            acceptReporters: true,
+            items: [
+              { value: "0", text: Scratch.translate("any channel") },
+              ..."0".repeat(15).split("").map((_, i) => ({ value: `${i + 1}`, text: `channel ${i + 1}` }))
+            ]
+          },
+          PROPS: {
+            acceptReporters: true,
+            items: Object.entries(eventProps).map(([value, { text }]) => ({ value, text }))
+          },
+          DEVICE_PROPS: {
+            acceptReporters: true,
+            items: [
+              { value: "id", text: Scratch.translate("Id") },
+              { value: "name", text: Scratch.translate("Name") },
+              { value: "state", text: Scratch.translate("State") },
+              { value: "manufacturer", text: Scratch.translate("Manufacturer") }
+            ]
+          },
+          // taken from /Lily/ListTools.js
+          lists: {
+            acceptReporters: true,
+            items: "_getLists",
+          },
+        }
+      };
+    }
+    // taken from /Lily/ListTools.js
+    _getLists() {
+      if (typeof Blockly === "undefined") {
+        return [""];
+      }
+      const lists = Blockly.getMainWorkspace()
+        .getVariableMap()
+        // @ts-expect-error - Blockly not typed yet
+        .getVariablesOfType("list")
+        .map((model) => model.name);
+
+      if (lists.length > 0) {
+        return lists;
+      } else {
+        return [""];
+      }
+    }
+    async initialize({ sysex = false, FORCE = false } = {}, util) {
+      const force = Cast.toBoolean(FORCE);
+      await this.midi.initialize({ sysex, force });
+    }
+    _isAnyArg(val) {
+      return val == undefined || val == "" || val == ANY_TYPE || typeof val === "string" && /^\*|any$/i.test(val);
+    }
+    numDevices({ DEVICE_TYPE }) {
+      this._ensureInitialize();
+      const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
+      const deviceList = deviceType === 'output' ? this.midi.outputs : this.midi.inputs;
+
+      return deviceList.length;
+    }
+    numOutputDevices() {
+      this._ensureInitialize();
+      return this.midi.outputs.length;
+    }
+    getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
+      const index = Cast.toNumber(INDEX);
+      const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
+      const deviceList = deviceType === 'input' ? this.midi.inputs : this.midi.outputs;
+      const device = deviceList[index];
+      if (!device) return "";
+      return device[DEVICE_PROP];
+    }
+    inputDevicesMenu() {
+      const inputList = this.midi.inputs.map((d) => ({ text: d.name || d.id, value: d.id }));
+      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(inputList);
+    }
+    outputDevicesMenu() {
+      const outputList = this.midi.outputs.map((d) => ({ text: d.name || d.id, value: d.id }));
+      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(outputList);
+    }
+    whenNoteOnOff({ NOTE, PRESS }, util) {
+      const isAny = this._isAnyArg(PRESS);
+      let type = isAny ? ['noteOn', 'noteOff'] : [normalizeType(Scratch.Cast.toString(PRESS))];
+
+      const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
+      const last = this.recorder.getLast();
+
+      // filter if only note on or note off
+      if (last &&
+        type.includes(last.type) &&
+        (pitch === undefined || last.pitch === pitch)
+      ) {
+        setThreadMidiValue(util.thread, last);
+        return true;
+      }
+
+      return false;
+    }
+    whenAnyNoteOnOff({ PRESS }, util) {
+      const isAny = this._isAnyArg(PRESS);
+      let type = isAny ? ['noteOn', 'noteOff'] : [normalizeType(Scratch.Cast.toString(PRESS))];
+
+      const last = this.recorder.getLast();
+      // filter if only note on or note off
+      if (last && type.includes(last.type)) {
+        setThreadMidiValue(util.thread, last);
+        return true;
+      }
+
+      return false;
+    }
+    whenMidiEvent({ TYPE }, util) {
+      const isAny = this._isAnyArg(TYPE);
+      const type = isAny ? undefined : normalizeType(Scratch.Cast.toString(TYPE));
+      const last = this.recorder.getLast();
+      if (last && (isAny || last.type === type)) {
+        setThreadMidiValue(util.thread, last);
+        return !!last;
+      }
+      return false;
+    }
+    /**
+     * 
+     * @param {MidiEvent} event
+     * @returns {MidiEvent}
+     */
+    _eventBeatsToSeconds(event) {
+      const tempo = getTempo();
+      const { dur, pos } = event;
+      const out = { ...event };
+      if (dur != undefined) {
+        out.dur = beatsToSeconds(parseFraction(dur), tempo);
+      }
+      if (pos != undefined) {
+        out.pos = beatsToSeconds(parseFraction(pos), tempo);
+      }
+      return out;
+    }
+    playNoteForBeats({ NOTE, BEATS }, util) {
+      const pitch = noteNameToMidiPitch(Cast.toString(NOTE)) || undefined;
+      const beats = typeof BEATS === 'string' && BEATS.includes('/')
+        ? parseFraction(BEATS)
+        : Cast.toNumber(BEATS);
+
+      const event = this._eventBeatsToSeconds({
+        type: 'noteOn',
+        ...(pitch != undefined) && { pitch },
+        dur: beats
+      });
+      this.midi.sendOutputEvent(event);
+    }
+    sendOutputEvent({ EVENT, POS }, util) {
+      const text = Cast.toString(EVENT);
+      const pos = typeof POS === 'string' && POS.includes('/')
+        ? parseFraction(POS)
+        : Cast.toNumber(POS);
+      const event = this._eventBeatsToSeconds({
+        // default value is 0, so if event has something set (like "C#3 pos=1/4 beats=1") then let it take precedence, otherwise override
+        ...(pos > 0) && { pos },
+        ...stringToMidi(text),
+      });
+
+      this.midi.sendOutputEvent(event);
+    }
+    stopAllNotes() {
+      this.midi.panic();
+    }
+    getEventProp({ EVENT, PROP }, util) {
+      const propName = Cast.toString(PROP);
+      const { key = "value", type } = eventProps[propName] ?? {};
+      if (!EVENT) return "";
+      const last = getThreadMidiValue(util.thread);
+      // use cached thread value if available instead of re-parsing
+      const evt = last?._str === EVENT
+        ? last
+        : stringToMidi(EVENT);
+
+      return evt?.[key] ?? "";
+    }
+    lastEvent(args, util) {
+      let last = getThreadMidiValue(util.thread);
+      last || (last = this.recorder.getLast());
+      return last ? midiToString(last) : "";
+    }
+    isNoteActive({ NOTE, CHANNEL }, util) {
+      const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
+      const channel = Cast.toNumber(CHANNEL) || undefined;
+      if (pitch == undefined) {
+        const notes = this.recorder.getActiveNotes(channel);
+        setThreadActiveNotes(util.thread, { channel, notes });
+        return notes.length == 0 ? undefined : notes.reduce((a, b) => a.when > b.when ? a : b);
+      }
+      const note = this.recorder.getActiveNote(pitch, channel || undefined);
+      if (note) {
+        setThreadMidiValue(util.thread, note);
+      }
+      return !!note;
+    }
+    isEventOfType({ TYPE }, util) {
+      const type = TYPE === ANY_TYPE ? undefined : TYPE;
+      let last = getThreadMidiValue(util.thread);
+      last || (last = this.recorder.getLast());
+      return last?.type === type;
+    }
+    noteForName({ NOTE }) {
+      if (typeof NOTE === "number" || /^\d+$/.test(NOTE)) {
+        return Cast.toNumber(NOTE);
+      }
+      const name = Cast.toString(NOTE);
+      return noteNameToMidiPitch(name) || 0;
+    }
+    nameForNote({ NOTE, ACCIDENTAL }, util) {
+      const useFlats = Cast.toString(ACCIDENTAL) === 'flats';
+      let val = Cast.toNumber(NOTE);
+      if (!val && /^[a-g]/i.test(`${NOTE}`)) {
+        val = noteNameToMidiPitch(Cast.toString(NOTE)) || 0;
+      }
+      return midiPitchToNoteName(val, { useFlats });
+    }
+    makeOutputNote({ NOTE, BEATS, VELOCITY, CHANNEL, DEVICE }) {
+      let dur = typeof BEATS === 'string' && BEATS.includes('/')
+        ? parseFraction(BEATS)
+        : Cast.toNumber(BEATS);
+      // sanity check - don't let a note be more than 1 minute
+      // if anyone ever needs a longer note then they should manually write event string
+      dur = Math.max(0, Math.min(dur, 60));
+      // convert from percent to midi value
+      let velocity = (Cast.toNumber(VELOCITY) / 100) * 127;
+      // clamp value
+      // NOTE - if 0 velocity then nothing will happen because treated as note off
+      velocity = Math.max(0, Math.min(velocity, 127));
+      // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
+      const deviceId = Cast.toString(DEVICE);
+      const device = this.midi.outputs.findIndex(d => d.id === deviceId);
+      /** @type {MidiEvent} */
+      const event = {
+        type: 'noteOn',
+        pitch: this.noteForName({ NOTE }),
+        velocity,
+        channel: Cast.toNumber(CHANNEL) || undefined,
+        device: device === -1 ? undefined : device,
+        dur
+      };
+      return midiToString(event);
+    }
+    makeOutputEvent({ TYPE, VALUE1, VALUE2, CHANNEL, DEVICE }) {
+      /** @type {EventType} */
+      // @ts-ignore
+      let type = Cast.toString(TYPE);
+      // TODO make menu for EVENT_TYPE that doesn't include "any"
+      // default is CC - is that right?
+      // @ts-ignore
+      if (type === ANY_TYPE) type = "cc";
+      // UNDOCUMENTED - allow raw number for command.
+      // note that the command lookup restricts command types, so will exclude sysex messages (which are possible security risk but already blocked by browsers anyways)
+      let spec = eventMapping[type];
+      if (!spec && /(0x)?[a-f0-9]+/i.test(type)) {
+        const rawType = /[a-f]/.test(type)
+          ? parseInt(type, 16)
+          : parseInt(type);
+        type = commandLookup[rawType];
+      }
+
+      // clamp values
+      let value1 = Cast.toNumber(VALUE1);
+      // pitchbend can be a bigger number
+      const maxValue1 = spec?.highResParam ? 16384 : 127;
+      value1 = Math.max(0, Math.min(value1, maxValue1));
+
+      let value2 = Cast.toNumber(VALUE2);
+      value2 = Math.max(0, Math.min(value2, 127));
+
+      // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
+      const deviceId = Cast.toString(DEVICE);
+      const device = this.midi.outputs.findIndex(d => d.id === deviceId);
+      // FUTURE this may make sense to get moved out to helper alongside rawMessageToMidi
+      /** @type {MidiEvent} */
+      const event = {
+        type,
+        value1,
+        value2,
+        channel: Cast.toNumber(CHANNEL) || undefined,
+        device: device === -1 ? undefined : device,
+        ...spec?.param1 && { [spec.param1]: value1 },
+        ...spec?.param2 && { [spec.param2]: value2 },
+        ...spec?.highResParam && parseHighResValue(value1, value2)
+      };
+      return midiToString(event);
+    }
+    normalizeMidiVal({ VALUE, MIN, MAX }) {
+      const min = Cast.toNumber(MIN);
+      const max = Cast.toNumber(MAX);
+      const val = Cast.toNumber(VALUE) / 127;
+      return val * (max - min) + min;
+    }
+    getMidiStartTime() {
+      return this.recorder.recordStart;
+    }
+    getMidiCurrentTime() {
+      return this.recorder._now();
+    }
+    clearEvents(args, util) {
+      this.recorder.clear();
+    }
+    setMidiEventList({ LIST, TIME }, util) {
+      const duration = Cast.toNumber(TIME) || 5;
+      const start = this.recorder._now() - duration;
+      const events = this.recorder.getRange(start);
+      if (LIST) {
+        this._upsertList(LIST, events.map((evt) => evt._str), util.target);
+      }
+    }
+    getActiveNotes(args, util) {
+      const notes = Array.from(this.recorder.getActiveNotes());
+      setThreadActiveNotes(util.thread, { notes });
+      return notes.map((note) => note._str ?? midiToString(note)).join("\n");
+    }
+    getActiveNoteByIndex({ INDEX }, util) {
+      const index = Cast.toNumber(INDEX) || 0;
+      let active = getThreadActiveNotes(util.thread);
+      if (!active) {
+        active = { notes: this.recorder.getActiveNotes() };
+        setThreadActiveNotes(util.thread, active);
+      }
+      const note = (active.notes || [])[index];
+      if (note) {
+        setThreadMidiValue(util.thread, note);
+        return note._str;
+      }
+      return '';
+    }
+    setActiveNoteList({ LIST }, util) {
+      const notes = Array.from(this.recorder.getActiveNotes());
+      setThreadActiveNotes(util.thread, { notes });
+      if (LIST) {
+        this._upsertList(LIST, notes.map((note) => note._str), util.target);
+      }
+    }
+    _upsertList(name, value, target) {
+      const vm = globalThis.Scratch.vm;
+      const stageTarget = vm.runtime.getTargetForStage();
+      let listObj = stageTarget?.lookupVariableByNameAndType(name, "list");
+      listObj || (listObj = target?.lookupVariableByNameAndType(name, "list"));
+      if (listObj) {
+        listObj.value = value;
+      }
+    }
+    numActiveNotes(args, util) {
+      let active = getThreadActiveNotes(util.thread);
+      if (!active) {
+        active = { notes: this.recorder.getActiveNotes() };
+        setThreadActiveNotes(util.thread, active);
+      }
+      return active.notes.length;
+    }
+    eventToJSON({ EVENT }, util) {
+      const raw = Cast.toString(EVENT);
+      // NOTE will be null if could not parse
+      const event = stringToMidi(raw);
+      // QUESTION does this need an error handler?
+      return JSON.stringify(event);
+    }
+    jsonToEvent({ JSON }, util) {
+      const raw = Cast.toString(JSON);
+      let event = null;
+      try {
+        event = {
+          ...JSON.parse(raw)
+        };
+        // rename aliases just in case
+        [['beats', 'dur'], ['offset', 'pos'], ['@', 'time']]
+          .filter(([alias, key]) => (alias in event) && event[key] == undefined)
+          .forEach(([alias, key]) => event[key] = event[alias]);
+      } catch (error) { }
+      return event ? midiToString(event) : ""
+    }
+  };
+  Scratch.extensions.register(new MidiExtension());
+})(Scratch);
\ No newline at end of file

From 0be617ea73f22109c6ad948134fa55a7fb5fdc82 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Fri, 7 Mar 2025 00:34:37 -0500
Subject: [PATCH 02/61] updated midi.js - tweak string/parsing/formatting

use "t=<time>" instead of "@<time>". Allow using "type=note pitch=60" instead of "note 60" if need to be verbose. Some bugfixes
---
 extensions/midi/midi.js | 198 ++++++++++++++++++++++++----------------
 1 file changed, 119 insertions(+), 79 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index dbec4a46c6..c44b0ee08a 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -82,23 +82,24 @@
     const height = octave ? parseInt(octave, 10) : defaultOctave;
     return chroma + ((height + 1) * 12);
   }
-  function parseNumValue(text, defaultValue, opts) {
-    if (!text) return defaultValue;
+  function parseNumValue(text, opts) {
+    if (typeof text === 'number') return text;
+    if (!text) return undefined;
     text = text.trim();
-    const useHex = opts?.useHex ?? /[a-f]/.test(text);
+    const useHex = opts?.useHex ?? /[a-f]/i.test(text);
     const radix = useHex ? 16 : 10;
     const val = parseInt(text, radix);
-    return isNaN(val) ? defaultValue : val;
+    return isNaN(val) ? undefined : val;
   }
   function formatHex(value, pad = 2) {
     return Math.round(value).toString(16).padStart(pad, "0");
   }
 
   const eventMapping = {
-    ["noteOn" /* Note */]: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
-    ["noteOff" /* NoteOff */]: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
+    ["noteOn"]: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
+    ["noteOff"]: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
     ["cc" /* CC */]: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
-    ["polyTouch" /* NoteAftertouch */]: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
+    ["polyTouch"]: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
     ["programChange" /* ProgramChange */]: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
     ["pitchBend" /* PitchBend */]: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
     ["channelPressure" /* ChannelPressure */]: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
@@ -121,6 +122,14 @@
     ...Object.keys(eventMapping).map(key => [key.toLowerCase(), key])
   ]);
   const shorthands = Object.fromEntries(Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand]));
+  const paramLookup = {
+    type: 'type', note: 'pitch', pitch: 'pitch',
+    ch: 'channel', channel: 'channel',
+    dev: 'device', device: 'device',
+    t: 'time', time: 'time', "@": 'time',
+    dur: 'dur', duration: 'dur',
+    pos: 'pos', value: 'value2'
+  };
   /**
    * @param {string} value 
    * @returns {EventType | undefined}
@@ -163,10 +172,13 @@
       return formatDefault(shorthands.programChange, program, undefined, opts);
     },
     channelPressure: ({ value1: value }, opts) => formatDefault(shorthands.channelPressure, value, undefined, opts),
-    pitchBend({ value1 = 0, value2 = 64 }, opts) {
+    pitchBend({ value1, value2 }, opts) {
+      if (value1 == undefined) {
+        [value1, value2] = [0, 64];
+      }
       return `${shorthands.pitchBend} ${formatHighResValue(value1, value2, opts)}`;
     },
-    songPosition({ value1 = 0, value2 = 0 }, opts) {
+    songPosition({ value1 = 0, value2 }, opts) {
       return `${shorthands.songPosition} ${formatHighResValue(value1, value2, opts)}`;
     },
     songSelect: ({ value1 }, opts) => formatDefault(shorthands.songSelect, value1, undefined, opts),
@@ -181,7 +193,8 @@
 
   const PREFIX_CHANNEL = "ch";
   const PREFIX_DEVICE = "dev";
-  const PREFIX_WHEN = "@";
+  // const PREFIX_WHEN = "@";
+  const PREFIX_WHEN = 't=';
   const PREFIX_POS = 'pos=';
   const PREFIX_DURATION = 'beats=';
   /** Used when creating lists - treat ~ as empty no value */
@@ -200,16 +213,22 @@
   function midiToString(event, opts = {}) {
     const { noMinify } = opts;
     let type = shorthands[event.type];
+    const spec = eventMapping[event.type] ?? {};
+    // ensure these are set properly
+    const {
+      value1 = event[spec.param1] ?? event[spec.highResParam],
+      value2 = event[spec.param2]
+    } = event;
     const formatter = formatters[event.type];
     if (!formatter) {
       console.debug(`unknown event type ${event.type}`);
       return "";
     }
-    let msg = formatter(event, opts);
+    let msg = formatter({...event, value1, value2}, opts);
     if (event.channel != undefined || noMinify) {
       msg += formatChannel(event.channel, opts);
     }
-    if (event.device || noMinify) {
+    if (event.device != undefined || noMinify) {
       msg += formatDevice(event.device, opts);
     }
     if (event.time != undefined) {
@@ -231,72 +250,86 @@
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
-    const match = midiStringRegex.exec(text);
+    const fullRe = /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
+    const match = fullRe.exec(text);
     if (!match?.groups) return null;
+    // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
+    // ch/dev/@ (channel, device, time) are special keys that don't need =
+    const keyvalRe = /\s*(?<key>\w+(?=\=)|ch|dev|@)=?(?<val>\S+)\s*/g;
+    /** @type {{[K in keyof typeof paramLookup]?: keyof MidiEvent}} */
+    const extras = Object.fromEntries(
+      [...match.groups.keyvals?.matchAll(keyvalRe)]
+        // paramLookup converts "t=2" into "time=2"
+        .map(({groups: {key, val}}) => [paramLookup[key] || key, val])
+    );
     let {
-      type: shorthand,
-      pitch,
-      data1,
-      data2,
-      channel: rawChannel,
-      device: rawDevice,
-      time,
-      pos,
-      dur
+      type: shorthand = extras.type,
+      pitch = extras.pitch, data1, data2
     } = match.groups;
-    const value1 = data1 ? parseNumValue(data1, undefined, opts) : undefined;
-    const value2 = data2 ? parseNumValue(data2, undefined, opts) : undefined;
-    /** @type {EventType | 'rest'} */
-    let type = normalizeType(shorthand);
 
-    if (!type && shorthand === REST_LITERAL) {
-      type = 'rest';
-    }
-    type || (type = "noteOn" /* Note */);
-    const spec = eventMapping[type];
+    // midi value1 can be specified as pitch or as number
+    const value1 = pitch
+      ? noteNameToMidiPitch(pitch, opts.defaultOctave)
+      : parseNumValue(data1, opts);
+
+    let value2 = parseNumValue(data2, opts);
+
     /** @type {MidiEvent} */
     const event = {
-      type,
-      channel: parseNumValue(rawChannel, undefined, opts),
-      device: parseNumValue(rawDevice, undefined, opts)
+      type: shorthand === REST_LITERAL
+        ? 'rest'
+        : normalizeType(shorthand),
+      ...(value1 != undefined) && {value1},
+      ...(value2 != undefined) && {value2},
+      channel: parseNumValue(extras.ch ?? extras.channel, opts),
+      device: parseNumValue(extras.dev ?? extras.device, opts),
+      ...extras.time && { time: parseTimespan(extras.t ?? extras.time)},
+      // REVIEW is pos even needed? it's for setting output in beats, but setting time would make more sense instead
+      ...extras.pos && { pos: parseFraction(extras.pos)},
+      ...extras.dur && { dur: parseFraction(extras.dur)},
     };
-    if (time) {
-      event.time = parseTimespan(time);
-    }
-    if (pos) {
-      event.pos = parseFraction(pos);
-      // REVIEW is this right?
-      event.time = (event.time || 0) + event.pos;
-    }
-    if (dur) {
-      event.dur = parseFraction(dur);
-    }
-    switch (type) {
-      case "noteOn" /* Note */:
-      case "noteOff" /* NoteOff */:
-      case "polyTouch" /* NoteAftertouch */:
-        const note = pitch ? noteNameToMidiPitch(pitch, opts.defaultOctave) : value1 || null;
-        if (note == null) return null;
-        const velocity = pitch ? value1 : value2;
-        if (event.type !== "polyTouch" /* NoteAftertouch */ && velocity == 0) {
-          event.type = "noteOff" /* NoteOff */;
+
+    // default to note event if has pitch (off if velocity = 0)
+    if (!event.type && value1 >= 0) {
+      event.type = 'noteOn';
+    } else if (!event.type) {
+      // no type set, invalid input
+      return null;
+    }
+    const spec = eventMapping[event.type];
+    switch (event.type) {
+      case "noteOn":
+      case "noteOff":
+        if (value1 == undefined) return null;
+        if (value2 === 0) event.type = 'noteOff';
+        if (value2 == undefined) {
+          event.value2 = event.velocity ?? event.value ?? (event.type === 'noteOn' ? 96 : 0);
+        }
+        break;
+      case "polyTouch":
+        // these types have note pitch
+        if (event.value1 == undefined) return null;
+        if (value2 == undefined) {
+          event.value2 = event.value ?? event.velocity ?? 64;
         }
-        event.value1 = note;
-        event.value2 = velocity ?? 64;
         break;
-      case "cc" /* CC */:
+      case "cc":
+        if (value2 == undefined) {
+          event.value2 = event.value;
+          value2 = event.value2
+        }
         if (value1 == undefined || value2 == undefined) return null;
-        event.value1 = value1;
-        event.value2 = value2;
         break;
       case "programChange" /* ProgramChange */:
       case "channelPressure" /* ChannelPressure */:
       case "songSelect" /* SongSelect */:
-        event.value1 = value1 || 0;
+        // default to 0 for these types
+        event.value1 ||= event.value ?? 0;
         break;
       case "songPosition" /* SongPosition */:
       case "pitchBend" /* PitchBend */:
         if (value1 == undefined) return null;
+        // these two types have a higher precision value
         const { value: highResValue, ...normedValues } = parseHighResValue(value1, value2);
         Object.assign(event, normedValues);
         event[spec.highResParam ?? "value"] = highResValue;
@@ -311,6 +344,7 @@
       case "rest":
       // do nothing
     }
+    // look at eventMap to give 'friendly' names to value1/value2 (ex. "pitch", "velocity")
     if (spec?.param1 && event.value1 != undefined) {
       event[spec.param1] = event.value1;
     }
@@ -402,7 +436,7 @@
       value2: value >> 7
     };
   }
-  function msbLsbToValue(lsb, msb) {
+  function msbLsbToValue(lsb, msb = 0) {
     return (msb << 7) + lsb;
   }
   function parseHighResValue(value1, value2) {
@@ -501,7 +535,7 @@
     };
   }
   function isPitchedEvent(type) {
-    return !!type && (type === "noteOn" /* Note */ || type === "noteOff" /* NoteOff */ || type === "polyTouch" /* NoteAftertouch */);
+    return !!type && (type === "noteOn" || type === "noteOff" || type === "polyTouch");
   }
 
   // Make a full array of notes in full midi range from 0 (C-1) to 127 (G-9)
@@ -513,13 +547,13 @@
   const eventProps = {
     type: { key: "type", text: Scratch.translate("Event Type") },
     pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
-    velocity: { key: "velocity", type: "noteOn" /* Note */, text: Scratch.translate("Velocity") },
+    velocity: { key: "velocity", type: "noteOn", text: Scratch.translate("Velocity") },
     ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
     ccValue: { key: "value", type: "cc" /* CC */, text: Scratch.translate("CC Value") },
     channel: { key: "channel", text: Scratch.translate("Channel") },
     device: { key: "device", text: Scratch.translate("Device") },
     pitchbend: { key: "value", type: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
-    aftertouch: { key: "value", type: "polyTouch" /* NoteAftertouch */, text: Scratch.translate("Aftertouch") },
+    aftertouch: { key: "value", type: "polyTouch", text: Scratch.translate("Aftertouch") },
     time: { key: "time", text: Scratch.translate("Timestamp") }
   };
 
@@ -815,13 +849,13 @@
         this._prune(when);
       }
       switch (evt.type) {
-        case "noteOn" /* Note */:
+        case "noteOn":
           this._onNoteOn(evt);
           break;
-        case "noteOff" /* NoteOff */:
+        case "noteOff":
           this._onNoteOff(doc);
           break;
-        case "polyTouch" /* NoteAftertouch */:
+        case "polyTouch":
           this._onNoteTouch(doc);
           break;
         case "cc" /* CC */:
@@ -905,13 +939,13 @@
       return this.getLast(undefined, undefined, channel);
     }
     getLastNote(pitch, channel) {
-      return this.getLast("noteOn" /* Note */, pitch, channel);
+      return this.getLast("noteOn", pitch, channel);
     }
     getLastCC(cc, channel) {
       return this.getLast("cc" /* CC */, cc, channel);
     }
     getLastAftertouch(pitch, channel) {
-      return this.getLast("polyTouch" /* NoteAftertouch */, pitch, channel);
+      return this.getLast("polyTouch", pitch, channel);
     }
     getLast(type, value1, channel) {
       if (type === value1 === channel === undefined) {
@@ -1063,10 +1097,10 @@
     }
     getInfo() {
       const EVENT_TYPES_ITEMS = [
-        { value: "noteOn" /* Note */, text: Scratch.translate("Note On") },
-        { value: "noteOff" /* NoteOff */, text: Scratch.translate("Note Off") },
+        { value: "noteOn", text: Scratch.translate("Note On") },
+        { value: "noteOff", text: Scratch.translate("Note Off") },
         { value: "cc" /* CC */, text: Scratch.translate("CC") },
-        { value: "polyTouch" /* NoteAftertouch */, text: Scratch.translate("AfterTouch") },
+        { value: "polyTouch", text: Scratch.translate("AfterTouch") },
         { value: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
         { value: "programChange" /* ProgramChange */, text: Scratch.translate("Program Change") },
         { value: "channelPressure" /* ChannelPressure */, text: Scratch.translate("Channel Pressure") }
@@ -1395,16 +1429,16 @@
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "note Eb4 96 pos=0.25 beats=1/4"
+                defaultValue: "note Eb4 96 t=0.5 dur=0.25"
               }
             }
           },
           {
             opcode: "jsonToEvent",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Convert JSON [JSON] to MIDI Event"),
+            text: Scratch.translate("Convert JSON [TEXT] to MIDI Event"),
             arguments: {
-              JSON: {
+              TEXT: {
                 type: Scratch.ArgumentType.STRING,
                 defaultValue: '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}'
               }
@@ -1487,8 +1521,8 @@
             acceptReporters: true,
             items: [
               { value: ANY_TYPE, text: Scratch.translate("Note On/Off") },
-              { value: "noteOn" /* Note */, text: Scratch.translate("Note On") },
-              { value: "noteOff" /* NoteOff */, text: Scratch.translate("Note Off") }
+              { value: "noteOn", text: Scratch.translate("Note On") },
+              { value: "noteOff", text: Scratch.translate("Note Off") }
             ]
           },
           ACCIDENTALS: {
@@ -1862,11 +1896,17 @@
       const raw = Cast.toString(EVENT);
       // NOTE will be null if could not parse
       const event = stringToMidi(raw);
+
+      // REVIEW - remove value1/value2 if already specified by event spec?
+      if (event && ('pitch' in event || 'value' in event)) {
+        delete event.value1;
+        delete event.value2;
+      }
       // QUESTION does this need an error handler?
       return JSON.stringify(event);
     }
-    jsonToEvent({ JSON }, util) {
-      const raw = Cast.toString(JSON);
+    jsonToEvent({ TEXT }, util) {
+      const raw = Cast.toString(TEXT);
       let event = null;
       try {
         event = {

From 767e8dbd35618cfc0e0b17ca2eba9875cd3da109 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 10 Mar 2025 10:02:42 -0400
Subject: [PATCH 03/61] midi - cleanup comments and types

---
 extensions/midi/midi.js | 201 ++++++++++++++++++++++++++--------------
 1 file changed, 132 insertions(+), 69 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index c44b0ee08a..f682fbe04c 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -12,13 +12,15 @@
 
   const EXT_ID = "extmidi";
 
+//#region utils
+
   /** 
    * This section includes logic to map raw data coming from the 'midimessage'
    * event into a friendly object representation of the event
    * 
    * 
    * // definition for the parsed midi event
-   * @typedef {keyof typeof eventMapping} EventType
+   * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset'} EventType
    * @typedef {object} MidiEvent
    * @property {EventType | 'rest'} type
    * @property {number} [value1]
@@ -32,7 +34,7 @@
    * @property {number} [value]
    * @property {number} [pos]
    * @property {number} [dur]
-   * @property {string} [_str]
+   * @property {string} [_str] cached string representation of this event
    * 
    * 
    * @typedef {object} FormatOptions
@@ -44,6 +46,7 @@
    * @property {boolean} [fixedWidth]
    * @property {boolean} [useHex]
    * @property {number} [defaultOctave]
+   * 
    */
 
   /**
@@ -95,33 +98,52 @@
     return Math.round(value).toString(16).padStart(pad, "0");
   }
 
+  /**
+   * IMPORTANT! This mapping is key in translating raw midi messages to/from their object/string representation.
+   * @typedef {object} EventSpec Definition of midi event type and how to convert to/from raw midi
+   * @property {string} shorthand Short name used in string representation
+   * @property {number} command   Actual midi command bytes (1st byte along with channel)
+   * @property {string} description English description of type TODO - translate if ever exposed in UI
+   * @property {'pitch' | 'cc' | 'value'} [param1] - corresponding key for 2nd byte of raw message
+   * @property {'velocity' | 'value'} [param2] - corresponding key for 3rd byte of raw message
+   * @property {'value'} [highResParam] - corresponding key for "high res" param that goes from 0-16384 instead of 127
+   * @property {[data1: number, data2: number]} [defaults] - default values if not otherwise specified
+   */
+
+  /**
+   * @type {Record<EventType, EventSpec>}
+   */
   const eventMapping = {
-    ["noteOn"]: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
-    ["noteOff"]: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
-    ["cc" /* CC */]: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
-    ["polyTouch"]: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
-    ["programChange" /* ProgramChange */]: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
-    ["pitchBend" /* PitchBend */]: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
-    ["channelPressure" /* ChannelPressure */]: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
-    ["songPosition" /* SongPosition */]: { shorthand: "songpos", command: 242, description: "Song Position Pointer (Sys Common)", highResParam: "value" },
-    ["songSelect" /* SongSelect */]: { shorthand: "songsel", command: 243, description: "Song Select (Sys Common)", param1: "value" },
-    ["clock" /* Clock */]: { shorthand: "clock", command: 248, description: "Timing Clock (Sys Realtime)" },
-    ["start" /* Start */]: { shorthand: "start", command: 250, description: "Start (Sys Realtime)" },
-    ["continue" /* Continue */]: { shorthand: "continue", command: 251, description: "Continue (Sys Realtime)" },
-    ["stop" /* Stop */]: { shorthand: "stop", command: 252, description: "Stop (Sys Realtime)" },
-    ["activeSensing" /* ActiveSensing */]: { shorthand: "ping", command: 254, description: "Active Sensing (Sys Realtime)" },
-    ["reset" /* Reset */]: { shorthand: "reset", command: 255, description: "System Reset (Sys Realtime)" }
+    noteOn: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
+    noteOff: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
+    cc: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
+    polyTouch: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
+    programChange: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
+    pitchBend: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
+    channelPressure: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
+    songPosition: { shorthand: "songpos", command: 242, description: "Song Position Pointer (Sys Common)", highResParam: "value" },
+    songSelect: { shorthand: "songsel", command: 243, description: "Song Select (Sys Common)", param1: "value" },
+    clock: { shorthand: "clock", command: 248, description: "Timing Clock (Sys Realtime)" },
+    start: { shorthand: "start", command: 250, description: "Start (Sys Realtime)" },
+    continue: { shorthand: "continue", command: 251, description: "Continue (Sys Realtime)" },
+    stop: { shorthand: "stop", command: 252, description: "Stop (Sys Realtime)" },
+    activeSensing: { shorthand: "ping", command: 254, description: "Active Sensing (Sys Realtime)" },
+    reset: { shorthand: "reset", command: 255, description: "System Reset (Sys Realtime)" }
   };
   /** @type {Map<number, EventType>} */
   // @ts-ignore
   const commandLookup = new Map(Object.entries(eventMapping).map(([key, { command }]) => [command, key]));
   /** @type {Map<string, EventType>} */
-  // @ts-ignore
-  const shorthandLookup = Object.fromEntries([
+    const shorthandLookup = Object.fromEntries([
     ...Object.entries(eventMapping).map(([key, { shorthand }]) => [shorthand, key]),
     ...Object.keys(eventMapping).map(key => [key.toLowerCase(), key])
   ]);
   const shorthands = Object.fromEntries(Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand]));
+
+
+  /** aliases for MidiEvent keys
+   * the allows for more permissive translation of input strings, i.e. ch10 === channel=10
+   * @type {Record<string, keyof MidiEvent>} */
   const paramLookup = {
     type: 'type', note: 'pitch', pitch: 'pitch',
     ch: 'channel', channel: 'channel',
@@ -130,6 +152,16 @@
     dur: 'dur', duration: 'dur',
     pos: 'pos', value: 'value2'
   };
+  
+  // These are how different midi event keys are split. ch and dev are special cases that don't include =, since they're common. Other params use = to allow arbitrary additional properties if needed
+  const PREFIX_CHANNEL = "ch";
+  const PREFIX_DEVICE = "dev";
+  const PREFIX_WHEN = 't=';
+  const PREFIX_POS = 'pos=';
+  const PREFIX_DURATION = 'dur=';
+  /** Used when creating lists - treat ~ as empty no value */
+  const REST_LITERAL = '~';
+
   /**
    * @param {string} value 
    * @returns {EventType | undefined}
@@ -154,7 +186,10 @@
   function formatNoteType(type, note, value, opts = {}) {
     return `${type ? type + " " : ""}${midiPitchToNoteName(note, opts)} ${formatNumValue(value, opts)}`;
   }
-  /** @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>} */
+  /** 
+   * This is a mapping of midi events and their string representation
+   * @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>}
+   */
   const formatters = {
     noteOn({ value1: note, value2: velocity = eventMapping.noteOn.defaults[1] }, opts = {}) {
       return formatNoteType(opts?.noMinify ? shorthands.noteOn : undefined, note, velocity, opts);
@@ -191,21 +226,10 @@
     reset: () => shorthands.reset
   };
 
-  const PREFIX_CHANNEL = "ch";
-  const PREFIX_DEVICE = "dev";
-  // const PREFIX_WHEN = "@";
-  const PREFIX_WHEN = 't=';
-  const PREFIX_POS = 'pos=';
-  const PREFIX_DURATION = 'beats=';
-  /** Used when creating lists - treat ~ as empty no value */
-  const REST_LITERAL = '~';
-
-  // FUTURE - convert everything after data1/data2 to an iterator to parse tokens so they don't need to be in specific order
-  // FUTURE - support unicode note durations https://en.wikipedia.org/wiki/Musical_Symbols_(Unicode_block)
-  const midiStringRegex = /^\s*(?<type>[a-zA-Z]{2,})?\s*(?<pitch>[A-G][#b♯♭_]*-?\d?)?\s*(?<data1>\b-?[0-9a-f]{1,5}\b)?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(ch=?(?<channel>[0-9a-f]{1,2}))?\s*(dev=?(?<device>[0-9a-f]))?\s*((@|time=)\s*(?<time>[\d:.]+))?\s*((pos|offset)=(?<pos>[\d./]+))?\s*((beats|dur)=(?<dur>[\d:./]+))?\s*$/;
 
   /**
-   * 
+   * convert midi event to string.
+   * The opts includes more formatting options than available through the current scratch blocks available.
    * @param {MidiEvent} event 
    * @param {FormatOptions} opts 
    * @returns 
@@ -245,18 +269,20 @@
 
   /**
    * convert a string representation of a note to a midievent
+   * FUTURE - support unicode note durations? https://en.wikipedia.org/wiki/Musical_Symbols_(Unicode_block)
    * @param {string} text 
    * @param {FormatOptions} opts 
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
+    if (typeof text !== 'string') text = `${String(text) ?? ''}`;
     const fullRe = /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
     const match = fullRe.exec(text);
     if (!match?.groups) return null;
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
     // ch/dev/@ (channel, device, time) are special keys that don't need =
     const keyvalRe = /\s*(?<key>\w+(?=\=)|ch|dev|@)=?(?<val>\S+)\s*/g;
-    /** @type {{[K in keyof typeof paramLookup]?: keyof MidiEvent}} */
+    /** @type {{[K in keyof MidiEvent]?: string}} */
     const extras = Object.fromEntries(
       [...match.groups.keyvals?.matchAll(keyvalRe)]
         // paramLookup converts "t=2" into "time=2"
@@ -281,9 +307,9 @@
         : normalizeType(shorthand),
       ...(value1 != undefined) && {value1},
       ...(value2 != undefined) && {value2},
-      channel: parseNumValue(extras.ch ?? extras.channel, opts),
-      device: parseNumValue(extras.dev ?? extras.device, opts),
-      ...extras.time && { time: parseTimespan(extras.t ?? extras.time)},
+      channel: parseNumValue(extras.channel, opts),
+      device: parseNumValue(extras.device, opts),
+      ...extras.time && { time: parseTimespan(extras.time)},
       // REVIEW is pos even needed? it's for setting output in beats, but setting time would make more sense instead
       ...extras.pos && { pos: parseFraction(extras.pos)},
       ...extras.dur && { dur: parseFraction(extras.dur)},
@@ -320,26 +346,26 @@
         }
         if (value1 == undefined || value2 == undefined) return null;
         break;
-      case "programChange" /* ProgramChange */:
-      case "channelPressure" /* ChannelPressure */:
-      case "songSelect" /* SongSelect */:
+      case "programChange":
+      case "channelPressure":
+      case "songSelect":
         // default to 0 for these types
         event.value1 ||= event.value ?? 0;
         break;
-      case "songPosition" /* SongPosition */:
-      case "pitchBend" /* PitchBend */:
+      case "songPosition":
+      case "pitchBend":
         if (value1 == undefined) return null;
         // these two types have a higher precision value
         const { value: highResValue, ...normedValues } = parseHighResValue(value1, value2);
         Object.assign(event, normedValues);
         event[spec.highResParam ?? "value"] = highResValue;
         break;
-      case "clock" /* Clock */:
-      case "start" /* Start */:
-      case "continue" /* Continue */:
-      case "stop" /* Stop */:
-      case "activeSensing" /* ActiveSensing */:
-      case "reset" /* Reset */:
+      case "clock":
+      case "start":
+      case "continue":
+      case "stop":
+      case "activeSensing":
+      case "reset":
         break;
       case "rest":
       // do nothing
@@ -459,7 +485,7 @@
   }
 
   /**
-   * 
+   * parse raw input midi bytes
    * @param {Uint8Array} data 
    * @returns {MidiEvent | null}
    */
@@ -493,7 +519,7 @@
     return event;
   }
   /**
-   * 
+   * convert midi event into bytes expected by MidiOut.send
    * @param {MidiEvent} event
    * @returns {Uint8Array}
    */
@@ -521,7 +547,7 @@
     return new Uint8Array([commandAndChannel, value1, ...(value2 !== undefined ? [value2] : [])]);
   }
   /**
-   * 
+   * read the "pos" / "dur" values of an event as relative time vs. a fixed wall-clock time
    * @param {Pick<MidiEvent, 'time' | 'pos' | 'dur'>} event 
    * @param {number} [offsetMs] time to return relative to. Default is now
    */
@@ -543,21 +569,38 @@
     .flatMap((_, i) => SHARPS.map(c => `${c}${i - 1}`))
     .slice(0, 128);
 
+  /**
+   * represents "any note" or "any device" etc. in menus
+   */
   const ANY_TYPE = "*";
+  /**
+   * Scratch menu items of @see {MidiEvent} properties
+   */
   const eventProps = {
     type: { key: "type", text: Scratch.translate("Event Type") },
     pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
     velocity: { key: "velocity", type: "noteOn", text: Scratch.translate("Velocity") },
     ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
-    ccValue: { key: "value", type: "cc" /* CC */, text: Scratch.translate("CC Value") },
+    ccValue: { key: "value", type: "cc", text: Scratch.translate("CC Value") },
     channel: { key: "channel", text: Scratch.translate("Channel") },
     device: { key: "device", text: Scratch.translate("Device") },
-    pitchbend: { key: "value", type: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
+    pitchbend: { key: "value", type: "pitchBend", text: Scratch.translate("Pitch Bend") },
     aftertouch: { key: "value", type: "polyTouch", text: Scratch.translate("Aftertouch") },
     time: { key: "time", text: Scratch.translate("Timestamp") }
   };
 
-  // src/midi/midi-backend.ts
+//#endregion utils
+
+//#region wrapper
+  /**
+   * This is a singleton wrapper class around the WebMIDI API. It:
+   * 1) Handles requesting API permission and reporting Input/Output devices
+   * 2) Translate raw midi input events into friendlier @see {MidiEvent} objects
+   * 3) Sends out midi events, translating MidiEvents into the raw midi payload
+   * 4) Keeps track of "note on"/"note off" messages to support "panic" stopping midi output
+   * 
+   * It extends the native EventTarget class to dispatch events
+   */
   class MidiBackend extends EventTarget {
     constructor() {
       super();
@@ -576,7 +619,7 @@
         dur: 0.5,
         velocity: 196
       }
-      // TIP! If you use arrow functions on class methos then 'this' is automatically bound correctly, even if using as event listener
+      // TIP! If you use arrow functions on class methods then 'this' is automatically bound correctly, even if using as event listener
       this.refreshDevices = () => {
         for (const input of this.access.inputs.values()) {
           if (!this.inputs.some((d) => d.id === input.id)) {
@@ -799,7 +842,15 @@
     }
   };
 
-  // src/midi/midi-recorder.ts
+  /**
+   * this singleton keeps track of events in order to:
+   * 1) Report the "last" value for a given CC/note
+   * 2) Track "active" notes
+   * 3) Keep short term memory of events to avoid missing events because of scratch's slower event sample rate
+   * 4) Allow recording events for playback/storage
+   * 
+   * It keeps track of midi events, automatically pruning them after a certain time period or # of max entries have been reached (lazy, it doesn't actively poll)
+   */
   class MidiRecorder extends EventTarget {
     constructor() {
       super();
@@ -858,7 +909,7 @@
         case "polyTouch":
           this._onNoteTouch(doc);
           break;
-        case "cc" /* CC */:
+        case "cc":
           Object.assign(this.ccs, {
             [`${evt.cc}_${evt.channel}`]: evt,
             [`${evt.cc}`]: evt
@@ -942,7 +993,7 @@
       return this.getLast("noteOn", pitch, channel);
     }
     getLastCC(cc, channel) {
-      return this.getLast("cc" /* CC */, cc, channel);
+      return this.getLast("cc", cc, channel);
     }
     getLastAftertouch(pitch, channel) {
       return this.getLast("polyTouch", pitch, channel);
@@ -951,7 +1002,7 @@
       if (type === value1 === channel === undefined) {
         return this.buffer[this.buffer.length - 1];
       }
-      if (type === "cc" /* CC */ && value1) {
+      if (type === "cc" && value1) {
         const key = channel != undefined ? `${value1}_${channel}` : `${value1}`;
         const foundCC = this.ccs[key];
         if (foundCC) return foundCC;
@@ -1043,22 +1094,32 @@
     return seconds * tempo / 60;
   }
 
-  //#endregion
+  //#endregion wrapper
 
-  //#region Scratch Extension
+//#region Scratch Extension
 
+  // hardcoded mapping of hats events, b/c I'll never remember the convention otherwise
   const HATS = {
     NOTE: `${EXT_ID}_whenNoteOnOff`,
     NOTEANY: `${EXT_ID}_whenAnyNoteOnOff`,
     MIDI: `${EXT_ID}_whenMidiEvent`
+    // not currently implemented
+    // CC: `${EXT_ID}_whenCC`
   };
-  /** @type {'---'} */
+  /**
+   * Block separator constant
+   * @type {'---'}
+   */
   const SEPARATOR = '---';
   const { Cast } = Scratch;
+
   class MidiExtension {
     constructor() {
       this.midi = new MidiBackend();
       this.recorder = new MidiRecorder();
+      /**
+       * Lazy initialize midi - only upon first executing, and used in other calls to make sure it gets triggered
+       */
       this._ensureInitialize = (evt) => {
         if (this.midi.status === "pending" /* Initial */) {
           this.initialize().catch(() => {
@@ -1089,7 +1150,8 @@
             vm.runtime.startHats(HATS.NOTE);
             vm.runtime.startHats(HATS.NOTEANY);
             break;
-          // case "cc" /* CC */:
+          // FUTURE - support a "whenCC" block if needed
+          // case "cc":
           //   vm.runtime.startHats(HATS.CC);
           //   break;
         }
@@ -1099,11 +1161,11 @@
       const EVENT_TYPES_ITEMS = [
         { value: "noteOn", text: Scratch.translate("Note On") },
         { value: "noteOff", text: Scratch.translate("Note Off") },
-        { value: "cc" /* CC */, text: Scratch.translate("CC") },
+        { value: "cc", text: Scratch.translate("CC") },
         { value: "polyTouch", text: Scratch.translate("AfterTouch") },
-        { value: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
-        { value: "programChange" /* ProgramChange */, text: Scratch.translate("Program Change") },
-        { value: "channelPressure" /* ChannelPressure */, text: Scratch.translate("Channel Pressure") }
+        { value: "pitchBend", text: Scratch.translate("Pitch Bend") },
+        { value: "programChange", text: Scratch.translate("Program Change") },
+        { value: "channelPressure", text: Scratch.translate("Channel Pressure") }
       ];
 
       return {
@@ -1112,6 +1174,7 @@
         menuIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
         blockIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
         blocks: [
+          // FUTURE - could force requesting permissions and checking midi device status. Usually refreshing is safer option
           // {
           //   opcode: "initialize",
           //   text: Scratch.translate("Initialize force? [FORCE]"),
@@ -1321,7 +1384,6 @@
           {
             opcode: "makeOutputNote",
             blockType: Scratch.BlockType.REPORTER,
-            // FUTURE - event_types has "any" type...should rename to EVENT_TYPES_OPTIONAL and make EVENT_TYPES that doesn't have "any"
             text: Scratch.translate("Note [NOTE] Duration [BEATS] Volume [VELOCITY]% [CHANNEL] [DEVICE]"),
             arguments: {
               NOTE: {
@@ -1350,7 +1412,6 @@
           {
             opcode: "makeOutputEvent",
             blockType: Scratch.BlockType.REPORTER,
-            // FUTURE - event_types has "any" type...should rename to EVENT_TYPES_OPTIONAL and make EVENT_TYPES that doesn't have "any"
             text: Scratch.translate("Event [TYPE] [VALUE1] [VALUE2] [CHANNEL] [DEVICE]"),
             arguments: {
               TYPE: {
@@ -1920,5 +1981,7 @@
       return event ? midiToString(event) : ""
     }
   };
+
+//#endregion
   Scratch.extensions.register(new MidiExtension());
 })(Scratch);
\ No newline at end of file

From 2981a0f698d6d44cb8eac2c4321b1ee4b9a675f0 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 10 Mar 2025 10:28:31 -0400
Subject: [PATCH 04/61] Update midi.js

---
 extensions/midi/midi.js | 981 +++++++++++++++++++++++++---------------
 1 file changed, 617 insertions(+), 364 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index f682fbe04c..1fb8cac386 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -12,13 +12,13 @@
 
   const EXT_ID = "extmidi";
 
-//#region utils
+  //#region utils
 
-  /** 
+  /**
    * This section includes logic to map raw data coming from the 'midimessage'
    * event into a friendly object representation of the event
-   * 
-   * 
+   *
+   *
    * // definition for the parsed midi event
    * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset'} EventType
    * @typedef {object} MidiEvent
@@ -35,8 +35,8 @@
    * @property {number} [pos]
    * @property {number} [dur]
    * @property {string} [_str] cached string representation of this event
-   * 
-   * 
+   *
+   *
    * @typedef {object} FormatOptions
    * @property {number} [tempo]
    * @property {boolean} [useFlats]
@@ -46,7 +46,7 @@
    * @property {boolean} [fixedWidth]
    * @property {boolean} [useHex]
    * @property {number} [defaultOctave]
-   * 
+   *
    */
 
   /**
@@ -55,13 +55,16 @@
    * https://www.midi.org/specifications/item/table-1-summary-of-midi-message
    *
    * adapted from https://github.com/fheyen/musicvis-lib/blob/905edbdc8280e8ca76a329ffc83a160f3cda674a/src/fileFormats/Midi.js#L41
-   * 
+   *
    * each key (the "EventType" relates to a raw midi "command". The "shorthand" could
    * be used to format midi events to string (future). param1 and param2 determine what property of the object the value1 + value2 bytes mean (i.e. noteOn gets pitch + velocity, cc gets cc# and value)
    */
   const SHARPS = "C C# D D# E F F# G G# A A# B".split(" ");
   const FLATS = "C Db D Eb E F Gb G Ab A Bb B".split(" ");
-  function midiPitchToNoteName(midi, { useFlats = false, fixedWidth = false } = {}) {
+  function midiPitchToNoteName(
+    midi,
+    { useFlats = false, fixedWidth = false } = {}
+  ) {
     if (!isFinite(midi)) return "";
     let chroma = (useFlats ? FLATS : SHARPS)[midi % 12];
     if (fixedWidth) chroma = chroma.padEnd(2, "_");
@@ -70,23 +73,30 @@
   }
   /**
    * convert a note string name (or raw midi number) to midi number value
-   * @param {string} note 
-   * @param {number} [defaultOctave] 
+   * @param {string} note
+   * @param {number} [defaultOctave]
    * @returns {number | null}
    */
   function noteNameToMidiPitch(note, defaultOctave = 4) {
-    const parts = /(?<pitch>[A-G])(?<flat>[b♭]+)?(?<sharp>[#♯]+)?_?(?<octave>-?\d+)?/i.exec(note || '');
+    const parts =
+      /(?<pitch>[A-G])(?<flat>[b♭]+)?(?<sharp>[#♯]+)?_?(?<octave>-?\d+)?/i.exec(
+        note || ""
+      );
     if (!parts?.groups) {
-      const numVal = typeof note === 'string' ? parseInt(note.trim(), 10) : +note;
-      return (numVal >= 0 && numVal <= 127) ? numVal : null;
+      const numVal =
+        typeof note === "string" ? parseInt(note.trim(), 10) : +note;
+      return numVal >= 0 && numVal <= 127 ? numVal : null;
     }
     const { pitch, octave, flat, sharp } = parts.groups;
-    let chroma = SHARPS.indexOf(pitch.toUpperCase()) - (flat?.length || 0) + (sharp?.length || 0);
+    let chroma =
+      SHARPS.indexOf(pitch.toUpperCase()) -
+      (flat?.length || 0) +
+      (sharp?.length || 0);
     const height = octave ? parseInt(octave, 10) : defaultOctave;
-    return chroma + ((height + 1) * 12);
+    return chroma + (height + 1) * 12;
   }
   function parseNumValue(text, opts) {
-    if (typeof text === 'number') return text;
+    if (typeof text === "number") return text;
     if (!text) return undefined;
     text = text.trim();
     const useHex = opts?.useHex ?? /[a-f]/i.test(text);
@@ -114,56 +124,147 @@
    * @type {Record<EventType, EventSpec>}
    */
   const eventMapping = {
-    noteOn: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
-    noteOff: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
-    cc: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
-    polyTouch: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
-    programChange: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
-    pitchBend: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
-    channelPressure: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
-    songPosition: { shorthand: "songpos", command: 242, description: "Song Position Pointer (Sys Common)", highResParam: "value" },
-    songSelect: { shorthand: "songsel", command: 243, description: "Song Select (Sys Common)", param1: "value" },
-    clock: { shorthand: "clock", command: 248, description: "Timing Clock (Sys Realtime)" },
-    start: { shorthand: "start", command: 250, description: "Start (Sys Realtime)" },
-    continue: { shorthand: "continue", command: 251, description: "Continue (Sys Realtime)" },
-    stop: { shorthand: "stop", command: 252, description: "Stop (Sys Realtime)" },
-    activeSensing: { shorthand: "ping", command: 254, description: "Active Sensing (Sys Realtime)" },
-    reset: { shorthand: "reset", command: 255, description: "System Reset (Sys Realtime)" }
+    noteOn: {
+      shorthand: "note",
+      command: 144,
+      description: "Note-on",
+      param1: "pitch",
+      param2: "velocity",
+      defaults: [60, 96],
+    },
+    noteOff: {
+      shorthand: "off",
+      command: 128,
+      description: "Note-off",
+      param1: "pitch",
+      param2: "velocity",
+      defaults: [60, 0],
+    },
+    cc: {
+      shorthand: "cc",
+      command: 176,
+      description: "Continuous controller",
+      param1: "cc",
+      param2: "value",
+      defaults: [0, 0],
+    },
+    polyTouch: {
+      shorthand: "touch",
+      command: 160,
+      description: "Aftertouch",
+      param1: "pitch",
+      param2: "value",
+      defaults: [60, 64],
+    },
+    programChange: {
+      shorthand: "program",
+      command: 192,
+      description: "Patch change",
+      param1: "value",
+    },
+    pitchBend: {
+      shorthand: "bend",
+      command: 224,
+      description: "Pitch bend",
+      highResParam: "value",
+    },
+    channelPressure: {
+      shorthand: "pressure",
+      command: 208,
+      description: "Channel Pressure",
+      param1: "value",
+    },
+    songPosition: {
+      shorthand: "songpos",
+      command: 242,
+      description: "Song Position Pointer (Sys Common)",
+      highResParam: "value",
+    },
+    songSelect: {
+      shorthand: "songsel",
+      command: 243,
+      description: "Song Select (Sys Common)",
+      param1: "value",
+    },
+    clock: {
+      shorthand: "clock",
+      command: 248,
+      description: "Timing Clock (Sys Realtime)",
+    },
+    start: {
+      shorthand: "start",
+      command: 250,
+      description: "Start (Sys Realtime)",
+    },
+    continue: {
+      shorthand: "continue",
+      command: 251,
+      description: "Continue (Sys Realtime)",
+    },
+    stop: {
+      shorthand: "stop",
+      command: 252,
+      description: "Stop (Sys Realtime)",
+    },
+    activeSensing: {
+      shorthand: "ping",
+      command: 254,
+      description: "Active Sensing (Sys Realtime)",
+    },
+    reset: {
+      shorthand: "reset",
+      command: 255,
+      description: "System Reset (Sys Realtime)",
+    },
   };
   /** @type {Map<number, EventType>} */
   // @ts-ignore
-  const commandLookup = new Map(Object.entries(eventMapping).map(([key, { command }]) => [command, key]));
+  const commandLookup = new Map(
+    Object.entries(eventMapping).map(([key, { command }]) => [command, key])
+  );
   /** @type {Map<string, EventType>} */
-    const shorthandLookup = Object.fromEntries([
-    ...Object.entries(eventMapping).map(([key, { shorthand }]) => [shorthand, key]),
-    ...Object.keys(eventMapping).map(key => [key.toLowerCase(), key])
+  const shorthandLookup = Object.fromEntries([
+    ...Object.entries(eventMapping).map(([key, { shorthand }]) => [
+      shorthand,
+      key,
+    ]),
+    ...Object.keys(eventMapping).map((key) => [key.toLowerCase(), key]),
   ]);
-  const shorthands = Object.fromEntries(Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand]));
-
+  const shorthands = Object.fromEntries(
+    Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand])
+  );
 
   /** aliases for MidiEvent keys
    * the allows for more permissive translation of input strings, i.e. ch10 === channel=10
    * @type {Record<string, keyof MidiEvent>} */
   const paramLookup = {
-    type: 'type', note: 'pitch', pitch: 'pitch',
-    ch: 'channel', channel: 'channel',
-    dev: 'device', device: 'device',
-    t: 'time', time: 'time', "@": 'time',
-    dur: 'dur', duration: 'dur',
-    pos: 'pos', value: 'value2'
+    type: "type",
+    note: "pitch",
+    pitch: "pitch",
+    ch: "channel",
+    channel: "channel",
+    dev: "device",
+    device: "device",
+    t: "time",
+    time: "time",
+    "@": "time",
+    dur: "dur",
+    duration: "dur",
+    pos: "pos",
+    value: "value2",
   };
-  
+
   // These are how different midi event keys are split. ch and dev are special cases that don't include =, since they're common. Other params use = to allow arbitrary additional properties if needed
   const PREFIX_CHANNEL = "ch";
   const PREFIX_DEVICE = "dev";
-  const PREFIX_WHEN = 't=';
-  const PREFIX_POS = 'pos=';
-  const PREFIX_DURATION = 'dur=';
+  const PREFIX_WHEN = "t=";
+  const PREFIX_POS = "pos=";
+  const PREFIX_DURATION = "dur=";
   /** Used when creating lists - treat ~ as empty no value */
-  const REST_LITERAL = '~';
+  const REST_LITERAL = "~";
 
   /**
-   * @param {string} value 
+   * @param {string} value
    * @returns {EventType | undefined}
    */
   function normalizeType(value) {
@@ -177,7 +278,9 @@
   }
 
   function formatNumValue(value, opts) {
-    const str = opts?.useHex ? formatHex(value) : value.toFixed().padStart(opts?.fixedWidth ? 2 : 3, "0");
+    const str = opts?.useHex
+      ? formatHex(value)
+      : value.toFixed().padStart(opts?.fixedWidth ? 2 : 3, "0");
     return str;
   }
   function formatDefault(type, value, value2, opts) {
@@ -186,18 +289,34 @@
   function formatNoteType(type, note, value, opts = {}) {
     return `${type ? type + " " : ""}${midiPitchToNoteName(note, opts)} ${formatNumValue(value, opts)}`;
   }
-  /** 
+  /**
    * This is a mapping of midi events and their string representation
    * @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>}
    */
   const formatters = {
-    noteOn({ value1: note, value2: velocity = eventMapping.noteOn.defaults[1] }, opts = {}) {
-      return formatNoteType(opts?.noMinify ? shorthands.noteOn : undefined, note, velocity, opts);
+    noteOn(
+      { value1: note, value2: velocity = eventMapping.noteOn.defaults[1] },
+      opts = {}
+    ) {
+      return formatNoteType(
+        opts?.noMinify ? shorthands.noteOn : undefined,
+        note,
+        velocity,
+        opts
+      );
     },
     noteOff({ value1: note }, opts = {}) {
-      return formatNoteType(opts?.noMinify ? shorthands.noteOff : undefined, note, 0, opts);
+      return formatNoteType(
+        opts?.noMinify ? shorthands.noteOff : undefined,
+        note,
+        0,
+        opts
+      );
     },
-    polyTouch({ value1: note, value2: value = eventMapping.polyTouch.defaults[1] }, opts = {}) {
+    polyTouch(
+      { value1: note, value2: value = eventMapping.polyTouch.defaults[1] },
+      opts = {}
+    ) {
       return formatNoteType(shorthands.polyTouch, note, value, opts);
     },
     cc({ value1: cc, value2: value }, opts) {
@@ -206,7 +325,8 @@
     programChange({ value1: program }, opts) {
       return formatDefault(shorthands.programChange, program, undefined, opts);
     },
-    channelPressure: ({ value1: value }, opts) => formatDefault(shorthands.channelPressure, value, undefined, opts),
+    channelPressure: ({ value1: value }, opts) =>
+      formatDefault(shorthands.channelPressure, value, undefined, opts),
     pitchBend({ value1, value2 }, opts) {
       if (value1 == undefined) {
         [value1, value2] = [0, 64];
@@ -216,23 +336,23 @@
     songPosition({ value1 = 0, value2 }, opts) {
       return `${shorthands.songPosition} ${formatHighResValue(value1, value2, opts)}`;
     },
-    songSelect: ({ value1 }, opts) => formatDefault(shorthands.songSelect, value1, undefined, opts),
+    songSelect: ({ value1 }, opts) =>
+      formatDefault(shorthands.songSelect, value1, undefined, opts),
     // tuneRequest: () => shorthands.tuneRequest,
     continue: () => shorthands.continue,
     activeSensing: () => shorthands.activeSensing,
     clock: () => shorthands.clock,
     start: () => shorthands.start,
     stop: () => shorthands.stop,
-    reset: () => shorthands.reset
+    reset: () => shorthands.reset,
   };
 
-
   /**
    * convert midi event to string.
    * The opts includes more formatting options than available through the current scratch blocks available.
-   * @param {MidiEvent} event 
-   * @param {FormatOptions} opts 
-   * @returns 
+   * @param {MidiEvent} event
+   * @param {FormatOptions} opts
+   * @returns
    */
   function midiToString(event, opts = {}) {
     const { noMinify } = opts;
@@ -241,14 +361,14 @@
     // ensure these are set properly
     const {
       value1 = event[spec.param1] ?? event[spec.highResParam],
-      value2 = event[spec.param2]
+      value2 = event[spec.param2],
     } = event;
     const formatter = formatters[event.type];
     if (!formatter) {
       console.debug(`unknown event type ${event.type}`);
       return "";
     }
-    let msg = formatter({...event, value1, value2}, opts);
+    let msg = formatter({ ...event, value1, value2 }, opts);
     if (event.channel != undefined || noMinify) {
       msg += formatChannel(event.channel, opts);
     }
@@ -270,13 +390,14 @@
   /**
    * convert a string representation of a note to a midievent
    * FUTURE - support unicode note durations? https://en.wikipedia.org/wiki/Musical_Symbols_(Unicode_block)
-   * @param {string} text 
-   * @param {FormatOptions} opts 
+   * @param {string} text
+   * @param {FormatOptions} opts
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
-    if (typeof text !== 'string') text = `${String(text) ?? ''}`;
-    const fullRe = /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
+    if (typeof text !== "string") text = `${String(text) ?? ""}`;
+    const fullRe =
+      /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
     const match = fullRe.exec(text);
     if (!match?.groups) return null;
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
@@ -286,11 +407,13 @@
     const extras = Object.fromEntries(
       [...match.groups.keyvals?.matchAll(keyvalRe)]
         // paramLookup converts "t=2" into "time=2"
-        .map(({groups: {key, val}}) => [paramLookup[key] || key, val])
+        .map(({ groups: { key, val } }) => [paramLookup[key] || key, val])
     );
     let {
       type: shorthand = extras.type,
-      pitch = extras.pitch, data1, data2
+      pitch = extras.pitch,
+      data1,
+      data2,
     } = match.groups;
 
     // midi value1 can be specified as pitch or as number
@@ -302,22 +425,20 @@
 
     /** @type {MidiEvent} */
     const event = {
-      type: shorthand === REST_LITERAL
-        ? 'rest'
-        : normalizeType(shorthand),
-      ...(value1 != undefined) && {value1},
-      ...(value2 != undefined) && {value2},
+      type: shorthand === REST_LITERAL ? "rest" : normalizeType(shorthand),
+      ...(value1 != undefined && { value1 }),
+      ...(value2 != undefined && { value2 }),
       channel: parseNumValue(extras.channel, opts),
       device: parseNumValue(extras.device, opts),
-      ...extras.time && { time: parseTimespan(extras.time)},
+      ...(extras.time && { time: parseTimespan(extras.time) }),
       // REVIEW is pos even needed? it's for setting output in beats, but setting time would make more sense instead
-      ...extras.pos && { pos: parseFraction(extras.pos)},
-      ...extras.dur && { dur: parseFraction(extras.dur)},
+      ...(extras.pos && { pos: parseFraction(extras.pos) }),
+      ...(extras.dur && { dur: parseFraction(extras.dur) }),
     };
 
     // default to note event if has pitch (off if velocity = 0)
     if (!event.type && value1 >= 0) {
-      event.type = 'noteOn';
+      event.type = "noteOn";
     } else if (!event.type) {
       // no type set, invalid input
       return null;
@@ -327,9 +448,10 @@
       case "noteOn":
       case "noteOff":
         if (value1 == undefined) return null;
-        if (value2 === 0) event.type = 'noteOff';
+        if (value2 === 0) event.type = "noteOff";
         if (value2 == undefined) {
-          event.value2 = event.velocity ?? event.value ?? (event.type === 'noteOn' ? 96 : 0);
+          event.value2 =
+            event.velocity ?? event.value ?? (event.type === "noteOn" ? 96 : 0);
         }
         break;
       case "polyTouch":
@@ -342,7 +464,7 @@
       case "cc":
         if (value2 == undefined) {
           event.value2 = event.value;
-          value2 = event.value2
+          value2 = event.value2;
         }
         if (value1 == undefined || value2 == undefined) return null;
         break;
@@ -356,7 +478,10 @@
       case "pitchBend":
         if (value1 == undefined) return null;
         // these two types have a higher precision value
-        const { value: highResValue, ...normedValues } = parseHighResValue(value1, value2);
+        const { value: highResValue, ...normedValues } = parseHighResValue(
+          value1,
+          value2
+        );
         Object.assign(event, normedValues);
         event[spec.highResParam ?? "value"] = highResValue;
         break;
@@ -381,14 +506,19 @@
   }
 
   function formatChannel(channel = 0, opts) {
-    const str = opts?.useHex ? formatHex(channel, 1) : channel.toFixed().padStart(2, "0");
+    const str = opts?.useHex
+      ? formatHex(channel, 1)
+      : channel.toFixed().padStart(2, "0");
     return ` ${PREFIX_CHANNEL}${str}`;
   }
   function formatDevice(device = 0, opts) {
     const str = opts?.useHex ? formatHex(device, 1) : device.toFixed();
     return ` ${PREFIX_DEVICE}${str}`;
   }
-  function formatTime({ time = undefined }, { noMinify = false, timestampFormat = "absolute", startTimestamp = 0 }) {
+  function formatTime(
+    { time = undefined },
+    { noMinify = false, timestampFormat = "absolute", startTimestamp = 0 }
+  ) {
     if (timestampFormat === "omit" || time == undefined) {
       return "";
     }
@@ -402,15 +532,14 @@
 
   // TODO FUTURE add in opts flag to use fractions or not
   function formatPosition(value, opts) {
-    return `${PREFIX_POS}${formatFraction(value)}`
+    return `${PREFIX_POS}${formatFraction(value)}`;
   }
 
   // TODO FUTURE add in opts flag to use fractions or not
   function formatDuration(value, opts) {
-    return `${PREFIX_DURATION}${formatFraction(value)}`
+    return `${PREFIX_DURATION}${formatFraction(value)}`;
   }
 
-
   function formatTimespan(seconds, hoursOptional = true) {
     const ms = 1e3 * (seconds % 1);
     let t = Math.floor(seconds);
@@ -421,29 +550,32 @@
     return `${parts.map((p) => p.toFixed(0).padStart(2, "0")).join(":")}.${ms.toFixed().padEnd(3, "0")}`;
   }
   /**
-   * 
-   * @param {string} text 
-   * @returns 
+   *
+   * @param {string} text
+   * @returns
    */
   function parseTimespan(text) {
     if (!text) return 0;
     // split into [hh]:mm:ss.000 parts
-    const parts = text.split(':');
+    const parts = text.split(":");
     // somewhat unnecessarily clever method to sum [hh][mm][ss]
     // by incrementing the scale from [1, 60, 3600].
     // goes right to left because hours and minutes are optional
-    const [value] = parts.reduceRight(([acc, scale], part) => {
-      const val = (parseFloat(part) || 0) * scale;
-      return [acc + val, scale * 60];
-    }, [0, 1]);
+    const [value] = parts.reduceRight(
+      ([acc, scale], part) => {
+        const val = (parseFloat(part) || 0) * scale;
+        return [acc + val, scale * 60];
+      },
+      [0, 1]
+    );
     return value;
   }
   function parseFraction(text) {
-    if (typeof text !== 'string') {
+    if (typeof text !== "string") {
       return +text || 0;
     }
-    const [top, bottom] = text.split('/');
-    return (parseFloat(top) / (parseFloat(bottom) || 1)) || 0;
+    const [top, bottom] = text.split("/");
+    return parseFloat(top) / (parseFloat(bottom) || 1) || 0;
   }
   function formatFraction(value, threshold = 2e-3) {
     for (let d of [4, 3, 10, 8, 1]) {
@@ -453,23 +585,24 @@
       }
     }
     // truncate to milliseconds (0.001)
-    return `${value}`.replace(/(\.\d{3})\d+$/, '$1');
+    return `${value}`.replace(/(\.\d{3})\d+$/, "$1");
   }
 
   function valueToMsbLsb(value) {
     return {
       value1: value & 127,
-      value2: value >> 7
+      value2: value >> 7,
     };
   }
   function msbLsbToValue(lsb, msb = 0) {
     return (msb << 7) + lsb;
   }
   function parseHighResValue(value1, value2) {
-    const value = typeof value2 == undefined ? value1 : msbLsbToValue(value1, value2);
+    const value =
+      typeof value2 == undefined ? value1 : msbLsbToValue(value1, value2);
     return {
       value,
-      ...valueToMsbLsb(value)
+      ...valueToMsbLsb(value),
     };
   }
   function formatHighResValue(value1, value2, opts = {}) {
@@ -486,7 +619,7 @@
 
   /**
    * parse raw input midi bytes
-   * @param {Uint8Array} data 
+   * @param {Uint8Array} data
    * @returns {MidiEvent | null}
    */
   function rawMessageToMidi(data) {
@@ -502,8 +635,8 @@
     const event = {
       type,
       channel: channel + 1,
-      ...value1 != undefined && { value1 },
-      ...value2 != undefined && { value2 }
+      ...(value1 != undefined && { value1 }),
+      ...(value2 != undefined && { value2 }),
     };
     const spec = eventMapping[type];
     if (spec?.param1 && event.value1 != undefined) {
@@ -524,12 +657,7 @@
    * @returns {Uint8Array}
    */
   function midiToRawMessage(event) {
-    let {
-      type,
-      value1,
-      value2,
-      channel = 1
-    } = event;
+    let { type, value1, value2, channel = 1 } = event;
     const spec = eventMapping[type];
     // return empty if not valid event
     if (!spec) return new Uint8Array();
@@ -538,35 +666,44 @@
       value1 = (event[spec.param1] ?? spec.defaults?.[0]) || 0;
     }
     if (spec.param2 && value2 == undefined) {
-      value2 = (event[spec.param2] ?? spec.defaults?.[1]) ?? undefined;
+      value2 = event[spec.param2] ?? spec.defaults?.[1] ?? undefined;
     }
     if (spec.highResParam && event.value != undefined) {
       const highRes = parseHighResValue(event.value);
       [value1, value2] = [highRes.value1, highRes.value2];
     }
-    return new Uint8Array([commandAndChannel, value1, ...(value2 !== undefined ? [value2] : [])]);
+    return new Uint8Array([
+      commandAndChannel,
+      value1,
+      ...(value2 !== undefined ? [value2] : []),
+    ]);
   }
   /**
    * read the "pos" / "dur" values of an event as relative time vs. a fixed wall-clock time
-   * @param {Pick<MidiEvent, 'time' | 'pos' | 'dur'>} event 
+   * @param {Pick<MidiEvent, 'time' | 'pos' | 'dur'>} event
    * @param {number} [offsetMs] time to return relative to. Default is now
    */
   function getMidiOffsetTime(event, offsetMs = window.performance.now()) {
     const { pos = 0, dur } = event;
     return {
-      start: offsetMs + (pos * 1000),
-      ...(dur > 0) && {
-        end: offsetMs + ((pos + dur) * 1000)
-      }
+      start: offsetMs + pos * 1000,
+      ...(dur > 0 && {
+        end: offsetMs + (pos + dur) * 1000,
+      }),
     };
   }
   function isPitchedEvent(type) {
-    return !!type && (type === "noteOn" || type === "noteOff" || type === "polyTouch");
+    return (
+      !!type &&
+      (type === "noteOn" || type === "noteOff" || type === "polyTouch")
+    );
   }
 
   // Make a full array of notes in full midi range from 0 (C-1) to 127 (G-9)
-  const MIDI_NOTES = "_".repeat(11).split('')
-    .flatMap((_, i) => SHARPS.map(c => `${c}${i - 1}`))
+  const MIDI_NOTES = "_"
+    .repeat(11)
+    .split("")
+    .flatMap((_, i) => SHARPS.map((c) => `${c}${i - 1}`))
     .slice(0, 128);
 
   /**
@@ -579,26 +716,38 @@
   const eventProps = {
     type: { key: "type", text: Scratch.translate("Event Type") },
     pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
-    velocity: { key: "velocity", type: "noteOn", text: Scratch.translate("Velocity") },
+    velocity: {
+      key: "velocity",
+      type: "noteOn",
+      text: Scratch.translate("Velocity"),
+    },
     ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
     ccValue: { key: "value", type: "cc", text: Scratch.translate("CC Value") },
     channel: { key: "channel", text: Scratch.translate("Channel") },
     device: { key: "device", text: Scratch.translate("Device") },
-    pitchbend: { key: "value", type: "pitchBend", text: Scratch.translate("Pitch Bend") },
-    aftertouch: { key: "value", type: "polyTouch", text: Scratch.translate("Aftertouch") },
-    time: { key: "time", text: Scratch.translate("Timestamp") }
+    pitchbend: {
+      key: "value",
+      type: "pitchBend",
+      text: Scratch.translate("Pitch Bend"),
+    },
+    aftertouch: {
+      key: "value",
+      type: "polyTouch",
+      text: Scratch.translate("Aftertouch"),
+    },
+    time: { key: "time", text: Scratch.translate("Timestamp") },
   };
 
-//#endregion utils
+  //#endregion utils
 
-//#region wrapper
+  //#region wrapper
   /**
    * This is a singleton wrapper class around the WebMIDI API. It:
    * 1) Handles requesting API permission and reporting Input/Output devices
    * 2) Translate raw midi input events into friendlier @see {MidiEvent} objects
    * 3) Sends out midi events, translating MidiEvents into the raw midi payload
    * 4) Keeps track of "note on"/"note off" messages to support "panic" stopping midi output
-   * 
+   *
    * It extends the native EventTarget class to dispatch events
    */
   class MidiBackend extends EventTarget {
@@ -612,13 +761,13 @@
       this._init = undefined;
       /** @type {MidiEvent} */
       this._defaultOutputEvent = {
-        type: 'noteOn',
+        type: "noteOn",
         channel: 1,
         device: 0,
         pitch: 60,
         dur: 0.5,
-        velocity: 196
-      }
+        velocity: 196,
+      };
       // TIP! If you use arrow functions on class methods then 'this' is automatically bound correctly, even if using as event listener
       this.refreshDevices = () => {
         for (const input of this.access.inputs.values()) {
@@ -644,14 +793,16 @@
           this.refreshDevices();
           return;
         }
-        this._emit("device:status", { index, id, name, type, state: port.state });
+        this._emit("device:status", {
+          index,
+          id,
+          name,
+          type,
+          state: port.state,
+        });
       };
       this._onInputEvent = (event) => {
-        const {
-          target: device,
-          data,
-          timeStamp
-        } = event;
+        const { target: device, data, timeStamp } = event;
         if (!data) return;
         const deviceIndex = this.inputs.indexOf(device);
         const midiEvent = rawMessageToMidi(data);
@@ -670,29 +821,36 @@
       };
     }
     get defaultInput() {
-      return this.inputs.find(d => d.state === 'connected');
+      return this.inputs.find((d) => d.state === "connected");
     }
     get defaultOutput() {
-      return this.outputs.find(d => d.state === 'connected');
+      return this.outputs.find((d) => d.state === "connected");
     }
-    async initialize({ sysex = false, force = false, timeoutMS = 1e3 * 30 } = {}) {
+    async initialize({
+      sysex = false,
+      force = false,
+      timeoutMS = 1e3 * 30,
+    } = {}) {
       if (this._init && !force) {
         return this._init;
       }
       if (!navigator.requestMIDIAccess) {
         return false;
       }
-      return this._init = (async () => {
+      return (this._init = (async () => {
         this.status = "initializing" /* Initializing */;
         this._emit("status", { status: this.status });
         try {
           let timer;
           const whenTimeout = new Promise((resolve, reject) => {
-            timer = setTimeout(() => reject(new DOMException("Timeout waiting for midi access")), timeoutMS);
+            timer = setTimeout(
+              () => reject(new DOMException("Timeout waiting for midi access")),
+              timeoutMS
+            );
           });
           const midiAccess = await Promise.race([
             navigator.requestMIDIAccess({ sysex }),
-            whenTimeout
+            whenTimeout,
           ]);
           clearTimeout(timer);
           this.access = midiAccess;
@@ -710,47 +868,55 @@
         } finally {
           this._emit("status", { status: this.status });
         }
-      })();
+      })());
     }
     /**
-     * 
+     *
      * @param {MidiEvent | string | number} event
      * @param {MidiEvent} [defaults]
      * @param {FormatOptions} [formatOpts]
      */
-    sendOutputEvent(event, defaults = this._defaultOutputEvent, formatOpts = {}) {
+    sendOutputEvent(
+      event,
+      defaults = this._defaultOutputEvent,
+      formatOpts = {}
+    ) {
       /** @type {MidiEvent} */
       let data;
       // midi pitch = noteon now for 1/2 beat
-      if (typeof event === 'number') {
+      if (typeof event === "number") {
         data = {
           ...defaults,
-          pitch: event
+          pitch: event,
         };
-      } else if (typeof event === 'string') {
+      } else if (typeof event === "string") {
         data = {
           ...defaults,
-          ...stringToMidi(event, formatOpts)
+          ...stringToMidi(event, formatOpts),
         };
-      } else if (typeof event === 'object') {
+      } else if (typeof event === "object") {
         data = event;
       } else {
-        throw new TypeError('Invalid data to send to output - must be midievent object, string or number');
+        throw new TypeError(
+          "Invalid data to send to output - must be midievent object, string or number"
+        );
       }
 
       // ignore, just placebo rest event
-      if (data.type === 'rest') {
+      if (data.type === "rest") {
         return false;
       }
 
-      const device = (data.device != undefined && this.outputs[data.device]) || this.defaultOutput;
+      const device =
+        (data.device != undefined && this.outputs[data.device]) ||
+        this.defaultOutput;
       if (!device) {
         // no output. Should this throw error?
         return false;
       }
       // ensure 0 velocity is interpreted as noteOff
-      if (data.type === 'noteOn' && data.velocity === 0) {
-        data.type = 'noteOff';
+      if (data.type === "noteOn" && data.velocity === 0) {
+        data.type = "noteOff";
       }
 
       // TODO be able to specify offset time to calculate from?
@@ -758,13 +924,13 @@
       let raw = midiToRawMessage(data);
       device.send(raw, start);
       // also send off event
-      if (data.type === 'noteOn' && end) {
+      if (data.type === "noteOn" && end) {
         /** @type {MidiEvent} */
         const offEvent = {
           ...data,
-          type: 'noteOff',
+          type: "noteOff",
           value2: 0,
-          velocity: 0
+          velocity: 0,
         };
         raw = midiToRawMessage(offEvent);
         device.send(raw, end);
@@ -779,13 +945,13 @@
      */
     panic() {
       for (let [device, active] of this._activeNotes.entries()) {
-        if (device.state !== 'connected') continue;
+        if (device.state !== "connected") continue;
         for (let key of active) {
-          const [channel, pitch] = key.split('_');
+          const [channel, pitch] = key.split("_");
           const raw = midiToRawMessage({
-            type: 'noteOff',
+            type: "noteOff",
             channel: parseInt(channel, 10),
-            pitch: parseInt(pitch)
+            pitch: parseInt(pitch),
           });
           // console.debug(`Stopping note ${pitch} on ${channel}`);
           device.send(raw);
@@ -796,13 +962,13 @@
     /**
      * Keep track of events sent to midi devices to allow panic stopping them if necessary
      * @private
-     * @param {MidiEvent} event 
+     * @param {MidiEvent} event
      * @param {MIDIOutput} device
      */
     _trackActiveNotes(event, device) {
       // NOTE - same default channel as midiToRawEvent, maybe default should be a magic value?
       const { type, pitch, channel = 1 } = event;
-      if (!(type === 'noteOn' || type === 'noteOff')) {
+      if (!(type === "noteOn" || type === "noteOff")) {
         return;
       }
       const key = `${channel}_${pitch}`;
@@ -810,7 +976,7 @@
         this._activeNotes.set(device, new Set());
       }
       const list = this._activeNotes.get(device);
-      if (type === 'noteOn') {
+      if (type === "noteOn") {
         list.add(key);
       } else {
         list.delete(key);
@@ -827,7 +993,9 @@
       const events = Array.isArray(event) ? event : [event];
       let timer;
       return new Promise((resolve, reject) => {
-        events.forEach((name) => target.addEventListener(name, resolve, { once: true, signal }));
+        events.forEach((name) =>
+          target.addEventListener(name, resolve, { once: true, signal })
+        );
         timer = setTimeout(() => {
           events.forEach((name) => target.removeEventListener(name, resolve));
           reject(new DOMException("Timeout", "TimeoutError"));
@@ -840,7 +1008,7 @@
     off(type, callback) {
       return super.removeEventListener(type, callback);
     }
-  };
+  }
 
   /**
    * this singleton keeps track of events in order to:
@@ -848,7 +1016,7 @@
    * 2) Track "active" notes
    * 3) Keep short term memory of events to avoid missing events because of scratch's slower event sample rate
    * 4) Allow recording events for playback/storage
-   * 
+   *
    * It keeps track of midi events, automatically pruning them after a certain time period or # of max entries have been reached (lazy, it doesn't actively poll)
    */
   class MidiRecorder extends EventTarget {
@@ -867,7 +1035,10 @@
       this.maxEntries = 256 * 256;
     }
     _now() {
-      return (globalThis.performance ? globalThis.performance.now() : Date.now()) / 1000;
+      return (
+        (globalThis.performance ? globalThis.performance.now() : Date.now()) /
+        1000
+      );
     }
     /**
      * REVIEW should record start be a protection against purging?
@@ -885,13 +1056,15 @@
       this.paused = true;
       const { recordStart } = this;
       this.recordStart = 0;
-      return recordStart ? this.buffer.filter((evt) => evt.when >= recordStart) : this.buffer;
+      return recordStart
+        ? this.buffer.filter((evt) => evt.when >= recordStart)
+        : this.buffer;
     }
     /**
      * add note to buffer
-     * @param evt 
+     * @param evt
      * @param when -- note, only used for setting "when" of active notes...evt should already have time value
-     * @returns 
+     * @returns
      */
     add(evt, when = this._now()) {
       const doc = { ...evt, when };
@@ -912,7 +1085,7 @@
         case "cc":
           Object.assign(this.ccs, {
             [`${evt.cc}_${evt.channel}`]: evt,
-            [`${evt.cc}`]: evt
+            [`${evt.cc}`]: evt,
           });
           break;
       }
@@ -954,7 +1127,9 @@
     getActiveNote(pitch, channel) {
       if (pitch == undefined) {
         const list = this.getActiveNotes(channel);
-        return list.length == 0 ? undefined : list.reduce((a, b) => a.when > b.when ? a : b);
+        return list.length == 0
+          ? undefined
+          : list.reduce((a, b) => (a.when > b.when ? a : b));
       }
       if (channel == undefined) {
         return this.active.get(pitch);
@@ -966,8 +1141,9 @@
       if (channel == undefined) {
         return [...this.active.values()];
       }
-      return [...this.activeByChannel.values()].filter((c) => c.channel == channel);
-      ;
+      return [...this.activeByChannel.values()].filter(
+        (c) => c.channel == channel
+      );
     }
     clear(newStartTime = 0) {
       this.lastNotes = {};
@@ -999,7 +1175,7 @@
       return this.getLast("polyTouch", pitch, channel);
     }
     getLast(type, value1, channel) {
-      if (type === value1 === channel === undefined) {
+      if (((type === value1) === channel) === undefined) {
         return this.buffer[this.buffer.length - 1];
       }
       if (type === "cc" && value1) {
@@ -1013,7 +1189,9 @@
         if (channel != undefined && evt.channel != channel) continue;
         if (type) {
           const eType = evt.type;
-          const isType = Array.isArray(type) ? type.includes(eType) : type === eType;
+          const isType = Array.isArray(type)
+            ? type.includes(eType)
+            : type === eType;
           if (!isType) continue;
         }
         return evt;
@@ -1033,17 +1211,19 @@
       if (this.buffer.length > this.maxEntries) {
         this.buffer = this.buffer.slice(-1 * this.maxEntries);
       }
-      const firstNonStaleEvent = this.buffer.findIndex((e) => e.when >= threshold);
+      const firstNonStaleEvent = this.buffer.findIndex(
+        (e) => e.when >= threshold
+      );
       if (firstNonStaleEvent === -1) {
         this.buffer = [];
       } else {
         this.buffer = this.buffer.slice(firstNonStaleEvent);
       }
     }
-  };
+  }
   // polyfill for findLastIndex for 5% of browsers without it
   const findLastIndex = (arr, cb) => {
-    if (typeof arr.findLastIndex === 'function') {
+    if (typeof arr.findLastIndex === "function") {
       return arr.findLastIndex(cb);
     }
     let i = arr.length - 1;
@@ -1051,7 +1231,7 @@
       i -= 1;
     }
     return i;
-  }
+  };
 
   function channelKeyForEvent(value = 0, channel = 0) {
     return msbLsbToValue(value, channel);
@@ -1060,8 +1240,8 @@
   // src/midi/midi-thread.ts
   const TARGET_MIDI_KEY = "_midi";
   /**
-   * 
-   * @param {import("scratch-vm").Thread} thread 
+   *
+   * @param {import("scratch-vm").Thread} thread
    * @returns {MidiEvent | undefined}
    */
   function getThreadMidiValue(thread) {
@@ -1088,21 +1268,21 @@
     return 60;
   }
   function beatsToSeconds(beats = 1, tempo = getTempo()) {
-    return beats * 60 / tempo;
+    return (beats * 60) / tempo;
   }
   function secondsToBeats(seconds = 1, tempo = getTempo()) {
-    return seconds * tempo / 60;
+    return (seconds * tempo) / 60;
   }
 
   //#endregion wrapper
 
-//#region Scratch Extension
+  //#region Scratch Extension
 
   // hardcoded mapping of hats events, b/c I'll never remember the convention otherwise
   const HATS = {
     NOTE: `${EXT_ID}_whenNoteOnOff`,
     NOTEANY: `${EXT_ID}_whenAnyNoteOnOff`,
-    MIDI: `${EXT_ID}_whenMidiEvent`
+    MIDI: `${EXT_ID}_whenMidiEvent`,
     // not currently implemented
     // CC: `${EXT_ID}_whenCC`
   };
@@ -1110,7 +1290,7 @@
    * Block separator constant
    * @type {'---'}
    */
-  const SEPARATOR = '---';
+  const SEPARATOR = "---";
   const { Cast } = Scratch;
 
   class MidiExtension {
@@ -1122,8 +1302,7 @@
        */
       this._ensureInitialize = (evt) => {
         if (this.midi.status === "pending" /* Initial */) {
-          this.initialize().catch(() => {
-          });
+          this.initialize().catch(() => {});
         }
       };
       this._addListeners();
@@ -1165,14 +1344,19 @@
         { value: "polyTouch", text: Scratch.translate("AfterTouch") },
         { value: "pitchBend", text: Scratch.translate("Pitch Bend") },
         { value: "programChange", text: Scratch.translate("Program Change") },
-        { value: "channelPressure", text: Scratch.translate("Channel Pressure") }
+        {
+          value: "channelPressure",
+          text: Scratch.translate("Channel Pressure"),
+        },
       ];
 
       return {
         id: EXT_ID,
         name: Scratch.translate("Midi"),
-        menuIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
-        blockIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
+        menuIconURI:
+          "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
+        blockIconURI:
+          "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
         blocks: [
           // FUTURE - could force requesting permissions and checking midi device status. Usually refreshing is safer option
           // {
@@ -1193,31 +1377,33 @@
             arguments: {
               DEVICE_TYPE: {
                 type: Scratch.ArgumentType.STRING,
-                menu: 'DEVICE_TYPES',
-                defaultValue: 'input'
-              }
-            }
+                menu: "DEVICE_TYPES",
+                defaultValue: "input",
+              },
+            },
           },
           {
             opcode: "getDeviceInfo",
-            text: Scratch.translate("[DEVICE_PROP] of [DEVICE_TYPE] device at [INDEX]"),
+            text: Scratch.translate(
+              "[DEVICE_PROP] of [DEVICE_TYPE] device at [INDEX]"
+            ),
             blockType: Scratch.BlockType.REPORTER,
             arguments: {
               DEVICE_PROP: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "DEVICE_PROPS",
-                defaultValue: "name"
+                defaultValue: "name",
               },
               DEVICE_TYPE: {
                 type: Scratch.ArgumentType.STRING,
-                menu: 'DEVICE_TYPES',
-                defaultValue: 'input'
+                menu: "DEVICE_TYPES",
+                defaultValue: "input",
               },
               INDEX: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
-              }
-            }
+                defaultValue: 0,
+              },
+            },
           },
           SEPARATOR,
           {
@@ -1229,14 +1415,14 @@
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               PRESS: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_EVENT_TYPE",
-                defaultValue: ANY_TYPE
-              }
-            }
+                defaultValue: ANY_TYPE,
+              },
+            },
           },
           {
             opcode: "whenAnyNoteOnOff",
@@ -1248,9 +1434,9 @@
               PRESS: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_EVENT_TYPE",
-                defaultValue: ANY_TYPE
-              }
-            }
+                defaultValue: ANY_TYPE,
+              },
+            },
           },
           {
             opcode: "whenMidiEvent",
@@ -1262,16 +1448,16 @@
               TYPE: {
                 menu: "EVENT_TYPES_OPTIONAL",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: ANY_TYPE
-              }
-            }
+                defaultValue: ANY_TYPE,
+              },
+            },
           },
           {
             opcode: "lastEvent",
             blockType: Scratch.BlockType.REPORTER,
             text: Scratch.translate("Input Event"),
             disableMonitor: true,
-            allowDropAnywhere: true
+            allowDropAnywhere: true,
           },
           {
             opcode: "getEventProp",
@@ -1280,14 +1466,14 @@
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "note C4 82 ch1 dev0 @1000"
+                defaultValue: "note C4 82 ch1 dev0 @1000",
               },
               PROP: {
                 type: Scratch.ArgumentType.STRING,
                 defaultValue: "type",
-                menu: "PROPS"
-              }
-            }
+                menu: "PROPS",
+              },
+            },
           },
           {
             opcode: "isNoteActive",
@@ -1296,14 +1482,14 @@
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               CHANNEL: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "CHANNELS",
-                defaultValue: "0"
-              }
-            }
+                defaultValue: "0",
+              },
+            },
           },
           {
             opcode: "isEventOfType",
@@ -1313,20 +1499,20 @@
               TYPE: {
                 menu: "EVENT_TYPES",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "noteOn"
-              }
-            }
+                defaultValue: "noteOn",
+              },
+            },
           },
           SEPARATOR,
           {
             opcode: "getActiveNotes",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Active Notes")
+            text: Scratch.translate("Active Notes"),
           },
           {
             opcode: "numActiveNotes",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("length of active notes")
+            text: Scratch.translate("length of active notes"),
           },
           {
             opcode: "getActiveNoteByIndex",
@@ -1335,9 +1521,9 @@
             arguments: {
               INDEX: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
-              }
-            }
+                defaultValue: 0,
+              },
+            },
           },
           {
             opcode: "setActiveNoteList",
@@ -1346,9 +1532,9 @@
             arguments: {
               LIST: {
                 type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              }
-            }
+                menu: "lists",
+              },
+            },
           },
           SEPARATOR,
           {
@@ -1358,90 +1544,96 @@
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               BEATS: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0.25
-              }
-            }
+                defaultValue: 0.25,
+              },
+            },
           },
           {
             opcode: "sendOutputEvent",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate("schedule [EVENT] for [POS] beats from now"),
+            text: Scratch.translate(
+              "schedule [EVENT] for [POS] beats from now"
+            ),
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "Eb4 beats=1/4"
+                defaultValue: "Eb4 beats=1/4",
               },
               POS: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
-              }
-            }
+                defaultValue: 0,
+              },
+            },
           },
           {
             opcode: "makeOutputNote",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Note [NOTE] Duration [BEATS] Volume [VELOCITY]% [CHANNEL] [DEVICE]"),
+            text: Scratch.translate(
+              "Note [NOTE] Duration [BEATS] Volume [VELOCITY]% [CHANNEL] [DEVICE]"
+            ),
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               BEATS: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0.25
+                defaultValue: 0.25,
               },
               VELOCITY: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 96
+                defaultValue: 96,
               },
               CHANNEL: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "CHANNELS",
-                defaultValue: "1"
+                defaultValue: "1",
               },
               DEVICE: {
                 type: Scratch.ArgumentType.STRING,
-                menu: "OUTPUT_DEVICES"
-              }
-            }
+                menu: "OUTPUT_DEVICES",
+              },
+            },
           },
           {
             opcode: "makeOutputEvent",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Event [TYPE] [VALUE1] [VALUE2] [CHANNEL] [DEVICE]"),
+            text: Scratch.translate(
+              "Event [TYPE] [VALUE1] [VALUE2] [CHANNEL] [DEVICE]"
+            ),
             arguments: {
               TYPE: {
                 menu: "EVENT_TYPES",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: 'cc'
+                defaultValue: "cc",
               },
               VALUE1: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
+                defaultValue: 0,
               },
               VALUE2: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
+                defaultValue: 0,
               },
               CHANNEL: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "CHANNELS",
-                defaultValue: "1"
+                defaultValue: "1",
               },
               DEVICE: {
                 type: Scratch.ArgumentType.STRING,
-                menu: "OUTPUT_DEVICES"
-              }
-            }
+                menu: "OUTPUT_DEVICES",
+              },
+            },
           },
           {
             opcode: "stopAllNotes",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate("stop all notes on output devices")
+            text: Scratch.translate("stop all notes on output devices"),
           },
           SEPARATOR,
 
@@ -1453,9 +1645,9 @@
               NOTE: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_NAMES",
-                defaultValue: "C4"
-              }
-            }
+                defaultValue: "C4",
+              },
+            },
           },
           {
             opcode: "nameForNote",
@@ -1464,24 +1656,26 @@
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               ACCIDENTAL: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "ACCIDENTALS",
-                defaultValue: 'sharps'
-              }
-            }
+                defaultValue: "sharps",
+              },
+            },
           },
           {
             opcode: "normalizeMidiVal",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Scale MIDI Value [VALUE] to min=[MIN] max=[MAX]"),
+            text: Scratch.translate(
+              "Scale MIDI Value [VALUE] to min=[MIN] max=[MAX]"
+            ),
             arguments: {
               VALUE: { type: Scratch.ArgumentType.NUMBER, defaultValue: 0 },
               MIN: { type: Scratch.ArgumentType.NUMBER, defaultValue: -1 },
-              MAX: { type: Scratch.ArgumentType.NUMBER, defaultValue: 1 }
-            }
+              MAX: { type: Scratch.ArgumentType.NUMBER, defaultValue: 1 },
+            },
           },
           {
             opcode: "eventToJSON",
@@ -1490,9 +1684,9 @@
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "note Eb4 96 t=0.5 dur=0.25"
-              }
-            }
+                defaultValue: "note Eb4 96 t=0.5 dur=0.25",
+              },
+            },
           },
           {
             opcode: "jsonToEvent",
@@ -1501,20 +1695,21 @@
             arguments: {
               TEXT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}'
-              }
-            }
+                defaultValue:
+                  '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}',
+              },
+            },
           },
           SEPARATOR,
           {
             opcode: "getMidiStartTime",
             text: Scratch.translate("MIDI Start Time"),
-            blockType: Scratch.BlockType.REPORTER
+            blockType: Scratch.BlockType.REPORTER,
           },
           {
             opcode: "getMidiCurrentTime",
             text: Scratch.translate("MIDI Current Time"),
-            blockType: Scratch.BlockType.REPORTER
+            blockType: Scratch.BlockType.REPORTER,
           },
           {
             opcode: "clearEvents",
@@ -1522,93 +1717,109 @@
             blockType: Scratch.BlockType.COMMAND,
             arguments: {
               TIME: {
-                type: Scratch.ArgumentType.NUMBER
-              }
-            }
+                type: Scratch.ArgumentType.NUMBER,
+              },
+            },
           },
           {
             opcode: "setMidiEventList",
-            text: Scratch.translate("Set list [LIST] to events in last [TIME] seconds"),
+            text: Scratch.translate(
+              "Set list [LIST] to events in last [TIME] seconds"
+            ),
             blockType: Scratch.BlockType.COMMAND,
             arguments: {
               LIST: {
                 type: Scratch.ArgumentType.STRING,
-                menu: "lists"
+                menu: "lists",
               },
               TIME: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 5
-              }
-            }
-          }
+                defaultValue: 5,
+              },
+            },
+          },
         ],
         menus: {
           EVENT_TYPES: {
             acceptReporters: true,
-            items: EVENT_TYPES_ITEMS
+            items: EVENT_TYPES_ITEMS,
           },
           EVENT_TYPES_OPTIONAL: {
             acceptReporters: true,
             items: [
               ...EVENT_TYPES_ITEMS,
-              { value: ANY_TYPE, text: Scratch.translate("Any") }
-            ]
+              { value: ANY_TYPE, text: Scratch.translate("Any") },
+            ],
           },
           INPUT_DEVICES: {
             acceptReporters: true,
-            items: "inputDevicesMenu"
+            items: "inputDevicesMenu",
           },
           OUTPUT_DEVICES: {
             acceptReporters: true,
-            items: "outputDevicesMenu"
+            items: "outputDevicesMenu",
           },
           DEVICE_TYPES: {
             acceptReporters: true,
             items: [
-              { value: 'input', text: Scratch.translate("input") },
-              { value: 'output', text: Scratch.translate("output") },
-            ]
+              { value: "input", text: Scratch.translate("input") },
+              { value: "output", text: Scratch.translate("output") },
+            ],
           },
           DEVICE_PROP: {
             acceptReporters: true,
             items: [
               { value: "id", text: Scratch.translate("Device ID") },
-              { value: "manufacturer", text: Scratch.translate("Manufacturer") },
+              {
+                value: "manufacturer",
+                text: Scratch.translate("Manufacturer"),
+              },
               { value: "name", text: Scratch.translate("Device Name") },
-              { value: "state", text: Scratch.translate("State") }
-            ]
+              { value: "state", text: Scratch.translate("State") },
+            ],
           },
           NOTE_EVENT_TYPE: {
             acceptReporters: true,
             items: [
               { value: ANY_TYPE, text: Scratch.translate("Note On/Off") },
               { value: "noteOn", text: Scratch.translate("Note On") },
-              { value: "noteOff", text: Scratch.translate("Note Off") }
-            ]
+              { value: "noteOff", text: Scratch.translate("Note Off") },
+            ],
           },
           ACCIDENTALS: {
             acceptReporters: true,
             items: [
               { value: "sharps", text: `♯ ${Scratch.translate("Sharps")}` },
-              { value: "flats", text: `♭ ${Scratch.translate("Flats")}` }
-            ]
+              { value: "flats", text: `♭ ${Scratch.translate("Flats")}` },
+            ],
           },
           NOTE_NAMES: {
             acceptReporters: true,
             // the result of these don't need translation - they're just "C4" or "G#6"
-            items: [...MIDI_NOTES.entries()]
-              .map(([index, text]) => ({ value: `${index}`, text }))
+            items: [...MIDI_NOTES.entries()].map(([index, text]) => ({
+              value: `${index}`,
+              text,
+            })),
           },
           CHANNELS: {
             acceptReporters: true,
             items: [
               { value: "0", text: Scratch.translate("any channel") },
-              ..."0".repeat(15).split("").map((_, i) => ({ value: `${i + 1}`, text: `channel ${i + 1}` }))
-            ]
+              ..."0"
+                .repeat(15)
+                .split("")
+                .map((_, i) => ({
+                  value: `${i + 1}`,
+                  text: `channel ${i + 1}`,
+                })),
+            ],
           },
           PROPS: {
             acceptReporters: true,
-            items: Object.entries(eventProps).map(([value, { text }]) => ({ value, text }))
+            items: Object.entries(eventProps).map(([value, { text }]) => ({
+              value,
+              text,
+            })),
           },
           DEVICE_PROPS: {
             acceptReporters: true,
@@ -1616,15 +1827,18 @@
               { value: "id", text: Scratch.translate("Id") },
               { value: "name", text: Scratch.translate("Name") },
               { value: "state", text: Scratch.translate("State") },
-              { value: "manufacturer", text: Scratch.translate("Manufacturer") }
-            ]
+              {
+                value: "manufacturer",
+                text: Scratch.translate("Manufacturer"),
+              },
+            ],
           },
           // taken from /Lily/ListTools.js
           lists: {
             acceptReporters: true,
             items: "_getLists",
           },
-        }
+        },
       };
     }
     // taken from /Lily/ListTools.js
@@ -1649,12 +1863,18 @@
       await this.midi.initialize({ sysex, force });
     }
     _isAnyArg(val) {
-      return val == undefined || val == "" || val == ANY_TYPE || typeof val === "string" && /^\*|any$/i.test(val);
+      return (
+        val == undefined ||
+        val == "" ||
+        val == ANY_TYPE ||
+        (typeof val === "string" && /^\*|any$/i.test(val))
+      );
     }
     numDevices({ DEVICE_TYPE }) {
       this._ensureInitialize();
       const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
-      const deviceList = deviceType === 'output' ? this.midi.outputs : this.midi.inputs;
+      const deviceList =
+        deviceType === "output" ? this.midi.outputs : this.midi.inputs;
 
       return deviceList.length;
     }
@@ -1665,28 +1885,42 @@
     getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
       const index = Cast.toNumber(INDEX);
       const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
-      const deviceList = deviceType === 'input' ? this.midi.inputs : this.midi.outputs;
+      const deviceList =
+        deviceType === "input" ? this.midi.inputs : this.midi.outputs;
       const device = deviceList[index];
       if (!device) return "";
       return device[DEVICE_PROP];
     }
     inputDevicesMenu() {
-      const inputList = this.midi.inputs.map((d) => ({ text: d.name || d.id, value: d.id }));
-      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(inputList);
+      const inputList = this.midi.inputs.map((d) => ({
+        text: d.name || d.id,
+        value: d.id,
+      }));
+      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(
+        inputList
+      );
     }
     outputDevicesMenu() {
-      const outputList = this.midi.outputs.map((d) => ({ text: d.name || d.id, value: d.id }));
-      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(outputList);
+      const outputList = this.midi.outputs.map((d) => ({
+        text: d.name || d.id,
+        value: d.id,
+      }));
+      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(
+        outputList
+      );
     }
     whenNoteOnOff({ NOTE, PRESS }, util) {
       const isAny = this._isAnyArg(PRESS);
-      let type = isAny ? ['noteOn', 'noteOff'] : [normalizeType(Scratch.Cast.toString(PRESS))];
+      let type = isAny
+        ? ["noteOn", "noteOff"]
+        : [normalizeType(Scratch.Cast.toString(PRESS))];
 
       const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
       const last = this.recorder.getLast();
 
       // filter if only note on or note off
-      if (last &&
+      if (
+        last &&
         type.includes(last.type) &&
         (pitch === undefined || last.pitch === pitch)
       ) {
@@ -1698,7 +1932,9 @@
     }
     whenAnyNoteOnOff({ PRESS }, util) {
       const isAny = this._isAnyArg(PRESS);
-      let type = isAny ? ['noteOn', 'noteOff'] : [normalizeType(Scratch.Cast.toString(PRESS))];
+      let type = isAny
+        ? ["noteOn", "noteOff"]
+        : [normalizeType(Scratch.Cast.toString(PRESS))];
 
       const last = this.recorder.getLast();
       // filter if only note on or note off
@@ -1711,7 +1947,9 @@
     }
     whenMidiEvent({ TYPE }, util) {
       const isAny = this._isAnyArg(TYPE);
-      const type = isAny ? undefined : normalizeType(Scratch.Cast.toString(TYPE));
+      const type = isAny
+        ? undefined
+        : normalizeType(Scratch.Cast.toString(TYPE));
       const last = this.recorder.getLast();
       if (last && (isAny || last.type === type)) {
         setThreadMidiValue(util.thread, last);
@@ -1720,7 +1958,7 @@
       return false;
     }
     /**
-     * 
+     *
      * @param {MidiEvent} event
      * @returns {MidiEvent}
      */
@@ -1738,25 +1976,27 @@
     }
     playNoteForBeats({ NOTE, BEATS }, util) {
       const pitch = noteNameToMidiPitch(Cast.toString(NOTE)) || undefined;
-      const beats = typeof BEATS === 'string' && BEATS.includes('/')
-        ? parseFraction(BEATS)
-        : Cast.toNumber(BEATS);
+      const beats =
+        typeof BEATS === "string" && BEATS.includes("/")
+          ? parseFraction(BEATS)
+          : Cast.toNumber(BEATS);
 
       const event = this._eventBeatsToSeconds({
-        type: 'noteOn',
-        ...(pitch != undefined) && { pitch },
-        dur: beats
+        type: "noteOn",
+        ...(pitch != undefined && { pitch }),
+        dur: beats,
       });
       this.midi.sendOutputEvent(event);
     }
     sendOutputEvent({ EVENT, POS }, util) {
       const text = Cast.toString(EVENT);
-      const pos = typeof POS === 'string' && POS.includes('/')
-        ? parseFraction(POS)
-        : Cast.toNumber(POS);
+      const pos =
+        typeof POS === "string" && POS.includes("/")
+          ? parseFraction(POS)
+          : Cast.toNumber(POS);
       const event = this._eventBeatsToSeconds({
         // default value is 0, so if event has something set (like "C#3 pos=1/4 beats=1") then let it take precedence, otherwise override
-        ...(pos > 0) && { pos },
+        ...(pos > 0 && { pos }),
         ...stringToMidi(text),
       });
 
@@ -1771,9 +2011,7 @@
       if (!EVENT) return "";
       const last = getThreadMidiValue(util.thread);
       // use cached thread value if available instead of re-parsing
-      const evt = last?._str === EVENT
-        ? last
-        : stringToMidi(EVENT);
+      const evt = last?._str === EVENT ? last : stringToMidi(EVENT);
 
       return evt?.[key] ?? "";
     }
@@ -1788,7 +2026,9 @@
       if (pitch == undefined) {
         const notes = this.recorder.getActiveNotes(channel);
         setThreadActiveNotes(util.thread, { channel, notes });
-        return notes.length == 0 ? undefined : notes.reduce((a, b) => a.when > b.when ? a : b);
+        return notes.length == 0
+          ? undefined
+          : notes.reduce((a, b) => (a.when > b.when ? a : b));
       }
       const note = this.recorder.getActiveNote(pitch, channel || undefined);
       if (note) {
@@ -1810,7 +2050,7 @@
       return noteNameToMidiPitch(name) || 0;
     }
     nameForNote({ NOTE, ACCIDENTAL }, util) {
-      const useFlats = Cast.toString(ACCIDENTAL) === 'flats';
+      const useFlats = Cast.toString(ACCIDENTAL) === "flats";
       let val = Cast.toNumber(NOTE);
       if (!val && /^[a-g]/i.test(`${NOTE}`)) {
         val = noteNameToMidiPitch(Cast.toString(NOTE)) || 0;
@@ -1818,9 +2058,10 @@
       return midiPitchToNoteName(val, { useFlats });
     }
     makeOutputNote({ NOTE, BEATS, VELOCITY, CHANNEL, DEVICE }) {
-      let dur = typeof BEATS === 'string' && BEATS.includes('/')
-        ? parseFraction(BEATS)
-        : Cast.toNumber(BEATS);
+      let dur =
+        typeof BEATS === "string" && BEATS.includes("/")
+          ? parseFraction(BEATS)
+          : Cast.toNumber(BEATS);
       // sanity check - don't let a note be more than 1 minute
       // if anyone ever needs a longer note then they should manually write event string
       dur = Math.max(0, Math.min(dur, 60));
@@ -1831,15 +2072,15 @@
       velocity = Math.max(0, Math.min(velocity, 127));
       // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
       const deviceId = Cast.toString(DEVICE);
-      const device = this.midi.outputs.findIndex(d => d.id === deviceId);
+      const device = this.midi.outputs.findIndex((d) => d.id === deviceId);
       /** @type {MidiEvent} */
       const event = {
-        type: 'noteOn',
+        type: "noteOn",
         pitch: this.noteForName({ NOTE }),
         velocity,
         channel: Cast.toNumber(CHANNEL) || undefined,
         device: device === -1 ? undefined : device,
-        dur
+        dur,
       };
       return midiToString(event);
     }
@@ -1872,7 +2113,7 @@
 
       // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
       const deviceId = Cast.toString(DEVICE);
-      const device = this.midi.outputs.findIndex(d => d.id === deviceId);
+      const device = this.midi.outputs.findIndex((d) => d.id === deviceId);
       // FUTURE this may make sense to get moved out to helper alongside rawMessageToMidi
       /** @type {MidiEvent} */
       const event = {
@@ -1881,9 +2122,9 @@
         value2,
         channel: Cast.toNumber(CHANNEL) || undefined,
         device: device === -1 ? undefined : device,
-        ...spec?.param1 && { [spec.param1]: value1 },
-        ...spec?.param2 && { [spec.param2]: value2 },
-        ...spec?.highResParam && parseHighResValue(value1, value2)
+        ...(spec?.param1 && { [spec.param1]: value1 }),
+        ...(spec?.param2 && { [spec.param2]: value2 }),
+        ...(spec?.highResParam && parseHighResValue(value1, value2)),
       };
       return midiToString(event);
     }
@@ -1907,7 +2148,11 @@
       const start = this.recorder._now() - duration;
       const events = this.recorder.getRange(start);
       if (LIST) {
-        this._upsertList(LIST, events.map((evt) => evt._str), util.target);
+        this._upsertList(
+          LIST,
+          events.map((evt) => evt._str),
+          util.target
+        );
       }
     }
     getActiveNotes(args, util) {
@@ -1927,13 +2172,17 @@
         setThreadMidiValue(util.thread, note);
         return note._str;
       }
-      return '';
+      return "";
     }
     setActiveNoteList({ LIST }, util) {
       const notes = Array.from(this.recorder.getActiveNotes());
       setThreadActiveNotes(util.thread, { notes });
       if (LIST) {
-        this._upsertList(LIST, notes.map((note) => note._str), util.target);
+        this._upsertList(
+          LIST,
+          notes.map((note) => note._str),
+          util.target
+        );
       }
     }
     _upsertList(name, value, target) {
@@ -1959,7 +2208,7 @@
       const event = stringToMidi(raw);
 
       // REVIEW - remove value1/value2 if already specified by event spec?
-      if (event && ('pitch' in event || 'value' in event)) {
+      if (event && ("pitch" in event || "value" in event)) {
         delete event.value1;
         delete event.value2;
       }
@@ -1971,17 +2220,21 @@
       let event = null;
       try {
         event = {
-          ...JSON.parse(raw)
+          ...JSON.parse(raw),
         };
         // rename aliases just in case
-        [['beats', 'dur'], ['offset', 'pos'], ['@', 'time']]
-          .filter(([alias, key]) => (alias in event) && event[key] == undefined)
-          .forEach(([alias, key]) => event[key] = event[alias]);
-      } catch (error) { }
-      return event ? midiToString(event) : ""
+        [
+          ["beats", "dur"],
+          ["offset", "pos"],
+          ["@", "time"],
+        ]
+          .filter(([alias, key]) => alias in event && event[key] == undefined)
+          .forEach(([alias, key]) => (event[key] = event[alias]));
+      } catch (error) {}
+      return event ? midiToString(event) : "";
     }
-  };
+  }
 
-//#endregion
+  //#endregion
   Scratch.extensions.register(new MidiExtension());
-})(Scratch);
\ No newline at end of file
+})(Scratch);

From 3cbb48aa896b0fbf97485650f5da8a89ee40e4c9 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 10 Mar 2025 11:22:22 -0400
Subject: [PATCH 05/61] midi.js - linting and ensure all inputs use
 Scratch.Cast

---
 extensions/midi/midi.js | 96 +++++++++++++++++++++++------------------
 1 file changed, 54 insertions(+), 42 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 1fb8cac386..8523b5bf7e 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -356,7 +356,6 @@
    */
   function midiToString(event, opts = {}) {
     const { noMinify } = opts;
-    let type = shorthands[event.type];
     const spec = eventMapping[event.type] ?? {};
     // ensure these are set properly
     const {
@@ -395,17 +394,17 @@
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
-    if (typeof text !== "string") text = `${String(text) ?? ""}`;
+    if (typeof text !== "string") text = Cast.toString(text);
     const fullRe =
       /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
     const match = fullRe.exec(text);
     if (!match?.groups) return null;
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
     // ch/dev/@ (channel, device, time) are special keys that don't need =
-    const keyvalRe = /\s*(?<key>\w+(?=\=)|ch|dev|@)=?(?<val>\S+)\s*/g;
+    const keyvalRe = /\s*(?<key>\w+(?==)|ch|dev|@)=?(?<val>\S+)\s*/g;
     /** @type {{[K in keyof MidiEvent]?: string}} */
     const extras = Object.fromEntries(
-      [...match.groups.keyvals?.matchAll(keyvalRe)]
+      Array.from(match.groups.keyvals?.matchAll(keyvalRe) || [])
         // paramLookup converts "t=2" into "time=2"
         .map(({ groups: { key, val } }) => [paramLookup[key] || key, val])
     );
@@ -444,6 +443,7 @@
       return null;
     }
     const spec = eventMapping[event.type];
+    let parsedHighRes = undefined;
     switch (event.type) {
       case "noteOn":
       case "noteOff":
@@ -478,12 +478,15 @@
       case "pitchBend":
         if (value1 == undefined) return null;
         // these two types have a higher precision value
-        const { value: highResValue, ...normedValues } = parseHighResValue(
+        parsedHighRes = parseHighResValue(
           value1,
           value2
         );
-        Object.assign(event, normedValues);
-        event[spec.highResParam ?? "value"] = highResValue;
+        Object.assign(event, {
+          [spec.highResParam ?? "value"]: parsedHighRes.value,
+          value1: parsedHighRes.value1,
+          value2: parsedHighRes.value2
+        });
         break;
       case "clock":
       case "start":
@@ -599,7 +602,7 @@
   }
   function parseHighResValue(value1, value2) {
     const value =
-      typeof value2 == undefined ? value1 : msbLsbToValue(value1, value2);
+      (value2 == undefined) ? value1 : msbLsbToValue(value1, value2);
     return {
       value,
       ...valueToMsbLsb(value),
@@ -692,12 +695,12 @@
       }),
     };
   }
-  function isPitchedEvent(type) {
-    return (
-      !!type &&
-      (type === "noteOn" || type === "noteOff" || type === "polyTouch")
-    );
-  }
+  // function isPitchedEvent(type) {
+  //   return (
+  //     !!type &&
+  //     (type === "noteOn" || type === "noteOff" || type === "polyTouch")
+  //   );
+  // }
 
   // Make a full array of notes in full midi range from 0 (C-1) to 127 (G-9)
   const MIDI_NOTES = "_"
@@ -826,7 +829,7 @@
     get defaultOutput() {
       return this.outputs.find((d) => d.state === "connected");
     }
-    async initialize({
+    initialize({
       sysex = false,
       force = false,
       timeoutMS = 1e3 * 30,
@@ -1175,7 +1178,8 @@
       return this.getLast("polyTouch", pitch, channel);
     }
     getLast(type, value1, channel) {
-      if (((type === value1) === channel) === undefined) {
+      // shortcut - just get last event if no filter
+      if (type == undefined && value1 == undefined && channel == undefined) {
         return this.buffer[this.buffer.length - 1];
       }
       if (type === "cc" && value1) {
@@ -1207,7 +1211,6 @@
     _prune(when = this._now()) {
       this.recordStart || (this.recordStart = when);
       const threshold = when - this.bufferSeconds;
-      const n = this.buffer.length;
       if (this.buffer.length > this.maxEntries) {
         this.buffer = this.buffer.slice(-1 * this.maxEntries);
       }
@@ -1270,9 +1273,9 @@
   function beatsToSeconds(beats = 1, tempo = getTempo()) {
     return (beats * 60) / tempo;
   }
-  function secondsToBeats(seconds = 1, tempo = getTempo()) {
-    return (seconds * tempo) / 60;
-  }
+  // function secondsToBeats(seconds = 1, tempo = getTempo()) {
+  //   return (seconds * tempo) / 60;
+  // }
 
   //#endregion wrapper
 
@@ -1401,7 +1404,7 @@
               },
               INDEX: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0,
+                defaultValue: 1,
               },
             },
           },
@@ -1862,12 +1865,15 @@
       const force = Cast.toBoolean(FORCE);
       await this.midi.initialize({ sysex, force });
     }
+    /**
+     * Checks if input value is whitespace or '*' or 'any'.
+     * @param {unknown} val 
+     * @returns {val is typeof ANY_TYPE}
+     */
     _isAnyArg(val) {
       return (
-        val == undefined ||
-        val == "" ||
-        val == ANY_TYPE ||
-        (typeof val === "string" && /^\*|any$/i.test(val))
+        val === ANY_TYPE ||
+        /^(\*|any|\s*)$/i.test(Cast.toString(val))
       );
     }
     numDevices({ DEVICE_TYPE }) {
@@ -1883,13 +1889,14 @@
       return this.midi.outputs.length;
     }
     getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
-      const index = Cast.toNumber(INDEX);
       const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
       const deviceList =
         deviceType === "input" ? this.midi.inputs : this.midi.outputs;
-      const device = deviceList[index];
+      const index = Cast.toListIndex(INDEX, deviceList.length, false);
+      const device = typeof index === 'number' ? deviceList[index - 1] : undefined;
       if (!device) return "";
-      return device[DEVICE_PROP];
+      const prop = Cast.toString(DEVICE_PROP);
+      return device[DEVICE_PROP] ?? "";
     }
     inputDevicesMenu() {
       const inputList = this.midi.inputs.map((d) => ({
@@ -1913,7 +1920,7 @@
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
         ? ["noteOn", "noteOff"]
-        : [normalizeType(Scratch.Cast.toString(PRESS))];
+        : [normalizeType(Cast.toString(PRESS))];
 
       const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
       const last = this.recorder.getLast();
@@ -1934,7 +1941,7 @@
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
         ? ["noteOn", "noteOff"]
-        : [normalizeType(Scratch.Cast.toString(PRESS))];
+        : [normalizeType(Cast.toString(PRESS))];
 
       const last = this.recorder.getLast();
       // filter if only note on or note off
@@ -1949,7 +1956,7 @@
       const isAny = this._isAnyArg(TYPE);
       const type = isAny
         ? undefined
-        : normalizeType(Scratch.Cast.toString(TYPE));
+        : normalizeType(Cast.toString(TYPE));
       const last = this.recorder.getLast();
       if (last && (isAny || last.type === type)) {
         setThreadMidiValue(util.thread, last);
@@ -2007,7 +2014,7 @@
     }
     getEventProp({ EVENT, PROP }, util) {
       const propName = Cast.toString(PROP);
-      const { key = "value", type } = eventProps[propName] ?? {};
+      const { key = "value" } = eventProps[propName] ?? {};
       if (!EVENT) return "";
       const last = getThreadMidiValue(util.thread);
       // use cached thread value if available instead of re-parsing
@@ -2015,7 +2022,7 @@
 
       return evt?.[key] ?? "";
     }
-    lastEvent(args, util) {
+    lastEvent(_args, util) {
       let last = getThreadMidiValue(util.thread);
       last || (last = this.recorder.getLast());
       return last ? midiToString(last) : "";
@@ -2037,7 +2044,7 @@
       return !!note;
     }
     isEventOfType({ TYPE }, util) {
-      const type = TYPE === ANY_TYPE ? undefined : TYPE;
+      const type = this._isAnyArg(TYPE) ? undefined : Cast.toString(TYPE);
       let last = getThreadMidiValue(util.thread);
       last || (last = this.recorder.getLast());
       return last?.type === type;
@@ -2050,7 +2057,7 @@
       return noteNameToMidiPitch(name) || 0;
     }
     nameForNote({ NOTE, ACCIDENTAL }, util) {
-      const useFlats = Cast.toString(ACCIDENTAL) === "flats";
+      const useFlats = Cast.toString(ACCIDENTAL).toLowerCase() === "flats";
       let val = Cast.toNumber(NOTE);
       if (!val && /^[a-g]/i.test(`${NOTE}`)) {
         val = noteNameToMidiPitch(Cast.toString(NOTE)) || 0;
@@ -2088,13 +2095,12 @@
       /** @type {EventType} */
       // @ts-ignore
       let type = Cast.toString(TYPE);
-      // TODO make menu for EVENT_TYPE that doesn't include "any"
       // default is CC - is that right?
       // @ts-ignore
-      if (type === ANY_TYPE) type = "cc";
+      if (this._isAnyArg(type)) type = "cc";
+      let spec = eventMapping[type];
       // UNDOCUMENTED - allow raw number for command.
       // note that the command lookup restricts command types, so will exclude sysex messages (which are possible security risk but already blocked by browsers anyways)
-      let spec = eventMapping[type];
       if (!spec && /(0x)?[a-f0-9]+/i.test(type)) {
         const rawType = /[a-f]/.test(type)
           ? parseInt(type, 16)
@@ -2149,7 +2155,7 @@
       const events = this.recorder.getRange(start);
       if (LIST) {
         this._upsertList(
-          LIST,
+          Cast.toString(LIST),
           events.map((evt) => evt._str),
           util.target
         );
@@ -2161,13 +2167,19 @@
       return notes.map((note) => note._str ?? midiToString(note)).join("\n");
     }
     getActiveNoteByIndex({ INDEX }, util) {
-      const index = Cast.toNumber(INDEX) || 0;
       let active = getThreadActiveNotes(util.thread);
       if (!active) {
         active = { notes: this.recorder.getActiveNotes() };
         setThreadActiveNotes(util.thread, active);
       }
-      const note = (active.notes || [])[index];
+      let index = Cast.toListIndex(INDEX, active.length, true);
+      if (!active.notes || index === 'INVALID') {
+        return "";
+      }
+      if (index === 'ALL') {
+        index = 1;
+      }
+      const note = active.notes[index - 1];
       if (note) {
         setThreadMidiValue(util.thread, note);
         return note._str;
@@ -2179,7 +2191,7 @@
       setThreadActiveNotes(util.thread, { notes });
       if (LIST) {
         this._upsertList(
-          LIST,
+          Cast.toString(LIST),
           notes.map((note) => note._str),
           util.target
         );

From 4848f425797623f889d7812b68cb3f840444c9c0 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 10 Mar 2025 11:24:19 -0400
Subject: [PATCH 06/61] Update midi.js

---
 extensions/midi/midi.js | 36 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 8523b5bf7e..409829fa54 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -478,14 +478,11 @@
       case "pitchBend":
         if (value1 == undefined) return null;
         // these two types have a higher precision value
-        parsedHighRes = parseHighResValue(
-          value1,
-          value2
-        );
+        parsedHighRes = parseHighResValue(value1, value2);
         Object.assign(event, {
           [spec.highResParam ?? "value"]: parsedHighRes.value,
           value1: parsedHighRes.value1,
-          value2: parsedHighRes.value2
+          value2: parsedHighRes.value2,
         });
         break;
       case "clock":
@@ -601,8 +598,7 @@
     return (msb << 7) + lsb;
   }
   function parseHighResValue(value1, value2) {
-    const value =
-      (value2 == undefined) ? value1 : msbLsbToValue(value1, value2);
+    const value = value2 == undefined ? value1 : msbLsbToValue(value1, value2);
     return {
       value,
       ...valueToMsbLsb(value),
@@ -829,11 +825,7 @@
     get defaultOutput() {
       return this.outputs.find((d) => d.state === "connected");
     }
-    initialize({
-      sysex = false,
-      force = false,
-      timeoutMS = 1e3 * 30,
-    } = {}) {
+    initialize({ sysex = false, force = false, timeoutMS = 1e3 * 30 } = {}) {
       if (this._init && !force) {
         return this._init;
       }
@@ -1867,14 +1859,11 @@
     }
     /**
      * Checks if input value is whitespace or '*' or 'any'.
-     * @param {unknown} val 
+     * @param {unknown} val
      * @returns {val is typeof ANY_TYPE}
      */
     _isAnyArg(val) {
-      return (
-        val === ANY_TYPE ||
-        /^(\*|any|\s*)$/i.test(Cast.toString(val))
-      );
+      return val === ANY_TYPE || /^(\*|any|\s*)$/i.test(Cast.toString(val));
     }
     numDevices({ DEVICE_TYPE }) {
       this._ensureInitialize();
@@ -1893,10 +1882,11 @@
       const deviceList =
         deviceType === "input" ? this.midi.inputs : this.midi.outputs;
       const index = Cast.toListIndex(INDEX, deviceList.length, false);
-      const device = typeof index === 'number' ? deviceList[index - 1] : undefined;
+      const device =
+        typeof index === "number" ? deviceList[index - 1] : undefined;
       if (!device) return "";
       const prop = Cast.toString(DEVICE_PROP);
-      return device[DEVICE_PROP] ?? "";
+      return device[prop] ?? "";
     }
     inputDevicesMenu() {
       const inputList = this.midi.inputs.map((d) => ({
@@ -1954,9 +1944,7 @@
     }
     whenMidiEvent({ TYPE }, util) {
       const isAny = this._isAnyArg(TYPE);
-      const type = isAny
-        ? undefined
-        : normalizeType(Cast.toString(TYPE));
+      const type = isAny ? undefined : normalizeType(Cast.toString(TYPE));
       const last = this.recorder.getLast();
       if (last && (isAny || last.type === type)) {
         setThreadMidiValue(util.thread, last);
@@ -2173,10 +2161,10 @@
         setThreadActiveNotes(util.thread, active);
       }
       let index = Cast.toListIndex(INDEX, active.length, true);
-      if (!active.notes || index === 'INVALID') {
+      if (!active.notes || index === "INVALID") {
         return "";
       }
-      if (index === 'ALL') {
+      if (index === "ALL") {
         index = 1;
       }
       const note = active.notes[index - 1];

From 488e76b5ccef3db9ba2ba0cedf80d20c51ef5981 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 11:30:34 -0400
Subject: [PATCH 07/61] midi - add "whenDeviceEvent" hat for detecting device
 connect/disconnect

---
 extensions/midi/midi.js | 46 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 409829fa54..b7e75bd191 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -782,6 +782,10 @@
           }
         }
       };
+      /**
+       *
+       * @param {MIDIPortEventMap['statechange']} event
+       */
       this._onDeviceStateChange = (event) => {
         const { port } = event;
         if (!port) return;
@@ -1275,6 +1279,7 @@
 
   // hardcoded mapping of hats events, b/c I'll never remember the convention otherwise
   const HATS = {
+    DEVICE: `${EXT_ID}_whenDeviceEvent`,
     NOTE: `${EXT_ID}_whenNoteOnOff`,
     NOTEANY: `${EXT_ID}_whenAnyNoteOnOff`,
     MIDI: `${EXT_ID}_whenMidiEvent`,
@@ -1310,6 +1315,13 @@
      */
     _addListeners() {
       const vm = globalThis.Scratch.vm;
+      this.midi.on("device:status", (domEvent) => {
+        const changeEvent = domEvent.detail;
+        vm.runtime.startHats(HATS.DEVICE, {
+          DEVICE_TYPE: changeEvent.type,
+          STATE: changeEvent.state,
+        });
+      });
       this.midi.on("midi", (domEvent) => {
         const midiEvent = domEvent.detail;
         this.recorder.add(midiEvent);
@@ -1365,6 +1377,25 @@
           //     }
           //   }
           // },
+          {
+            opcode: "whenDeviceEvent",
+            text: Scratch.translate("when [DEVICE_TYPE] device [STATE]"),
+            blockType: Scratch.BlockType.EVENT,
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            arguments: {
+              DEVICE_TYPE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "DEVICE_TYPES",
+                defaultValue: "input",
+              },
+              STATE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "DEVICE_STATES",
+                defaultValue: "connected",
+              },
+            },
+          },
           {
             opcode: "numDevices",
             text: Scratch.translate("number of [DEVICE_TYPE] devices"),
@@ -1755,7 +1786,7 @@
             items: "outputDevicesMenu",
           },
           DEVICE_TYPES: {
-            acceptReporters: true,
+            acceptReporters: false,
             items: [
               { value: "input", text: Scratch.translate("input") },
               { value: "output", text: Scratch.translate("output") },
@@ -1773,6 +1804,16 @@
               { value: "state", text: Scratch.translate("State") },
             ],
           },
+          DEVICE_STATES: {
+            acceptReporters: false,
+            items: [
+              { value: "connected", text: Scratch.translate("connected") },
+              {
+                value: "disconnected",
+                text: Scratch.translate("disconnected"),
+              },
+            ],
+          },
           NOTE_EVENT_TYPE: {
             acceptReporters: true,
             items: [
@@ -1906,6 +1947,9 @@
         outputList
       );
     }
+    // handled automatically b/c blockType = EVENT instead of HAT
+    // whenDeviceEvent({ DEVICE_TYPE, STATE }, util) {
+    // }
     whenNoteOnOff({ NOTE, PRESS }, util) {
       const isAny = this._isAnyArg(PRESS);
       let type = isAny

From 065976d8e101ede9478d02c806f1f7641bd562c0 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 11:30:49 -0400
Subject: [PATCH 08/61] add midi to extensions list

---
 extensions/extensions.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/extensions/extensions.json b/extensions/extensions.json
index d8ed71e33d..43d6c3a2c9 100644
--- a/extensions/extensions.json
+++ b/extensions/extensions.json
@@ -48,6 +48,7 @@
   "ar",
   "encoding",
   "Lily/SoundExpanded",
+  "midi/midi",
   "Lily/TempVariables2",
   "Lily/MoreTimers",
   "clouddata-ping",

From 1b8ec5baf5ee90446b71349bf26fec6278155da4 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 14:34:26 -0400
Subject: [PATCH 09/61] bugfix in string parsing and minor formatting

---
 extensions/midi/midi.js | 51 +++++++++++++++++++++--------------------
 1 file changed, 26 insertions(+), 25 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index b7e75bd191..2977399a15 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -22,30 +22,31 @@
    * // definition for the parsed midi event
    * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset'} EventType
    * @typedef {object} MidiEvent
-   * @property {EventType | 'rest'} type
-   * @property {number} [value1]
-   * @property {number} [value2]
-   * @property {number} [channel]
-   * @property {number} [device]
-   * @property {number} [time]
-   * @property {number} [pitch]
-   * @property {number} [velocity]
-   * @property {number} [cc]
-   * @property {number} [value]
-   * @property {number} [pos]
-   * @property {number} [dur]
+   * @property {EventType | 'rest'} type type of midi command (note on, program change, tc). Default is 'noteOn'
+   * @property {number} [value1] (0-127) raw data1 byte value
+   * @property {number} [value2] (0-127) raw data2 byte value
+   * @property {number} [channel] (1-16) channel of event. default is 1
+   * @property {number} [device] (1-N) index of midi input/output device
+   * @property {number} [time] time of event in seconds
+   * @property {number} [pitch] note pitch (0-127). C4=60
+   * @property {number} [velocity] note velocity (0-127). If this is 0 then treated as a note off event
+   * @property {number} [cc] continuous controller number (0-127)
+   * @property {number} [value] cc / pitchBend/programChange value (0-127 except for songPosition / pitchbend)
+   * @property {number} [pos] time in beats - gets converted to time using current tempo
+   * @property {number} [dur] (note type only) duration in seconds- send corresponding note off event automatically
+   * @property {number} [beats] gets converted to dur using current tempo
    * @property {string} [_str] cached string representation of this event
    *
    *
    * @typedef {object} FormatOptions
-   * @property {number} [tempo]
-   * @property {boolean} [useFlats]
-   * @property {boolean} [noMinify]
-   * @property {'omit' | 'timestamp' | 'absolute'} [timestampFormat]
-   * @property {number} [startTimestamp]
-   * @property {boolean} [fixedWidth]
-   * @property {boolean} [useHex]
-   * @property {number} [defaultOctave]
+   * @property {number} [tempo] override tempo used in converting beats/pos. default is stage tempo
+   * @property {boolean} [useFlats] show notes as flats instead of sharps
+   * @property {boolean} [noMinify] include all data even if defaults
+   * @property {'omit' | 'timestamp' | 'absolute'} [timestampFormat] for future use
+   * @property {number} [startTimestamp] for future use
+   * @property {boolean} [fixedWidth] include padding to make values line up
+   * @property {boolean} [useHex] use hex for number values instead of base 10
+   * @property {number} [defaultOctave] default octave if not otherwise specfied. default 4
    *
    */
 
@@ -396,7 +397,7 @@
   function stringToMidi(text, opts = {}) {
     if (typeof text !== "string") text = Cast.toString(text);
     const fullRe =
-      /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
+      /^\s*(?<type>[a-zA-Z]{2,}|~)?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.*)\s*$/;
     const match = fullRe.exec(text);
     if (!match?.groups) return null;
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
@@ -517,7 +518,7 @@
   }
   function formatTime(
     { time = undefined },
-    { noMinify = false, timestampFormat = "absolute", startTimestamp = 0 }
+    { timestampFormat = "absolute", startTimestamp = 0 }
   ) {
     if (timestampFormat === "omit" || time == undefined) {
       return "";
@@ -531,12 +532,12 @@
   }
 
   // TODO FUTURE add in opts flag to use fractions or not
-  function formatPosition(value, opts) {
+  function formatPosition(value, _opts) {
     return `${PREFIX_POS}${formatFraction(value)}`;
   }
 
   // TODO FUTURE add in opts flag to use fractions or not
-  function formatDuration(value, opts) {
+  function formatDuration(value, _opts) {
     return `${PREFIX_DURATION}${formatFraction(value)}`;
   }
 
@@ -1566,7 +1567,7 @@
           {
             opcode: "playNoteForBeats",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate("play midi note [NOTE] for [BEATS] beats"),
+            text: Scratch.translate("play note [NOTE] for [BEATS] beats"),
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,

From 9f8dfeadfe3bbdc3a54e9829a5787d46663cb1de Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 14:35:20 -0400
Subject: [PATCH 10/61] midi - change params for sendOutputEvent

---
 extensions/midi/midi.js | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 2977399a15..548b7e7f6c 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -1582,17 +1582,15 @@
           {
             opcode: "sendOutputEvent",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate(
-              "schedule [EVENT] for [POS] beats from now"
-            ),
+            text: Scratch.translate("Send [EVENT] to [DEVICE]"),
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
                 defaultValue: "Eb4 beats=1/4",
               },
-              POS: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0,
+              DEVICE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "OUTPUT_DEVICES",
               },
             },
           },
@@ -2028,17 +2026,16 @@
       });
       this.midi.sendOutputEvent(event);
     }
-    sendOutputEvent({ EVENT, POS }, util) {
+    sendOutputEvent({ EVENT, DEVICE }, util) {
       const text = Cast.toString(EVENT);
-      const pos =
-        typeof POS === "string" && POS.includes("/")
-          ? parseFraction(POS)
-          : Cast.toNumber(POS);
-      const event = this._eventBeatsToSeconds({
-        // default value is 0, so if event has something set (like "C#3 pos=1/4 beats=1") then let it take precedence, otherwise override
-        ...(pos > 0 && { pos }),
-        ...stringToMidi(text),
-      });
+      const event = stringToMidi(text);
+
+      const deviceId = Cast.toString(DEVICE);
+      if (deviceId && event.device == undefined) {
+        const device =
+          deviceId && this.midi.outputs.findIndex((d) => d.id === deviceId);
+        event.device = device === -1 ? undefined : device;
+      }
 
       this.midi.sendOutputEvent(event);
     }

From 17a9e6b7603472d2ac8b24b57605e3a60383b29e Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 14:38:14 -0400
Subject: [PATCH 11/61] midi - treat "pos" and "beats" as beats unit, "time"
 and "dur" as seconds

---
 extensions/midi/midi.js | 45 ++++++++++++++++-------------------------
 1 file changed, 17 insertions(+), 28 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 548b7e7f6c..3340a457d7 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -252,6 +252,7 @@
     dur: "dur",
     duration: "dur",
     pos: "pos",
+    beats: "beats",
     value: "value2",
   };
 
@@ -403,7 +404,7 @@
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
     // ch/dev/@ (channel, device, time) are special keys that don't need =
     const keyvalRe = /\s*(?<key>\w+(?==)|ch|dev|@)=?(?<val>\S+)\s*/g;
-    /** @type {{[K in keyof MidiEvent]?: string}} */
+    /** @type {{[K in keyof MidiEvent | 'beats']?: string}} */
     const extras = Object.fromEntries(
       Array.from(match.groups.keyvals?.matchAll(keyvalRe) || [])
         // paramLookup converts "t=2" into "time=2"
@@ -431,11 +432,20 @@
       channel: parseNumValue(extras.channel, opts),
       device: parseNumValue(extras.device, opts),
       ...(extras.time && { time: parseTimespan(extras.time) }),
-      // REVIEW is pos even needed? it's for setting output in beats, but setting time would make more sense instead
-      ...(extras.pos && { pos: parseFraction(extras.pos) }),
       ...(extras.dur && { dur: parseFraction(extras.dur) }),
+      ...(extras.pos && { pos: parseFraction(extras.pos) }),
+      ...(extras.beats && { beats: parseFraction(extras.beats) }),
     };
 
+    if (event.beats && event.dur == undefined) {
+      // NOTE - looks up tempo in vm stage
+      event.dur = beatsToSeconds(event.beats, opts.tempo);
+    }
+    if (event.pos && event.time == undefined) {
+      // NOTE - looks up tempo in vm stage
+      event.time = beatsToSeconds(event.pos, opts.tempo);
+    }
+
     // default to note event if has pitch (off if velocity = 0)
     if (!event.type && value1 >= 0) {
       event.type = "noteOn";
@@ -684,11 +694,11 @@
    * @param {number} [offsetMs] time to return relative to. Default is now
    */
   function getMidiOffsetTime(event, offsetMs = window.performance.now()) {
-    const { pos = 0, dur } = event;
+    const { time = 0, dur } = event;
     return {
-      start: offsetMs + pos * 1000,
+      start: offsetMs + time * 1000,
       ...(dur > 0 && {
-        end: offsetMs + (pos + dur) * 1000,
+        end: offsetMs + (time + dur) * 1000,
       }),
     };
   }
@@ -1995,23 +2005,6 @@
       }
       return false;
     }
-    /**
-     *
-     * @param {MidiEvent} event
-     * @returns {MidiEvent}
-     */
-    _eventBeatsToSeconds(event) {
-      const tempo = getTempo();
-      const { dur, pos } = event;
-      const out = { ...event };
-      if (dur != undefined) {
-        out.dur = beatsToSeconds(parseFraction(dur), tempo);
-      }
-      if (pos != undefined) {
-        out.pos = beatsToSeconds(parseFraction(pos), tempo);
-      }
-      return out;
-    }
     playNoteForBeats({ NOTE, BEATS }, util) {
       const pitch = noteNameToMidiPitch(Cast.toString(NOTE)) || undefined;
       const beats =
@@ -2019,11 +2012,7 @@
           ? parseFraction(BEATS)
           : Cast.toNumber(BEATS);
 
-      const event = this._eventBeatsToSeconds({
-        type: "noteOn",
-        ...(pitch != undefined && { pitch }),
-        dur: beats,
-      });
+      const event = stringToMidi(`${text}`);
       this.midi.sendOutputEvent(event);
     }
     sendOutputEvent({ EVENT, DEVICE }, util) {

From ccda8863328f6b261148261d544f6c73ec64b675 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 14:38:55 -0400
Subject: [PATCH 12/61] allow string event input into "play note for beats"
 command

---
 extensions/midi/midi.js | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 3340a457d7..2f40f55150 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -2006,12 +2006,15 @@
       return false;
     }
     playNoteForBeats({ NOTE, BEATS }, util) {
-      const pitch = noteNameToMidiPitch(Cast.toString(NOTE)) || undefined;
-      const beats =
-        typeof BEATS === "string" && BEATS.includes("/")
-          ? parseFraction(BEATS)
-          : Cast.toNumber(BEATS);
+      let text = Cast.toString(NOTE);
+      const beats = Cast.toString(BEATS);
+
+      // just append to text and let stringToMidi handle
+      if (beats) {
+        text += ` beats=${beats}`;
+      }
 
+      // default event type is note, so any valid input will be treated as note by default
       const event = stringToMidi(`${text}`);
       this.midi.sendOutputEvent(event);
     }

From eb5b977e06023a7016f89696182c8750b7d06cc5 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 13 Mar 2025 00:38:38 -0400
Subject: [PATCH 13/61] reformatting as per comments

---
 extensions/midi/midi.js | 236 ++++++++++++++++++++++++++--------------
 1 file changed, 155 insertions(+), 81 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 2f40f55150..629ae8fde7 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -74,6 +74,8 @@
   }
   /**
    * convert a note string name (or raw midi number) to midi number value
+   * Examples of valid inputs: C4 C_4 C#7 Db6 F# F♯♯ B♭0 60 32
+   * Returns null if not a valid pitch string or midi note number
    * @param {string} note
    * @param {number} [defaultOctave]
    * @returns {number | null}
@@ -396,7 +398,7 @@
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
-    if (typeof text !== "string") text = Cast.toString(text);
+    if (typeof text !== "string") text = Scratch.Cast.toString(text);
     const fullRe =
       /^\s*(?<type>[a-zA-Z]{2,}|~)?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.*)\s*$/;
     const match = fullRe.exec(text);
@@ -716,10 +718,6 @@
     .flatMap((_, i) => SHARPS.map((c) => `${c}${i - 1}`))
     .slice(0, 128);
 
-  /**
-   * represents "any note" or "any device" etc. in menus
-   */
-  const ANY_TYPE = "*";
   /**
    * Scratch menu items of @see {MidiEvent} properties
    */
@@ -1302,7 +1300,6 @@
    * @type {'---'}
    */
   const SEPARATOR = "---";
-  const { Cast } = Scratch;
 
   class MidiExtension {
     constructor() {
@@ -1356,12 +1353,30 @@
     }
     getInfo() {
       const EVENT_TYPES_ITEMS = [
-        { value: "noteOn", text: Scratch.translate("Note On") },
-        { value: "noteOff", text: Scratch.translate("Note Off") },
-        { value: "cc", text: Scratch.translate("CC") },
-        { value: "polyTouch", text: Scratch.translate("AfterTouch") },
-        { value: "pitchBend", text: Scratch.translate("Pitch Bend") },
-        { value: "programChange", text: Scratch.translate("Program Change") },
+        {
+          value: "noteOn",
+          text: Scratch.translate("Note On"),
+        },
+        {
+          value: "noteOff",
+          text: Scratch.translate("Note Off"),
+        },
+        {
+          value: "cc",
+          text: Scratch.translate("CC"),
+        },
+        {
+          value: "polyTouch",
+          text: Scratch.translate("AfterTouch"),
+        },
+        {
+          value: "pitchBend",
+          text: Scratch.translate("Pitch Bend"),
+        },
+        {
+          value: "programChange",
+          text: Scratch.translate("Program Change"),
+        },
         {
           value: "channelPressure",
           text: Scratch.translate("Channel Pressure"),
@@ -1457,7 +1472,7 @@
               PRESS: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_EVENT_TYPE",
-                defaultValue: ANY_TYPE,
+                defaultValue: "ANY",
               },
             },
           },
@@ -1471,7 +1486,7 @@
               PRESS: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_EVENT_TYPE",
-                defaultValue: ANY_TYPE,
+                defaultValue: "ANY",
               },
             },
           },
@@ -1485,7 +1500,7 @@
               TYPE: {
                 menu: "EVENT_TYPES_OPTIONAL",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: ANY_TYPE,
+                defaultValue: "ANY",
               },
             },
           },
@@ -1783,7 +1798,10 @@
             acceptReporters: true,
             items: [
               ...EVENT_TYPES_ITEMS,
-              { value: ANY_TYPE, text: Scratch.translate("Any") },
+              {
+                value: "ANY",
+                text: Scratch.translate("Any"),
+              },
             ],
           },
           INPUT_DEVICES: {
@@ -1797,26 +1815,44 @@
           DEVICE_TYPES: {
             acceptReporters: false,
             items: [
-              { value: "input", text: Scratch.translate("input") },
-              { value: "output", text: Scratch.translate("output") },
+              {
+                value: "input",
+                text: Scratch.translate("input"),
+              },
+              {
+                value: "output",
+                text: Scratch.translate("output"),
+              },
             ],
           },
           DEVICE_PROP: {
             acceptReporters: true,
             items: [
-              { value: "id", text: Scratch.translate("Device ID") },
+              {
+                value: "id",
+                text: Scratch.translate("Device ID"),
+              },
               {
                 value: "manufacturer",
                 text: Scratch.translate("Manufacturer"),
               },
-              { value: "name", text: Scratch.translate("Device Name") },
-              { value: "state", text: Scratch.translate("State") },
+              {
+                value: "name",
+                text: Scratch.translate("Device Name"),
+              },
+              {
+                value: "state",
+                text: Scratch.translate("State"),
+              },
             ],
           },
           DEVICE_STATES: {
             acceptReporters: false,
             items: [
-              { value: "connected", text: Scratch.translate("connected") },
+              {
+                value: "connected",
+                text: Scratch.translate("connected"),
+              },
               {
                 value: "disconnected",
                 text: Scratch.translate("disconnected"),
@@ -1826,16 +1862,31 @@
           NOTE_EVENT_TYPE: {
             acceptReporters: true,
             items: [
-              { value: ANY_TYPE, text: Scratch.translate("Note On/Off") },
-              { value: "noteOn", text: Scratch.translate("Note On") },
-              { value: "noteOff", text: Scratch.translate("Note Off") },
+              {
+                value: "ANY",
+                text: Scratch.translate("Note On/Off"),
+              },
+              {
+                value: "noteOn",
+                text: Scratch.translate("Note On"),
+              },
+              {
+                value: "noteOff",
+                text: Scratch.translate("Note Off"),
+              },
             ],
           },
           ACCIDENTALS: {
             acceptReporters: true,
             items: [
-              { value: "sharps", text: `♯ ${Scratch.translate("Sharps")}` },
-              { value: "flats", text: `♭ ${Scratch.translate("Flats")}` },
+              {
+                value: "sharps",
+                text: `♯ ${Scratch.translate("Sharps")}`,
+              },
+              {
+                value: "flats",
+                text: `♭ ${Scratch.translate("Flats")}`,
+              },
             ],
           },
           NOTE_NAMES: {
@@ -1849,7 +1900,10 @@
           CHANNELS: {
             acceptReporters: true,
             items: [
-              { value: "0", text: Scratch.translate("any channel") },
+              {
+                value: "0",
+                text: Scratch.translate("any channel"),
+              },
               ..."0"
                 .repeat(15)
                 .split("")
@@ -1869,9 +1923,18 @@
           DEVICE_PROPS: {
             acceptReporters: true,
             items: [
-              { value: "id", text: Scratch.translate("Id") },
-              { value: "name", text: Scratch.translate("Name") },
-              { value: "state", text: Scratch.translate("State") },
+              {
+                value: "id",
+                text: Scratch.translate("Id"),
+              },
+              {
+                value: "name",
+                text: Scratch.translate("Name"),
+              },
+              {
+                value: "state",
+                text: Scratch.translate("State"),
+              },
               {
                 value: "manufacturer",
                 text: Scratch.translate("Manufacturer"),
@@ -1904,20 +1967,23 @@
       }
     }
     async initialize({ sysex = false, FORCE = false } = {}, util) {
-      const force = Cast.toBoolean(FORCE);
+      const force = Scratch.Cast.toBoolean(FORCE);
       await this.midi.initialize({ sysex, force });
     }
     /**
      * Checks if input value is whitespace or '*' or 'any'.
      * @param {unknown} val
-     * @returns {val is typeof ANY_TYPE}
+     * @returns {val is "ANY"}
      */
     _isAnyArg(val) {
-      return val === ANY_TYPE || /^(\*|any|\s*)$/i.test(Cast.toString(val));
+      return (
+        val === "ANY" || /^(\*|any|\s*)$/i.test(Scratch.Cast.toString(val))
+      );
+    }
     }
     numDevices({ DEVICE_TYPE }) {
       this._ensureInitialize();
-      const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
+      const deviceType = Scratch.Cast.toString(DEVICE_TYPE).toLowerCase();
       const deviceList =
         deviceType === "output" ? this.midi.outputs : this.midi.inputs;
 
@@ -1928,14 +1994,14 @@
       return this.midi.outputs.length;
     }
     getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
-      const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
+      const deviceType = Scratch.Cast.toString(DEVICE_TYPE).toLowerCase();
       const deviceList =
         deviceType === "input" ? this.midi.inputs : this.midi.outputs;
-      const index = Cast.toListIndex(INDEX, deviceList.length, false);
+      const index = Scratch.Cast.toListIndex(INDEX, deviceList.length, false);
       const device =
         typeof index === "number" ? deviceList[index - 1] : undefined;
       if (!device) return "";
-      const prop = Cast.toString(DEVICE_PROP);
+      const prop = Scratch.Cast.toString(DEVICE_PROP);
       return device[prop] ?? "";
     }
     inputDevicesMenu() {
@@ -1943,7 +2009,7 @@
         text: d.name || d.id,
         value: d.id,
       }));
-      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(
+      return [{ text: Scratch.translate("any"), value: "ANY" }].concat(
         inputList
       );
     }
@@ -1952,7 +2018,7 @@
         text: d.name || d.id,
         value: d.id,
       }));
-      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(
+      return [{ text: Scratch.translate("any"), value: "ANY" }].concat(
         outputList
       );
     }
@@ -1963,9 +2029,11 @@
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
         ? ["noteOn", "noteOff"]
-        : [normalizeType(Cast.toString(PRESS))];
+        : [normalizeType(Scratch.Cast.toString(PRESS))];
 
-      const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
+      const pitch = this._isAnyArg(NOTE)
+        ? undefined
+        : Scratch.Cast.toNumber(NOTE);
       const last = this.recorder.getLast();
 
       // filter if only note on or note off
@@ -1984,7 +2052,7 @@
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
         ? ["noteOn", "noteOff"]
-        : [normalizeType(Cast.toString(PRESS))];
+        : [normalizeType(Scratch.Cast.toString(PRESS))];
 
       const last = this.recorder.getLast();
       // filter if only note on or note off
@@ -1997,7 +2065,9 @@
     }
     whenMidiEvent({ TYPE }, util) {
       const isAny = this._isAnyArg(TYPE);
-      const type = isAny ? undefined : normalizeType(Cast.toString(TYPE));
+      const type = isAny
+        ? undefined
+        : normalizeType(Scratch.Cast.toString(TYPE));
       const last = this.recorder.getLast();
       if (last && (isAny || last.type === type)) {
         setThreadMidiValue(util.thread, last);
@@ -2006,8 +2076,8 @@
       return false;
     }
     playNoteForBeats({ NOTE, BEATS }, util) {
-      let text = Cast.toString(NOTE);
-      const beats = Cast.toString(BEATS);
+      let text = Scratch.Cast.toString(NOTE);
+      const beats = Scratch.Cast.toString(BEATS);
 
       // just append to text and let stringToMidi handle
       if (beats) {
@@ -2019,7 +2089,7 @@
       this.midi.sendOutputEvent(event);
     }
     sendOutputEvent({ EVENT, DEVICE }, util) {
-      const text = Cast.toString(EVENT);
+      const text = Scratch.Cast.toString(EVENT);
       const event = stringToMidi(text);
 
       const deviceId = Cast.toString(DEVICE);
@@ -2035,7 +2105,7 @@
       this.midi.panic();
     }
     getEventProp({ EVENT, PROP }, util) {
-      const propName = Cast.toString(PROP);
+      const propName = Scratch.Cast.toString(PROP);
       const { key = "value" } = eventProps[propName] ?? {};
       if (!EVENT) return "";
       const last = getThreadMidiValue(util.thread);
@@ -2050,8 +2120,10 @@
       return last ? midiToString(last) : "";
     }
     isNoteActive({ NOTE, CHANNEL }, util) {
-      const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
-      const channel = Cast.toNumber(CHANNEL) || undefined;
+      const pitch = this._isAnyArg(NOTE)
+        ? undefined
+        : Scratch.Cast.toNumber(NOTE);
+      const channel = Scratch.Cast.toNumber(CHANNEL) || undefined;
       if (pitch == undefined) {
         const notes = this.recorder.getActiveNotes(channel);
         setThreadActiveNotes(util.thread, { channel, notes });
@@ -2066,57 +2138,59 @@
       return !!note;
     }
     isEventOfType({ TYPE }, util) {
-      const type = this._isAnyArg(TYPE) ? undefined : Cast.toString(TYPE);
+      const type = this._isAnyArg(TYPE)
+        ? undefined
+        : Scratch.Cast.toString(TYPE);
       let last = getThreadMidiValue(util.thread);
       last || (last = this.recorder.getLast());
       return last?.type === type;
     }
     noteForName({ NOTE }) {
       if (typeof NOTE === "number" || /^\d+$/.test(NOTE)) {
-        return Cast.toNumber(NOTE);
+        return Scratch.Cast.toNumber(NOTE);
       }
-      const name = Cast.toString(NOTE);
+      const name = Scratch.Cast.toString(NOTE);
       return noteNameToMidiPitch(name) || 0;
     }
     nameForNote({ NOTE, ACCIDENTAL }, util) {
-      const useFlats = Cast.toString(ACCIDENTAL).toLowerCase() === "flats";
-      let val = Cast.toNumber(NOTE);
+      const useFlats =
+        Scratch.Cast.toString(ACCIDENTAL).toLowerCase() === "flats";
+      let val = Scratch.Cast.toNumber(NOTE);
       if (!val && /^[a-g]/i.test(`${NOTE}`)) {
-        val = noteNameToMidiPitch(Cast.toString(NOTE)) || 0;
+        val = noteNameToMidiPitch(Scratch.Cast.toString(NOTE)) || 0;
       }
       return midiPitchToNoteName(val, { useFlats });
     }
     makeOutputNote({ NOTE, BEATS, VELOCITY, CHANNEL, DEVICE }) {
-      let dur =
+      let beats =
         typeof BEATS === "string" && BEATS.includes("/")
           ? parseFraction(BEATS)
-          : Cast.toNumber(BEATS);
-      // sanity check - don't let a note be more than 1 minute
-      // if anyone ever needs a longer note then they should manually write event string
-      dur = Math.max(0, Math.min(dur, 60));
+          : Scratch.Cast.toNumber(BEATS);
+      /** sanity check - clamp beats as per scratch music extension limits
+       * @see {@link https://github.com/TurboWarp/scratch-vm/blob/develop/src/extensions/scratch3_music/index.js#L706}
+       */
+      beats = Math.max(0, Math.min(beats, 100));
       // convert from percent to midi value
-      let velocity = (Cast.toNumber(VELOCITY) / 100) * 127;
+      let velocity = (Scratch.Cast.toNumber(VELOCITY) / 100) * 127;
       // clamp value
       // NOTE - if 0 velocity then nothing will happen because treated as note off
       velocity = Math.max(0, Math.min(velocity, 127));
-      // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
-      const deviceId = Cast.toString(DEVICE);
-      const device = this.midi.outputs.findIndex((d) => d.id === deviceId);
+      const device = this._getDeviceIndex(DEVICE, "output");
       /** @type {MidiEvent} */
       const event = {
         type: "noteOn",
         pitch: this.noteForName({ NOTE }),
         velocity,
-        channel: Cast.toNumber(CHANNEL) || undefined,
-        device: device === -1 ? undefined : device,
-        dur,
+        channel: Scratch.Cast.toNumber(CHANNEL) || undefined,
+        device,
+        beats,
       };
       return midiToString(event);
     }
     makeOutputEvent({ TYPE, VALUE1, VALUE2, CHANNEL, DEVICE }) {
       /** @type {EventType} */
       // @ts-ignore
-      let type = Cast.toString(TYPE);
+      let type = Scratch.Cast.toString(TYPE);
       // default is CC - is that right?
       // @ts-ignore
       if (this._isAnyArg(type)) type = "cc";
@@ -2131,12 +2205,12 @@
       }
 
       // clamp values
-      let value1 = Cast.toNumber(VALUE1);
+      let value1 = Scratch.Cast.toNumber(VALUE1);
       // pitchbend can be a bigger number
       const maxValue1 = spec?.highResParam ? 16384 : 127;
       value1 = Math.max(0, Math.min(value1, maxValue1));
 
-      let value2 = Cast.toNumber(VALUE2);
+      let value2 = Scratch.Cast.toNumber(VALUE2);
       value2 = Math.max(0, Math.min(value2, 127));
 
       // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
@@ -2148,8 +2222,8 @@
         type,
         value1,
         value2,
-        channel: Cast.toNumber(CHANNEL) || undefined,
         device: device === -1 ? undefined : device,
+        channel: Scratch.Cast.toNumber(CHANNEL) || undefined,
         ...(spec?.param1 && { [spec.param1]: value1 }),
         ...(spec?.param2 && { [spec.param2]: value2 }),
         ...(spec?.highResParam && parseHighResValue(value1, value2)),
@@ -2157,9 +2231,9 @@
       return midiToString(event);
     }
     normalizeMidiVal({ VALUE, MIN, MAX }) {
-      const min = Cast.toNumber(MIN);
-      const max = Cast.toNumber(MAX);
-      const val = Cast.toNumber(VALUE) / 127;
+      const min = Scratch.Cast.toNumber(MIN);
+      const max = Scratch.Cast.toNumber(MAX);
+      const val = Scratch.Cast.toNumber(VALUE) / 127;
       return val * (max - min) + min;
     }
     getMidiStartTime() {
@@ -2172,12 +2246,12 @@
       this.recorder.clear();
     }
     setMidiEventList({ LIST, TIME }, util) {
-      const duration = Cast.toNumber(TIME) || 5;
+      const duration = Scratch.Cast.toNumber(TIME) || 5;
       const start = this.recorder._now() - duration;
       const events = this.recorder.getRange(start);
       if (LIST) {
         this._upsertList(
-          Cast.toString(LIST),
+          Scratch.Cast.toString(LIST),
           events.map((evt) => evt._str),
           util.target
         );
@@ -2194,7 +2268,7 @@
         active = { notes: this.recorder.getActiveNotes() };
         setThreadActiveNotes(util.thread, active);
       }
-      let index = Cast.toListIndex(INDEX, active.length, true);
+      let index = Scratch.Cast.toListIndex(INDEX, active.length, true);
       if (!active.notes || index === "INVALID") {
         return "";
       }
@@ -2213,7 +2287,7 @@
       setThreadActiveNotes(util.thread, { notes });
       if (LIST) {
         this._upsertList(
-          Cast.toString(LIST),
+          Scratch.Cast.toString(LIST),
           notes.map((note) => note._str),
           util.target
         );
@@ -2237,7 +2311,7 @@
       return active.notes.length;
     }
     eventToJSON({ EVENT }, util) {
-      const raw = Cast.toString(EVENT);
+      const raw = Scratch.Cast.toString(EVENT);
       // NOTE will be null if could not parse
       const event = stringToMidi(raw);
 
@@ -2250,7 +2324,7 @@
       return JSON.stringify(event);
     }
     jsonToEvent({ TEXT }, util) {
-      const raw = Cast.toString(TEXT);
+      const raw = Scratch.Cast.toString(TEXT);
       let event = null;
       try {
         event = {

From a12a8631bd8e97b3829710cbfff27b70ff31d2c9 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 13 Mar 2025 00:43:09 -0400
Subject: [PATCH 14/61] ensure device index starts at 1

---
 extensions/midi/midi.js | 51 ++++++++++++++++++++++++++---------------
 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 629ae8fde7..539df3e45d 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -800,13 +800,13 @@
         if (!port) return;
         const { type, id, name } = port;
         const deviceList = type === "input" ? this.inputs : this.outputs;
-        const index = deviceList.findIndex((dev) => dev.id === id);
-        if (index === -1) {
+        const rawIndex = deviceList.findIndex((dev) => dev.id === id);
+        if (rawIndex === -1) {
           this.refreshDevices();
           return;
         }
         this._emit("device:status", {
-          index,
+          index: rawIndex + 1,
           id,
           name,
           type,
@@ -816,7 +816,7 @@
       this._onInputEvent = (event) => {
         const { target: device, data, timeStamp } = event;
         if (!data) return;
-        const deviceIndex = this.inputs.indexOf(device);
+        const rawIndex = this.inputs.indexOf(device);
         const midiEvent = rawMessageToMidi(data);
         if (!midiEvent) {
           console.warn("Unable to parse message", data);
@@ -824,8 +824,8 @@
           return;
         } else {
           midiEvent.time = timeStamp / 1000;
-          if (deviceIndex !== -1) {
-            midiEvent.device = deviceIndex;
+          if (rawIndex !== -1) {
+            midiEvent.device = rawIndex + 1;
           }
           midiEvent._str = midiToString(midiEvent, { noMinify: true });
           this._emit("midi", midiEvent);
@@ -915,11 +915,14 @@
         return false;
       }
 
-      const device =
-        (data.device != undefined && this.outputs[data.device]) ||
-        this.defaultOutput;
+      let device;
+      // passed in index starts at 1
+      if (data.device != undefined && data.device > 0) {
+        device = this.outputs[data.device - 1];
+      }
+      device ||= this.defaultOutput;
       if (!device) {
-        // no output. Should this throw error?
+        // no output device so do nothing
         return false;
       }
       // ensure 0 velocity is interpreted as noteOff
@@ -1980,6 +1983,22 @@
         val === "ANY" || /^(\*|any|\s*)$/i.test(Scratch.Cast.toString(val))
       );
     }
+    _getDeviceIndex(DEVICE, deviceType) {
+      const deviceId = Scratch.Cast.toString(DEVICE);
+      const deviceList =
+        deviceType === "output" ? this.midi.outputs : this.midi.inputs;
+
+      const rawIndex = this.midi.outputs.findIndex((d) => d.id === deviceId);
+      if (rawIndex !== -1) {
+        // arrays start at 1
+        return rawIndex + 1;
+      }
+      // check if index passed in and use directly
+      const index = Scratch.Cast.toNumber(deviceId);
+      if (index >= 1 && index <= deviceList.length) {
+        return index;
+      }
+      return undefined;
     }
     numDevices({ DEVICE_TYPE }) {
       this._ensureInitialize();
@@ -2092,11 +2111,8 @@
       const text = Scratch.Cast.toString(EVENT);
       const event = stringToMidi(text);
 
-      const deviceId = Cast.toString(DEVICE);
-      if (deviceId && event.device == undefined) {
-        const device =
-          deviceId && this.midi.outputs.findIndex((d) => d.id === deviceId);
-        event.device = device === -1 ? undefined : device;
+      if (DEVICE) {
+        event.device = this._getDeviceIndex(DEVICE, "output");
       }
 
       this.midi.sendOutputEvent(event);
@@ -2214,16 +2230,15 @@
       value2 = Math.max(0, Math.min(value2, 127));
 
       // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
-      const deviceId = Cast.toString(DEVICE);
-      const device = this.midi.outputs.findIndex((d) => d.id === deviceId);
+      const device = this._getDeviceIndex(DEVICE, "output");
       // FUTURE this may make sense to get moved out to helper alongside rawMessageToMidi
       /** @type {MidiEvent} */
       const event = {
         type,
         value1,
         value2,
-        device: device === -1 ? undefined : device,
         channel: Scratch.Cast.toNumber(CHANNEL) || undefined,
+        device,
         ...(spec?.param1 && { [spec.param1]: value1 }),
         ...(spec?.param2 && { [spec.param2]: value2 }),
         ...(spec?.highResParam && parseHighResValue(value1, value2)),

From 6d0a1ca02c9fc4f63bb6cd6c4a9ac7e75319b7ce Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 17 Mar 2025 00:27:58 -0400
Subject: [PATCH 15/61] build(deps): bump @turbowarp/types from `4b59b95` to
 `b89be2e` (#2038)

Bumps [@turbowarp/types](https://github.com/TurboWarp/types-tw) from
`4b59b95` to `b89be2e`.
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/TurboWarp/types-tw/commit/b89be2e3ce64fa84774540dff026a42dd915ee3c"><code>b89be2e</code></a>
TW: add pause events</li>
<li>See full diff in <a
href="https://github.com/TurboWarp/types-tw/compare/4b59b95e3b02560ff626a36a871869b89dbe9a48...b89be2e3ce64fa84774540dff026a42dd915ee3c">compare
view</a></li>
</ul>
</details>
<br />


Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 package-lock.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 27489ef316..3aac4edf74 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -276,8 +276,8 @@
     },
     "node_modules/@turbowarp/types": {
       "version": "0.0.13",
-      "resolved": "git+ssh://git@github.com/TurboWarp/types-tw.git#4b59b95e3b02560ff626a36a871869b89dbe9a48",
-      "integrity": "sha512-4gHxtg0mMeWU1tJVK62InGL+yprQHbdJ5kyOjVtEBAhzX8hXQibcfYCpg0Sdh7QSjrEZ4VVNK3HbGh6cYaPYnQ==",
+      "resolved": "git+ssh://git@github.com/TurboWarp/types-tw.git#b89be2e3ce64fa84774540dff026a42dd915ee3c",
+      "integrity": "sha512-1VMhsp7fzrhLe+8pepcGO1/mglQbqJiuAJsFx2qpCgsexYEsc/6QPKr1as6F+QLMdmvqXWvmf9kNju8ofoZwRQ==",
       "license": "Apache-2.0"
     },
     "node_modules/@types/estree": {

From 53449c74e4edc769f42e2161c87c03911a91ff93 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 17 Mar 2025 00:29:06 -0400
Subject: [PATCH 16/61] build(deps): bump image-size from 2.0.0 to 2.0.1
 (#2039)

Bumps [image-size](https://github.com/image-size/image-size) from 2.0.0
to 2.0.1.
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/image-size/image-size/commit/a5750c51dc1d81756521521f5821da732038d8c4"><code>a5750c5</code></a>
2.0.1</li>
<li><a
href="https://github.com/image-size/image-size/commit/6c3cb7188aa244c84581e699d80474ddc581ec2c"><code>6c3cb71</code></a>
fix the bin script</li>
<li><a
href="https://github.com/image-size/image-size/commit/9cfcb4f395928e39dc30f0ba71e698af0cb5b863"><code>9cfcb4f</code></a>
Add a sync usage example</li>
<li>See full diff in <a
href="https://github.com/image-size/image-size/compare/v2.0.0...v2.0.1">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=image-size&package-manager=npm_and_yarn&previous-version=2.0.0&new-version=2.0.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 package-lock.json | 8 ++++----
 package.json      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 3aac4edf74..f80d339762 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,7 +16,7 @@
         "chokidar": "^4.0.3",
         "ejs": "^3.1.10",
         "express": "^4.21.2",
-        "image-size": "^2.0.0",
+        "image-size": "^2.0.1",
         "markdown-it": "^14.1.0"
       },
       "devDependencies": {
@@ -1241,9 +1241,9 @@
       }
     },
     "node_modules/image-size": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/image-size/-/image-size-2.0.0.tgz",
-      "integrity": "sha512-HP07n1SpdIXGUL4VotUIOQz66MQOq8g7VN+Yj02YTVowqZScQ5i/JYU0+lkNr2pwt5j4hOpk94/UBV1ZCbS2fA==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/image-size/-/image-size-2.0.1.tgz",
+      "integrity": "sha512-NI6NK/2zchlZopsQrcVIS7jxA0/rtIy74B+/rx5s7rKQyFebmQjZVhzxXgRZJROk+WhhOq+S6sUaODxp0L5hfg==",
       "license": "MIT",
       "bin": {
         "image-size": "bin/image-size.js"
diff --git a/package.json b/package.json
index 51ce3aa0ed..7cc08334d2 100644
--- a/package.json
+++ b/package.json
@@ -33,7 +33,7 @@
     "chokidar": "^4.0.3",
     "ejs": "^3.1.10",
     "express": "^4.21.2",
-    "image-size": "^2.0.0",
+    "image-size": "^2.0.1",
     "markdown-it": "^14.1.0"
   },
   "devDependencies": {

From 3cc720df9a94b1586e072cfeb3ee7fcb0e56defe Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 17 Mar 2025 23:40:05 -0400
Subject: [PATCH 17/61] Merge in MIDI Parser extension by CHCAT1320

---
 extensions/midi/midi.js | 93 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 92 insertions(+), 1 deletion(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 539df3e45d..72c52d9ec9 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -1,6 +1,8 @@
 // Name: MIDI
 // ID: extmidi
 // Description: An extension to use the WebMidi API for midi input/output.
+// By: lselden
+// By: CHCAT1320
 // License: MPL-2.0
 
 (function (Scratch) {
@@ -12,6 +14,77 @@
 
   const EXT_ID = "extmidi";
 
+  //#region midi files
+  const Midi = (function initMidi() {
+    const exports = {};
+    const module = { exports };
+
+    /* eslint-disable */
+    // prettier-ignore
+
+    //  tonejs/midi
+    // TODO FIXME - include full link to original code + licensing here - see newgroundsIO.js for one such example
+    !function(t,e){if("object"==typeof exports&&"object"==typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var r=e();for(var n in r)("object"==typeof exports?exports:t)[n]=r[n]}}("undefined"!=typeof self?self:this,(function(){return(()=>{var t={507:(t,e,r)=>{"use strict";function n(t){var e=[];return i(t,e),e}function i(t,e){for(var r=0;r<t.length;r++){var n=t[r];Array.isArray(n)?i(n,e):e.push(n)}}r.r(e),r.d(e,{flatten:()=>n})},289:(t,e,r)=>{e.parseMidi=r(666),e.writeMidi=r(865)},666:t=>{function e(t){for(var e,n=new r(t),i=[];!n.eof();){var a=o();i.push(a)}return i;function o(){var t={};t.deltaTime=n.readVarInt();var r=n.readUInt8();if(240==(240&r)){if(255!==r){if(240==r)return t.type="sysEx",a=n.readVarInt(),t.data=n.readBytes(a),t;if(247==r)return t.type="endSysEx",a=n.readVarInt(),t.data=n.readBytes(a),t;throw"Unrecognised MIDI event type byte: "+r}t.meta=!0;var i=n.readUInt8(),a=n.readVarInt();switch(i){case 0:if(t.type="sequenceNumber",2!==a)throw"Expected length for sequenceNumber event is 2, got "+a;return t.number=n.readUInt16(),t;case 1:return t.type="text",t.text=n.readString(a),t;case 2:return t.type="copyrightNotice",t.text=n.readString(a),t;case 3:return t.type="trackName",t.text=n.readString(a),t;case 4:return t.type="instrumentName",t.text=n.readString(a),t;case 5:return t.type="lyrics",t.text=n.readString(a),t;case 6:return t.type="marker",t.text=n.readString(a),t;case 7:return t.type="cuePoint",t.text=n.readString(a),t;case 32:if(t.type="channelPrefix",1!=a)throw"Expected length for channelPrefix event is 1, got "+a;return t.channel=n.readUInt8(),t;case 33:if(t.type="portPrefix",1!=a)throw"Expected length for portPrefix event is 1, got "+a;return t.port=n.readUInt8(),t;case 47:if(t.type="endOfTrack",0!=a)throw"Expected length for endOfTrack event is 0, got "+a;return t;case 81:if(t.type="setTempo",3!=a)throw"Expected length for setTempo event is 3, got "+a;return t.microsecondsPerBeat=n.readUInt24(),t;case 84:if(t.type="smpteOffset",5!=a)throw"Expected length for smpteOffset event is 5, got "+a;var o=n.readUInt8();return t.frameRate={0:24,32:25,64:29,96:30}[96&o],t.hour=31&o,t.min=n.readUInt8(),t.sec=n.readUInt8(),t.frame=n.readUInt8(),t.subFrame=n.readUInt8(),t;case 88:if(t.type="timeSignature",4!=a)throw"Expected length for timeSignature event is 4, got "+a;return t.numerator=n.readUInt8(),t.denominator=1<<n.readUInt8(),t.metronome=n.readUInt8(),t.thirtyseconds=n.readUInt8(),t;case 89:if(t.type="keySignature",2!=a)throw"Expected length for keySignature event is 2, got "+a;return t.key=n.readInt8(),t.scale=n.readUInt8(),t;case 127:return t.type="sequencerSpecific",t.data=n.readBytes(a),t;default:return t.type="unknownMeta",t.data=n.readBytes(a),t.metatypeByte=i,t}}else{var s;if(0==(128&r)){if(null===e)throw"Running status byte encountered before status byte";s=r,r=e,t.running=!0}else s=n.readUInt8(),e=r;var c=r>>4;switch(t.channel=15&r,c){case 8:return t.type="noteOff",t.noteNumber=s,t.velocity=n.readUInt8(),t;case 9:var u=n.readUInt8();return t.type=0===u?"noteOff":"noteOn",t.noteNumber=s,t.velocity=u,0===u&&(t.byte9=!0),t;case 10:return t.type="noteAftertouch",t.noteNumber=s,t.amount=n.readUInt8(),t;case 11:return t.type="controller",t.controllerType=s,t.value=n.readUInt8(),t;case 12:return t.type="programChange",t.programNumber=s,t;case 13:return t.type="channelAftertouch",t.amount=s,t;case 14:return t.type="pitchBend",t.value=s+(n.readUInt8()<<7)-8192,t;default:throw"Unrecognised MIDI event type: "+c}}}}function r(t){this.buffer=t,this.bufferLen=this.buffer.length,this.pos=0}r.prototype.eof=function(){return this.pos>=this.bufferLen},r.prototype.readUInt8=function(){var t=this.buffer[this.pos];return this.pos+=1,t},r.prototype.readInt8=function(){var t=this.readUInt8();return 128&t?t-256:t},r.prototype.readUInt16=function(){return(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readInt16=function(){var t=this.readUInt16();return 32768&t?t-65536:t},r.prototype.readUInt24=function(){return(this.readUInt8()<<16)+(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readInt24=function(){var t=this.readUInt24();return 8388608&t?t-16777216:t},r.prototype.readUInt32=function(){return(this.readUInt8()<<24)+(this.readUInt8()<<16)+(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readBytes=function(t){var e=this.buffer.slice(this.pos,this.pos+t);return this.pos+=t,e},r.prototype.readString=function(t){var e=this.readBytes(t);return String.fromCharCode.apply(null,e)},r.prototype.readVarInt=function(){for(var t=0;!this.eof();){var e=this.readUInt8();if(!(128&e))return t+e;t+=127&e,t<<=7}return t},r.prototype.readChunk=function(){var t=this.readString(4),e=this.readUInt32();return{id:t,length:e,data:this.readBytes(e)}},t.exports=function(t){var n=new r(t),i=n.readChunk();if("MThd"!=i.id)throw"Bad MIDI file.  Expected 'MHdr', got: '"+i.id+"'";for(var a=function(t){var e=new r(t),n={format:e.readUInt16(),numTracks:e.readUInt16()},i=e.readUInt16();return 32768&i?(n.framesPerSecond=256-(i>>8),n.ticksPerFrame=255&i):n.ticksPerBeat=i,n}(i.data),o=[],s=0;!n.eof()&&s<a.numTracks;s++){var c=n.readChunk();if("MTrk"!=c.id)throw"Bad MIDI file.  Expected 'MTrk', got: '"+c.id+"'";var u=e(c.data);o.push(u)}return{header:a,tracks:o}}},865:t=>{function e(t,e,i){var a,o=new n,s=e.length,c=null;for(a=0;a<s;a++)!1!==i.running&&(i.running||e[a].running)||(c=null),c=r(o,e[a],c,i.useByte9ForNoteOff);t.writeChunk("MTrk",o.buffer)}function r(t,e,r,n){var i=e.type,a=e.deltaTime,o=e.text||"",s=e.data||[],c=null;switch(t.writeVarInt(a),i){case"sequenceNumber":t.writeUInt8(255),t.writeUInt8(0),t.writeVarInt(2),t.writeUInt16(e.number);break;case"text":t.writeUInt8(255),t.writeUInt8(1),t.writeVarInt(o.length),t.writeString(o);break;case"copyrightNotice":t.writeUInt8(255),t.writeUInt8(2),t.writeVarInt(o.length),t.writeString(o);break;case"trackName":t.writeUInt8(255),t.writeUInt8(3),t.writeVarInt(o.length),t.writeString(o);break;case"instrumentName":t.writeUInt8(255),t.writeUInt8(4),t.writeVarInt(o.length),t.writeString(o);break;case"lyrics":t.writeUInt8(255),t.writeUInt8(5),t.writeVarInt(o.length),t.writeString(o);break;case"marker":t.writeUInt8(255),t.writeUInt8(6),t.writeVarInt(o.length),t.writeString(o);break;case"cuePoint":t.writeUInt8(255),t.writeUInt8(7),t.writeVarInt(o.length),t.writeString(o);break;case"channelPrefix":t.writeUInt8(255),t.writeUInt8(32),t.writeVarInt(1),t.writeUInt8(e.channel);break;case"portPrefix":t.writeUInt8(255),t.writeUInt8(33),t.writeVarInt(1),t.writeUInt8(e.port);break;case"endOfTrack":t.writeUInt8(255),t.writeUInt8(47),t.writeVarInt(0);break;case"setTempo":t.writeUInt8(255),t.writeUInt8(81),t.writeVarInt(3),t.writeUInt24(e.microsecondsPerBeat);break;case"smpteOffset":t.writeUInt8(255),t.writeUInt8(84),t.writeVarInt(5);var u=31&e.hour|{24:0,25:32,29:64,30:96}[e.frameRate];t.writeUInt8(u),t.writeUInt8(e.min),t.writeUInt8(e.sec),t.writeUInt8(e.frame),t.writeUInt8(e.subFrame);break;case"timeSignature":t.writeUInt8(255),t.writeUInt8(88),t.writeVarInt(4),t.writeUInt8(e.numerator);var h=255&Math.floor(Math.log(e.denominator)/Math.LN2);t.writeUInt8(h),t.writeUInt8(e.metronome),t.writeUInt8(e.thirtyseconds||8);break;case"keySignature":t.writeUInt8(255),t.writeUInt8(89),t.writeVarInt(2),t.writeInt8(e.key),t.writeUInt8(e.scale);break;case"sequencerSpecific":t.writeUInt8(255),t.writeUInt8(127),t.writeVarInt(s.length),t.writeBytes(s);break;case"unknownMeta":null!=e.metatypeByte&&(t.writeUInt8(255),t.writeUInt8(e.metatypeByte),t.writeVarInt(s.length),t.writeBytes(s));break;case"sysEx":t.writeUInt8(240),t.writeVarInt(s.length),t.writeBytes(s);break;case"endSysEx":t.writeUInt8(247),t.writeVarInt(s.length),t.writeBytes(s);break;case"noteOff":(c=(!1!==n&&e.byte9||n&&0==e.velocity?144:128)|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.velocity);break;case"noteOn":(c=144|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.velocity);break;case"noteAftertouch":(c=160|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.amount);break;case"controller":(c=176|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.controllerType),t.writeUInt8(e.value);break;case"programChange":(c=192|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.programNumber);break;case"channelAftertouch":(c=208|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.amount);break;case"pitchBend":(c=224|e.channel)!==r&&t.writeUInt8(c);var f=8192+e.value,p=127&f,l=f>>7&127;t.writeUInt8(p),t.writeUInt8(l);break;default:throw"Unrecognized event type: "+i}return c}function n(){this.buffer=[]}n.prototype.writeUInt8=function(t){this.buffer.push(255&t)},n.prototype.writeInt8=n.prototype.writeUInt8,n.prototype.writeUInt16=function(t){var e=t>>8&255,r=255&t;this.writeUInt8(e),this.writeUInt8(r)},n.prototype.writeInt16=n.prototype.writeUInt16,n.prototype.writeUInt24=function(t){var e=t>>16&255,r=t>>8&255,n=255&t;this.writeUInt8(e),this.writeUInt8(r),this.writeUInt8(n)},n.prototype.writeInt24=n.prototype.writeUInt24,n.prototype.writeUInt32=function(t){var e=t>>24&255,r=t>>16&255,n=t>>8&255,i=255&t;this.writeUInt8(e),this.writeUInt8(r),this.writeUInt8(n),this.writeUInt8(i)},n.prototype.writeInt32=n.prototype.writeUInt32,n.prototype.writeBytes=function(t){this.buffer=this.buffer.concat(Array.prototype.slice.call(t,0))},n.prototype.writeString=function(t){var e,r=t.length,n=[];for(e=0;e<r;e++)n.push(t.codePointAt(e));this.writeBytes(n)},n.prototype.writeVarInt=function(t){if(t<0)throw"Cannot write negative variable-length integer";if(t<=127)this.writeUInt8(t);else{var e=t,r=[];for(r.push(127&e),e>>=7;e;){var n=127&e|128;r.push(n),e>>=7}this.writeBytes(r.reverse())}},n.prototype.writeChunk=function(t,e){this.writeString(t),this.writeUInt32(e.length),this.writeBytes(e)},t.exports=function(t,r){if("object"!=typeof t)throw"Invalid MIDI data";r=r||{};var i,a=t.header||{},o=t.tracks||[],s=o.length,c=new n;for(function(t,e,r){var i=null==e.format?1:e.format,a=128;e.timeDivision?a=e.timeDivision:e.ticksPerFrame&&e.framesPerSecond?a=-(255&e.framesPerSecond)<<8|255&e.ticksPerFrame:e.ticksPerBeat&&(a=32767&e.ticksPerBeat);var o=new n;o.writeUInt16(i),o.writeUInt16(r),o.writeUInt16(a),t.writeChunk("MThd",o.buffer)}(c,a,s),i=0;i<s;i++)e(c,o[i],r);return c.buffer}},805:(t,e)=>{"use strict";function r(t,e,r){void 0===r&&(r="ticks");var n=0,i=t.length,a=i;if(i>0&&t[i-1][r]<=e)return i-1;for(;n<a;){var o=Math.floor(n+(a-n)/2),s=t[o],c=t[o+1];if(s[r]===e){for(var u=o;u<t.length;u++)t[u][r]===e&&(o=u);return o}if(s[r]<e&&c[r]>e)return o;s[r]>e?a=o:s[r]<e&&(n=o+1)}return-1}Object.defineProperty(e,"__esModule",{value:!0}),e.insert=e.search=void 0,e.search=r,e.insert=function(t,e,n){if(void 0===n&&(n="ticks"),t.length){var i=r(t,e[n],n);t.splice(i+1,0,e)}else t.push(e)}},543:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.ControlChange=e.controlChangeIds=e.controlChangeNames=void 0,e.controlChangeNames={1:"modulationWheel",2:"breath",4:"footController",5:"portamentoTime",7:"volume",8:"balance",10:"pan",64:"sustain",65:"portamentoTime",66:"sostenuto",67:"softPedal",68:"legatoFootswitch",84:"portamentoControl"},e.controlChangeIds=Object.keys(e.controlChangeNames).reduce((function(t,r){return t[e.controlChangeNames[r]]=r,t}),{});var r=new WeakMap,n=new WeakMap,i=function(){function t(t,e){r.set(this,e),n.set(this,t.controllerType),this.ticks=t.absoluteTime,this.value=t.value}return Object.defineProperty(t.prototype,"number",{get:function(){return n.get(this)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"name",{get:function(){return e.controlChangeNames[this.number]?e.controlChangeNames[this.number]:null},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"time",{get:function(){return r.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=r.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{number:this.number,ticks:this.ticks,time:this.time,value:this.value}},t}();e.ControlChange=i},906:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.createControlChanges=void 0;var n=r(543);e.createControlChanges=function(){return new Proxy({},{get:function(t,e){return t[e]?t[e]:n.controlChangeIds.hasOwnProperty(e)?t[n.controlChangeIds[e]]:void 0},set:function(t,e,r){return n.controlChangeIds.hasOwnProperty(e)?t[n.controlChangeIds[e]]=r:t[e]=r,!0}})}},54:function(t,e,r){"use strict";var n=this&&this.__spreadArray||function(t,e,r){if(r||2===arguments.length)for(var n,i=0,a=e.length;i<a;i++)!n&&i in e||(n||(n=Array.prototype.slice.call(e,0,i)),n[i]=e[i]);return t.concat(n||Array.prototype.slice.call(e))};Object.defineProperty(e,"__esModule",{value:!0}),e.encode=void 0;var i=r(289),a=r(535),o=r(507);function s(t,e){return{absoluteTime:t.ticks,channel:e,controllerType:t.number,deltaTime:0,type:"controller",value:Math.floor(127*t.value)}}function c(t){return{absoluteTime:0,channel:t.channel,deltaTime:0,programNumber:t.instrument.number,type:"programChange"}}e.encode=function(t){var e={header:{format:1,numTracks:t.tracks.length+1,ticksPerBeat:t.header.ppq},tracks:n([n(n(n(n([{absoluteTime:0,deltaTime:0,meta:!0,text:t.header.name,type:"trackName"}],t.header.keySignatures.map((function(t){return function(t){var e=a.keySignatureKeys.indexOf(t.key);return{absoluteTime:t.ticks,deltaTime:0,key:e+7,meta:!0,scale:"major"===t.scale?0:1,type:"keySignature"}}(t)})),!0),t.header.meta.map((function(t){return{absoluteTime:(e=t).ticks,deltaTime:0,meta:!0,text:e.text,type:e.type};var e})),!0),t.header.tempos.map((function(t){return function(t){return{absoluteTime:t.ticks,deltaTime:0,meta:!0,microsecondsPerBeat:Math.floor(6e7/t.bpm),type:"setTempo"}}(t)})),!0),t.header.timeSignatures.map((function(t){return function(t){return{absoluteTime:t.ticks,deltaTime:0,denominator:t.timeSignature[1],meta:!0,metronome:24,numerator:t.timeSignature[0],thirtyseconds:8,type:"timeSignature"}}(t)})),!0)],t.tracks.map((function(t){return n(n(n([(e=t.name,{absoluteTime:0,deltaTime:0,meta:!0,text:e,type:"trackName"}),c(t)],function(t){return(0,o.flatten)(t.notes.map((function(e){return function(t,e){return[{absoluteTime:t.ticks,channel:e,deltaTime:0,noteNumber:t.midi,type:"noteOn",velocity:Math.floor(127*t.velocity)},{absoluteTime:t.ticks+t.durationTicks,channel:e,deltaTime:0,noteNumber:t.midi,type:"noteOff",velocity:Math.floor(127*t.noteOffVelocity)}]}(e,t.channel)})))}(t),!0),function(t){for(var e=[],r=0;r<127;r++)t.controlChanges.hasOwnProperty(r)&&t.controlChanges[r].forEach((function(r){e.push(s(r,t.channel))}));return e}(t),!0),function(t){var e=[];return t.pitchBends.forEach((function(r){e.push(function(t,e){return{absoluteTime:t.ticks,channel:e,deltaTime:0,type:"pitchBend",value:t.value}}(r,t.channel))})),e}(t),!0);var e})),!0)};return e.tracks=e.tracks.map((function(t){t=t.sort((function(t,e){return t.absoluteTime-e.absoluteTime}));var e=0;return t.forEach((function(t){t.deltaTime=t.absoluteTime-e,e=t.absoluteTime,delete t.absoluteTime})),t.push({deltaTime:0,meta:!0,type:"endOfTrack"}),t})),new Uint8Array((0,i.writeMidi)(e))}},535:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Header=e.keySignatureKeys=void 0;var n=r(805),i=new WeakMap;e.keySignatureKeys=["Cb","Gb","Db","Ab","Eb","Bb","F","C","G","D","A","E","B","F#","C#"];var a=function(){function t(t){var r=this;if(this.tempos=[],this.timeSignatures=[],this.keySignatures=[],this.meta=[],this.name="",i.set(this,480),t){i.set(this,t.header.ticksPerBeat),t.tracks.forEach((function(t){t.forEach((function(t){t.meta&&("timeSignature"===t.type?r.timeSignatures.push({ticks:t.absoluteTime,timeSignature:[t.numerator,t.denominator]}):"setTempo"===t.type?r.tempos.push({bpm:6e7/t.microsecondsPerBeat,ticks:t.absoluteTime}):"keySignature"===t.type&&r.keySignatures.push({key:e.keySignatureKeys[t.key+7],scale:0===t.scale?"major":"minor",ticks:t.absoluteTime}))}))}));var n=0;t.tracks[0].forEach((function(t){n+=t.deltaTime,t.meta&&("trackName"===t.type?r.name=t.text:"text"!==t.type&&"cuePoint"!==t.type&&"marker"!==t.type&&"lyrics"!==t.type||r.meta.push({text:t.text,ticks:n,type:t.type}))})),this.update()}}return t.prototype.update=function(){var t=this,e=0,r=0;this.tempos.sort((function(t,e){return t.ticks-e.ticks})),this.tempos.forEach((function(n,i){var a=i>0?t.tempos[i-1].bpm:t.tempos[0].bpm,o=n.ticks/t.ppq-r,s=60/a*o;n.time=s+e,e=n.time,r+=o})),this.timeSignatures.sort((function(t,e){return t.ticks-e.ticks})),this.timeSignatures.forEach((function(e,r){var n=r>0?t.timeSignatures[r-1]:t.timeSignatures[0],i=(e.ticks-n.ticks)/t.ppq/n.timeSignature[0]/(n.timeSignature[1]/4);n.measures=n.measures||0,e.measures=i+n.measures}))},t.prototype.ticksToSeconds=function(t){var e=(0,n.search)(this.tempos,t);if(-1!==e){var r=this.tempos[e],i=r.time,a=(t-r.ticks)/this.ppq;return i+60/r.bpm*a}return t/this.ppq*.5},t.prototype.ticksToMeasures=function(t){var e=(0,n.search)(this.timeSignatures,t);if(-1!==e){var r=this.timeSignatures[e],i=(t-r.ticks)/this.ppq;return r.measures+i/(r.timeSignature[0]/r.timeSignature[1])/4}return t/this.ppq/4},Object.defineProperty(t.prototype,"ppq",{get:function(){return i.get(this)},enumerable:!1,configurable:!0}),t.prototype.secondsToTicks=function(t){var e=(0,n.search)(this.tempos,t,"time");if(-1!==e){var r=this.tempos[e],i=(t-r.time)/(60/r.bpm);return Math.round(r.ticks+i*this.ppq)}var a=t/.5;return Math.round(a*this.ppq)},t.prototype.toJSON=function(){return{keySignatures:this.keySignatures,meta:this.meta,name:this.name,ppq:this.ppq,tempos:this.tempos.map((function(t){return{bpm:t.bpm,ticks:t.ticks}})),timeSignatures:this.timeSignatures}},t.prototype.fromJSON=function(t){this.name=t.name,this.tempos=t.tempos.map((function(t){return Object.assign({},t)})),this.timeSignatures=t.timeSignatures.map((function(t){return Object.assign({},t)})),this.keySignatures=t.keySignatures.map((function(t){return Object.assign({},t)})),this.meta=t.meta.map((function(t){return Object.assign({},t)})),i.set(this,t.ppq),this.update()},t.prototype.setTempo=function(t){this.tempos=[{bpm:t,ticks:0}],this.update()},t}();e.Header=a},362:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Instrument=void 0;var n=r(438),i=new WeakMap,a=function(){function t(t,e){if(this.number=0,i.set(this,e),this.number=0,t){var r=t.find((function(t){return"programChange"===t.type}));r&&(this.number=r.programNumber)}}return Object.defineProperty(t.prototype,"name",{get:function(){return this.percussion?n.DrumKitByPatchID[this.number]:n.instrumentByPatchID[this.number]},set:function(t){var e=n.instrumentByPatchID.indexOf(t);-1!==e&&(this.number=e)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"family",{get:function(){return this.percussion?"drums":n.InstrumentFamilyByID[Math.floor(this.number/8)]},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"percussion",{get:function(){return 9===i.get(this).channel},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{family:this.family,number:this.number,name:this.name}},t.prototype.fromJSON=function(t){this.number=t.number},t}();e.Instrument=a},438:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.DrumKitByPatchID=e.InstrumentFamilyByID=e.instrumentByPatchID=void 0,e.instrumentByPatchID=["acoustic grand piano","bright acoustic piano","electric grand piano","honky-tonk piano","electric piano 1","electric piano 2","harpsichord","clavi","celesta","glockenspiel","music box","vibraphone","marimba","xylophone","tubular bells","dulcimer","drawbar organ","percussive organ","rock organ","church organ","reed organ","accordion","harmonica","tango accordion","acoustic guitar (nylon)","acoustic guitar (steel)","electric guitar (jazz)","electric guitar (clean)","electric guitar (muted)","overdriven guitar","distortion guitar","guitar harmonics","acoustic bass","electric bass (finger)","electric bass (pick)","fretless bass","slap bass 1","slap bass 2","synth bass 1","synth bass 2","violin","viola","cello","contrabass","tremolo strings","pizzicato strings","orchestral harp","timpani","string ensemble 1","string ensemble 2","synthstrings 1","synthstrings 2","choir aahs","voice oohs","synth voice","orchestra hit","trumpet","trombone","tuba","muted trumpet","french horn","brass section","synthbrass 1","synthbrass 2","soprano sax","alto sax","tenor sax","baritone sax","oboe","english horn","bassoon","clarinet","piccolo","flute","recorder","pan flute","blown bottle","shakuhachi","whistle","ocarina","lead 1 (square)","lead 2 (sawtooth)","lead 3 (calliope)","lead 4 (chiff)","lead 5 (charang)","lead 6 (voice)","lead 7 (fifths)","lead 8 (bass + lead)","pad 1 (new age)","pad 2 (warm)","pad 3 (polysynth)","pad 4 (choir)","pad 5 (bowed)","pad 6 (metallic)","pad 7 (halo)","pad 8 (sweep)","fx 1 (rain)","fx 2 (soundtrack)","fx 3 (crystal)","fx 4 (atmosphere)","fx 5 (brightness)","fx 6 (goblins)","fx 7 (echoes)","fx 8 (sci-fi)","sitar","banjo","shamisen","koto","kalimba","bag pipe","fiddle","shanai","tinkle bell","agogo","steel drums","woodblock","taiko drum","melodic tom","synth drum","reverse cymbal","guitar fret noise","breath noise","seashore","bird tweet","telephone ring","helicopter","applause","gunshot"],e.InstrumentFamilyByID=["piano","chromatic percussion","organ","guitar","bass","strings","ensemble","brass","reed","pipe","synth lead","synth pad","synth effects","world","percussive","sound effects"],e.DrumKitByPatchID={0:"standard kit",8:"room kit",16:"power kit",24:"electronic kit",25:"tr-808 kit",32:"jazz kit",40:"brush kit",48:"orchestra kit",56:"sound fx kit"}},233:function(t,e,r){"use strict";var n=this&&this.__awaiter||function(t,e,r,n){return new(r||(r=Promise))((function(i,a){function o(t){try{c(n.next(t))}catch(t){a(t)}}function s(t){try{c(n.throw(t))}catch(t){a(t)}}function c(t){var e;t.done?i(t.value):(e=t.value,e instanceof r?e:new r((function(t){t(e)}))).then(o,s)}c((n=n.apply(t,e||[])).next())}))},i=this&&this.__generator||function(t,e){var r,n,i,a,o={label:0,sent:function(){if(1&i[0])throw i[1];return i[1]},trys:[],ops:[]};return a={next:s(0),throw:s(1),return:s(2)},"function"==typeof Symbol&&(a[Symbol.iterator]=function(){return this}),a;function s(a){return function(s){return function(a){if(r)throw new TypeError("Generator is already executing.");for(;o;)try{if(r=1,n&&(i=2&a[0]?n.return:a[0]?n.throw||((i=n.return)&&i.call(n),0):n.next)&&!(i=i.call(n,a[1])).done)return i;switch(n=0,i&&(a=[2&a[0],i.value]),a[0]){case 0:case 1:i=a;break;case 4:return o.label++,{value:a[1],done:!1};case 5:o.label++,n=a[1],a=[0];continue;case 7:a=o.ops.pop(),o.trys.pop();continue;default:if(!((i=(i=o.trys).length>0&&i[i.length-1])||6!==a[0]&&2!==a[0])){o=0;continue}if(3===a[0]&&(!i||a[1]>i[0]&&a[1]<i[3])){o.label=a[1];break}if(6===a[0]&&o.label<i[1]){o.label=i[1],i=a;break}if(i&&o.label<i[2]){o.label=i[2],o.ops.push(a);break}i[2]&&o.ops.pop(),o.trys.pop();continue}a=e.call(t,o)}catch(t){a=[6,t],n=0}finally{r=i=0}if(5&a[0])throw a[1];return{value:a[0]?a[1]:void 0,done:!0}}([a,s])}}};Object.defineProperty(e,"__esModule",{value:!0}),e.Header=e.Track=e.Midi=void 0;var a=r(289),o=r(535),s=r(334),c=r(54),u=function(){function t(t){var e=this,r=null;if(t){var n=t instanceof ArrayBuffer?new Uint8Array(t):t;(r=(0,a.parseMidi)(n)).tracks.forEach((function(t){var e=0;t.forEach((function(t){e+=t.deltaTime,t.absoluteTime=e}))})),r.tracks=function(t){for(var e=[],r=0;r<t.length;r++)for(var n=e.length,i=new Map,a=Array(16).fill(0),o=0,s=t[r];o<s.length;o++){var c=s[o],u=n,h=c.channel;if(void 0!==h){"programChange"===c.type&&(a[h]=c.programNumber);var f=a[h],p="".concat(f," ").concat(h);i.has(p)?u=i.get(p):(u=n+i.size,i.set(p,u))}e[u]||e.push([]),e[u].push(c)}return e}(r.tracks)}this.header=new o.Header(r),this.tracks=[],t&&(this.tracks=r.tracks.map((function(t){return new s.Track(t,e.header)})),1===r.header.format&&0===this.tracks[0].duration&&this.tracks.shift())}return t.fromUrl=function(e){return n(this,void 0,void 0,(function(){var r;return i(this,(function(n){switch(n.label){case 0:return[4,fetch(e)];case 1:return(r=n.sent()).ok?[4,r.arrayBuffer()]:[3,3];case 2:return[2,new t(n.sent())];case 3:throw new Error("Could not load '".concat(e,"'"))}}))}))},Object.defineProperty(t.prototype,"name",{get:function(){return this.header.name},set:function(t){this.header.name=t},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"duration",{get:function(){var t=this.tracks.map((function(t){return t.duration}));return Math.max.apply(Math,t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"durationTicks",{get:function(){var t=this.tracks.map((function(t){return t.durationTicks}));return Math.max.apply(Math,t)},enumerable:!1,configurable:!0}),t.prototype.addTrack=function(){var t=new s.Track(void 0,this.header);return this.tracks.push(t),t},t.prototype.toArray=function(){return(0,c.encode)(this)},t.prototype.toJSON=function(){return{header:this.header.toJSON(),tracks:this.tracks.map((function(t){return t.toJSON()}))}},t.prototype.fromJSON=function(t){var e=this;this.header=new o.Header,this.header.fromJSON(t.header),this.tracks=t.tracks.map((function(t){var r=new s.Track(void 0,e.header);return r.fromJSON(t),r}))},t.prototype.clone=function(){var e=new t;return e.fromJSON(this.toJSON()),e},t}();e.Midi=u;var h=r(334);Object.defineProperty(e,"Track",{enumerable:!0,get:function(){return h.Track}});var f=r(535);Object.defineProperty(e,"Header",{enumerable:!0,get:function(){return f.Header}})},518:(t,e)=>{"use strict";function r(t){return["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"][t%12]}Object.defineProperty(e,"__esModule",{value:!0}),e.Note=void 0;var n,i,a=(n=/^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,i={cbb:-2,cb:-1,c:0,"c#":1,cx:2,dbb:0,db:1,d:2,"d#":3,dx:4,ebb:2,eb:3,e:4,"e#":5,ex:6,fbb:3,fb:4,f:5,"f#":6,fx:7,gbb:5,gb:6,g:7,"g#":8,gx:9,abb:7,ab:8,a:9,"a#":10,ax:11,bbb:9,bb:10,b:11,"b#":12,bx:13},function(t){var e=n.exec(t),r=e[1],a=e[2];return i[r.toLowerCase()]+12*(parseInt(a,10)+1)}),o=new WeakMap,s=function(){function t(t,e,r){o.set(this,r),this.midi=t.midi,this.velocity=t.velocity,this.noteOffVelocity=e.velocity,this.ticks=t.ticks,this.durationTicks=e.ticks-t.ticks}return Object.defineProperty(t.prototype,"name",{get:function(){return t=this.midi,e=Math.floor(t/12)-1,r(t)+e.toString();var t,e},set:function(t){this.midi=a(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"octave",{get:function(){return Math.floor(this.midi/12)-1},set:function(t){var e=t-this.octave;this.midi+=12*e},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"pitch",{get:function(){return r(this.midi)},set:function(t){this.midi=12*(this.octave+1)+["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"].indexOf(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"duration",{get:function(){var t=o.get(this);return t.ticksToSeconds(this.ticks+this.durationTicks)-t.ticksToSeconds(this.ticks)},set:function(t){var e=o.get(this).secondsToTicks(this.time+t);this.durationTicks=e-this.ticks},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"time",{get:function(){return o.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=o.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"bars",{get:function(){return o.get(this).ticksToMeasures(this.ticks)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{duration:this.duration,durationTicks:this.durationTicks,midi:this.midi,name:this.name,ticks:this.ticks,time:this.time,velocity:this.velocity}},t}();e.Note=s},882:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.PitchBend=void 0;var r=new WeakMap,n=function(){function t(t,e){r.set(this,e),this.ticks=t.absoluteTime,this.value=t.value}return Object.defineProperty(t.prototype,"time",{get:function(){return r.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=r.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{ticks:this.ticks,time:this.time,value:this.value}},t}();e.PitchBend=n},334:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Track=void 0;var n=r(805),i=r(543),a=r(906),o=r(882),s=r(362),c=r(518),u=new WeakMap,h=function(){function t(t,e){var r=this;if(this.name="",this.notes=[],this.controlChanges=(0,a.createControlChanges)(),this.pitchBends=[],u.set(this,e),t){var n=t.find((function(t){return"trackName"===t.type}));this.name=n?n.text:""}if(this.instrument=new s.Instrument(t,this),this.channel=0,t){for(var i=t.filter((function(t){return"noteOn"===t.type})),o=t.filter((function(t){return"noteOff"===t.type})),c=function(){var t=i.shift();h.channel=t.channel;var e=o.findIndex((function(e){return e.noteNumber===t.noteNumber&&e.absoluteTime>=t.absoluteTime}));if(-1!==e){var r=o.splice(e,1)[0];h.addNote({durationTicks:r.absoluteTime-t.absoluteTime,midi:t.noteNumber,noteOffVelocity:r.velocity/127,ticks:t.absoluteTime,velocity:t.velocity/127})}},h=this;i.length;)c();t.filter((function(t){return"controller"===t.type})).forEach((function(t){r.addCC({number:t.controllerType,ticks:t.absoluteTime,value:t.value/127})})),t.filter((function(t){return"pitchBend"===t.type})).forEach((function(t){r.addPitchBend({ticks:t.absoluteTime,value:t.value/Math.pow(2,13)})}));var f=t.find((function(t){return"endOfTrack"===t.type}));this.endOfTrackTicks=void 0!==f?f.absoluteTime:void 0}}return t.prototype.addNote=function(t){var e=u.get(this),r=new c.Note({midi:0,ticks:0,velocity:1},{ticks:0,velocity:0},e);return Object.assign(r,t),(0,n.insert)(this.notes,r,"ticks"),this},t.prototype.addCC=function(t){var e=u.get(this),r=new i.ControlChange({controllerType:t.number},e);return delete t.number,Object.assign(r,t),Array.isArray(this.controlChanges[r.number])||(this.controlChanges[r.number]=[]),(0,n.insert)(this.controlChanges[r.number],r,"ticks"),this},t.prototype.addPitchBend=function(t){var e=u.get(this),r=new o.PitchBend({},e);return Object.assign(r,t),(0,n.insert)(this.pitchBends,r,"ticks"),this},Object.defineProperty(t.prototype,"duration",{get:function(){if(!this.notes.length)return 0;for(var t=this.notes[this.notes.length-1].time+this.notes[this.notes.length-1].duration,e=0;e<this.notes.length-1;e++){var r=this.notes[e].time+this.notes[e].duration;t<r&&(t=r)}return t},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"durationTicks",{get:function(){if(!this.notes.length)return 0;for(var t=this.notes[this.notes.length-1].ticks+this.notes[this.notes.length-1].durationTicks,e=0;e<this.notes.length-1;e++){var r=this.notes[e].ticks+this.notes[e].durationTicks;t<r&&(t=r)}return t},enumerable:!1,configurable:!0}),t.prototype.fromJSON=function(t){var e=this;for(var r in this.name=t.name,this.channel=t.channel,this.instrument=new s.Instrument(void 0,this),this.instrument.fromJSON(t.instrument),void 0!==t.endOfTrackTicks&&(this.endOfTrackTicks=t.endOfTrackTicks),t.controlChanges)t.controlChanges[r]&&t.controlChanges[r].forEach((function(t){e.addCC({number:t.number,ticks:t.ticks,value:t.value})}));t.notes.forEach((function(t){e.addNote({durationTicks:t.durationTicks,midi:t.midi,ticks:t.ticks,velocity:t.velocity})}))},t.prototype.toJSON=function(){for(var t={},e=0;e<127;e++)this.controlChanges.hasOwnProperty(e)&&(t[e]=this.controlChanges[e].map((function(t){return t.toJSON()})));var r={channel:this.channel,controlChanges:t,pitchBends:this.pitchBends.map((function(t){return t.toJSON()})),instrument:this.instrument.toJSON(),name:this.name,notes:this.notes.map((function(t){return t.toJSON()}))};return void 0!==this.endOfTrackTicks&&(r.endOfTrackTicks=this.endOfTrackTicks),r},t}();e.Track=h}},e={};function r(n){var i=e[n];if(void 0!==i)return i.exports;var a=e[n]={exports:{}};return t[n].call(a.exports,a,a.exports,r),a.exports}return r.d=(t,e)=>{for(var n in e)r.o(e,n)&&!r.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:e[n]})},r.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},r(233)})()}));
+    //# sourceMappingURL=Midi.js.map
+    /* eslint-enable */
+
+    return module.exports.Midi;
+  })();
+
+  function parseMidiDataUrl(args) {
+    // this.errorMessage = "";
+    if (!Midi) {
+      return "MIDI library failed to load";
+    }
+
+    const dataUrl = args.DATA_URL.trim();
+    if (!dataUrl) {
+      return "MIDI Data URL is empty";
+    }
+
+    try {
+      // Parse Data URL
+      const base64Data = dataUrl.split(",")[1];
+      if (!base64Data) {
+        throw new Error("Invalid Data URL format");
+      }
+
+      // Decode Base64 data to ArrayBuffer
+      const binaryString = atob(base64Data);
+      const len = binaryString.length;
+      const buffer = new ArrayBuffer(len);
+      const view = new Uint8Array(buffer);
+      for (let i = 0; i < len; i++) {
+        view[i] = binaryString.charCodeAt(i);
+      }
+
+      // Parse MIDI file
+      const midi = new Midi(buffer);
+
+      // Store note information
+      const notesData = [];
+      midi.tracks.forEach((track, trackIndex) => {
+        track.notes.forEach((note) => {
+          notesData.push({
+            track: trackIndex,
+            midiNumber: note.midi,
+            noteName: note.name,
+            startTime: note.time,
+            duration: note.duration,
+            velocity: note.velocity,
+          });
+        });
+      });
+
+      notesData.sort((a, b) => a.startTime - b.startTime);
+      return JSON.stringify(notesData, null, 2);
+    } catch (error) {
+      return "Error parsing MIDI file: " + error.message;
+    }
+  }
+
+  //#endregion
+
   //#region utils
 
   /**
@@ -1393,6 +1466,9 @@
           "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
         blockIconURI:
           "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
+          color1: "#4C97FF",
+          color2: "#337BCC",
+          color3: "#2C6CA3",  
         blocks: [
           // FUTURE - could force requesting permissions and checking midi device status. Usually refreshing is safer option
           // {
@@ -1689,7 +1765,18 @@
             text: Scratch.translate("stop all notes on output devices"),
           },
           SEPARATOR,
-
+          {
+            opcode: "parseMidiDataUrl",
+            blockType: Scratch.BlockType.REPORTER,
+            text: "Parse MIDI Data URL [DATA_URL]",
+            arguments: {
+              DATA_URL: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "",
+              },
+            },
+          },
+          SEPARATOR,
           {
             opcode: "noteForName",
             blockType: Scratch.BlockType.REPORTER,
@@ -2356,6 +2443,10 @@
       } catch (error) {}
       return event ? midiToString(event) : "";
     }
+    /** MIDI FILE FUNCTIONS **/
+    parseMidiDataUrl(args) {
+      return parseMidiDataUrl(args);
+    }
   }
 
   //#endregion

From 3fdf79aaac366ac9434afceb6f9534c21e378706 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 17 Mar 2025 23:53:08 -0400
Subject: [PATCH 18/61] minor refactor - rearrange code

---
 extensions/midi/midi.js | 179 +++++++++++++++++++---------------------
 1 file changed, 84 insertions(+), 95 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 72c52d9ec9..57c6b330d7 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -1377,88 +1377,40 @@
    */
   const SEPARATOR = "---";
 
+  /** Menu list. Reused in two menus, so defined here rather than below */
+  const EVENT_TYPES_ITEMS = [
+    {
+      value: "noteOn",
+      text: Scratch.translate("Note On"),
+    },
+    {
+      value: "noteOff",
+      text: Scratch.translate("Note Off"),
+    },
+    {
+      value: "cc",
+      text: Scratch.translate("CC"),
+    },
+    {
+      value: "polyTouch",
+      text: Scratch.translate("AfterTouch"),
+    },
+    {
+      value: "pitchBend",
+      text: Scratch.translate("Pitch Bend"),
+    },
+    {
+      value: "programChange",
+      text: Scratch.translate("Program Change"),
+    },
+    {
+      value: "channelPressure",
+      text: Scratch.translate("Channel Pressure"),
+    },
+  ];
+
   class MidiExtension {
-    constructor() {
-      this.midi = new MidiBackend();
-      this.recorder = new MidiRecorder();
-      /**
-       * Lazy initialize midi - only upon first executing, and used in other calls to make sure it gets triggered
-       */
-      this._ensureInitialize = (evt) => {
-        if (this.midi.status === "pending" /* Initial */) {
-          this.initialize().catch(() => {});
-        }
-      };
-      this._addListeners();
-      // globalThis.midiExt = this;
-      const vm = Scratch.vm;
-      vm.runtime.once("BEFORE_EXECUTE", this._ensureInitialize);
-    }
-    /**
-     * This helper actually glues together the extension with the MidiBackend / recorder. In particular it triggers HATS when incoming midi events occur
-     */
-    _addListeners() {
-      const vm = globalThis.Scratch.vm;
-      this.midi.on("device:status", (domEvent) => {
-        const changeEvent = domEvent.detail;
-        vm.runtime.startHats(HATS.DEVICE, {
-          DEVICE_TYPE: changeEvent.type,
-          STATE: changeEvent.state,
-        });
-      });
-      this.midi.on("midi", (domEvent) => {
-        const midiEvent = domEvent.detail;
-        this.recorder.add(midiEvent);
-        const threads = vm.runtime.startHats(HATS.MIDI);
-        // set the thread local variable to the passed in midi event for use with the "input event" reporter
-        for (let thread of threads) {
-          setThreadMidiValue(thread, midiEvent);
-        }
-        switch (midiEvent.type) {
-          case "noteOn":
-          case "noteOff":
-            vm.runtime.startHats(HATS.NOTE);
-            vm.runtime.startHats(HATS.NOTEANY);
-            break;
-          // FUTURE - support a "whenCC" block if needed
-          // case "cc":
-          //   vm.runtime.startHats(HATS.CC);
-          //   break;
-        }
-      });
-    }
     getInfo() {
-      const EVENT_TYPES_ITEMS = [
-        {
-          value: "noteOn",
-          text: Scratch.translate("Note On"),
-        },
-        {
-          value: "noteOff",
-          text: Scratch.translate("Note Off"),
-        },
-        {
-          value: "cc",
-          text: Scratch.translate("CC"),
-        },
-        {
-          value: "polyTouch",
-          text: Scratch.translate("AfterTouch"),
-        },
-        {
-          value: "pitchBend",
-          text: Scratch.translate("Pitch Bend"),
-        },
-        {
-          value: "programChange",
-          text: Scratch.translate("Program Change"),
-        },
-        {
-          value: "channelPressure",
-          text: Scratch.translate("Channel Pressure"),
-        },
-      ];
-
       return {
         id: EXT_ID,
         name: Scratch.translate("Midi"),
@@ -1466,22 +1418,10 @@
           "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
         blockIconURI:
           "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
-          color1: "#4C97FF",
-          color2: "#337BCC",
-          color3: "#2C6CA3",  
+        color1: "#4C97FF",
+        color2: "#337BCC",
+        color3: "#2C6CA3",
         blocks: [
-          // FUTURE - could force requesting permissions and checking midi device status. Usually refreshing is safer option
-          // {
-          //   opcode: "initialize",
-          //   text: Scratch.translate("Initialize force? [FORCE]"),
-          //   blockType: Scratch.BlockType.COMMAND,
-          //   arguments: {
-          //     FORCE: {
-          //       type: Scratch.ArgumentType.NUMBER,
-          //       defaultValue: 1
-          //     }
-          //   }
-          // },
           {
             opcode: "whenDeviceEvent",
             text: Scratch.translate("when [DEVICE_TYPE] device [STATE]"),
@@ -2039,6 +1979,55 @@
         },
       };
     }
+    constructor() {
+      this.midi = new MidiBackend();
+      this.recorder = new MidiRecorder();
+      /**
+       * Lazy initialize midi - only upon first executing, and used in other calls to make sure it gets triggered
+       */
+      this._ensureInitialize = (evt) => {
+        if (this.midi.status === "pending" /* Initial */) {
+          this.initialize().catch(() => {});
+        }
+      };
+      this._addListeners();
+      // globalThis.midiExt = this;
+      const vm = Scratch.vm;
+      vm.runtime.once("BEFORE_EXECUTE", this._ensureInitialize);
+    }
+    /**
+     * This helper actually glues together the extension with the MidiBackend / recorder. In particular it triggers HATS when incoming midi events occur
+     */
+    _addListeners() {
+      const vm = globalThis.Scratch.vm;
+      this.midi.on("device:status", (domEvent) => {
+        const changeEvent = domEvent.detail;
+        vm.runtime.startHats(HATS.DEVICE, {
+          DEVICE_TYPE: changeEvent.type,
+          STATE: changeEvent.state,
+        });
+      });
+      this.midi.on("midi", (domEvent) => {
+        const midiEvent = domEvent.detail;
+        this.recorder.add(midiEvent);
+        const threads = vm.runtime.startHats(HATS.MIDI);
+        // set the thread local variable to the passed in midi event for use with the "input event" reporter
+        for (let thread of threads) {
+          setThreadMidiValue(thread, midiEvent);
+        }
+        switch (midiEvent.type) {
+          case "noteOn":
+          case "noteOff":
+            vm.runtime.startHats(HATS.NOTE);
+            vm.runtime.startHats(HATS.NOTEANY);
+            break;
+          // FUTURE - support a "whenCC" block if needed
+          // case "cc":
+          //   vm.runtime.startHats(HATS.CC);
+          //   break;
+        }
+      });
+    }
     // taken from /Lily/ListTools.js
     _getLists() {
       if (typeof Blockly === "undefined") {

From 74001d810edda965be9a74af9127c64724cce7d4 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 18 Mar 2025 00:59:10 -0400
Subject: [PATCH 19/61] change parseMidiDataUrl to use same keys

Existing code uses "dur" for "duration", and "pitch" for "noteName"
---
 extensions/midi/midi.js | 42 ++++++++++++++++++++---------------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 57c6b330d7..107bf46577 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -31,13 +31,7 @@
     return module.exports.Midi;
   })();
 
-  function parseMidiDataUrl(args) {
-    // this.errorMessage = "";
-    if (!Midi) {
-      return "MIDI library failed to load";
-    }
-
-    const dataUrl = args.DATA_URL.trim();
+  function parseMidiDataUrl(dataUrl) {
     if (!dataUrl) {
       return "MIDI Data URL is empty";
     }
@@ -62,22 +56,23 @@
       const midi = new Midi(buffer);
 
       // Store note information
-      const notesData = [];
-      midi.tracks.forEach((track, trackIndex) => {
-        track.notes.forEach((note) => {
-          notesData.push({
-            track: trackIndex,
-            midiNumber: note.midi,
-            noteName: note.name,
-            startTime: note.time,
-            duration: note.duration,
-            velocity: note.velocity,
-          });
+      /** @type {MidiEvent[]} */
+      const notesData = midi.tracks.flatMap((track, trackIndex) => {
+        return track.notes.map((note) => {
+          return {
+            type: "noteOn",
+            channel: trackIndex + 1,
+            pitch: note.name,
+            time: note.time,
+            dur: note.duration,
+            // REVIEW should scale be MIDI (0-127), (0-1) or (0-100)?
+            velocity: note.velocity * 127,
+          };
         });
       });
 
-      notesData.sort((a, b) => a.startTime - b.startTime);
-      return JSON.stringify(notesData, null, 2);
+      notesData.sort((a, b) => a.time - b.time);
+      return notesData;
     } catch (error) {
       return "Error parsing MIDI file: " + error.message;
     }
@@ -2433,8 +2428,11 @@
       return event ? midiToString(event) : "";
     }
     /** MIDI FILE FUNCTIONS **/
-    parseMidiDataUrl(args) {
-      return parseMidiDataUrl(args);
+    parseMidiDataUrl({ DATA_URL }, util) {
+      const dataUrl = Scratch.Cast.toString(DATA_URL).trim();
+      if (!dataUrl) return "";
+      const notesData = parseMidiDataUrl(dataUrl);
+      return JSON.stringify(notesData, null, 2);
     }
   }
 

From 3209710ab6dcaaadabdf516b2dec7564499832b5 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 18 Mar 2025 01:02:20 -0400
Subject: [PATCH 20/61] round midi file times to 1 millisecond

midi precision doesn't go under 2-5 milliseconds, so forcing numbers to be readable 1ms precision
---
 extensions/midi/midi.js | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 107bf46577..d501ca8e88 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -63,10 +63,10 @@
             type: "noteOn",
             channel: trackIndex + 1,
             pitch: note.name,
-            time: note.time,
-            dur: note.duration,
+            time: roundToMillisecond(note.time),
+            dur: roundToMillisecond(note.duration),
             // REVIEW should scale be MIDI (0-127), (0-1) or (0-100)?
-            velocity: note.velocity * 127,
+            velocity: Math.round(note.velocity * 127)
           };
         });
       });
@@ -78,6 +78,10 @@
     }
   }
 
+  function roundToMillisecond(value) {
+    return Math.round(value * 1000) / 1000;
+  }
+
   //#endregion
 
   //#region utils

From 8b48acc7c3ee671825b2b04e5f152470461cb94b Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 18 Mar 2025 01:02:58 -0400
Subject: [PATCH 21/61] fix json to event formatting

---
 extensions/midi/midi.js | 49 ++++++++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 18 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index d501ca8e88..97fe40ed0e 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -118,6 +118,7 @@
    * @property {number} [startTimestamp] for future use
    * @property {boolean} [fixedWidth] include padding to make values line up
    * @property {boolean} [useHex] use hex for number values instead of base 10
+   * @property {boolean} [useFractions] output as fractions if possible
    * @property {number} [defaultOctave] default octave if not otherwise specfied. default 4
    *
    */
@@ -138,7 +139,7 @@
     midi,
     { useFlats = false, fixedWidth = false } = {}
   ) {
-    if (!isFinite(midi)) return "";
+    if (!isFinite(midi)) return Scratch.Cast.toString(midi) || "";
     let chroma = (useFlats ? FLATS : SHARPS)[midi % 12];
     if (fixedWidth) chroma = chroma.padEnd(2, "_");
     const octave = Math.floor(midi / 12) - 1;
@@ -615,14 +616,18 @@
     return ` ${PREFIX_WHEN}${formatTimespan(val)}`;
   }
 
-  // TODO FUTURE add in opts flag to use fractions or not
-  function formatPosition(value, _opts) {
-    return `${PREFIX_POS}${formatFraction(value)}`;
+  function formatPosition(value, opts) {
+    return ` ${PREFIX_POS}${formatSeconds(value, opts)}`;
   }
 
-  // TODO FUTURE add in opts flag to use fractions or not
-  function formatDuration(value, _opts) {
-    return `${PREFIX_DURATION}${formatFraction(value)}`;
+  function formatDuration(value, opts) {
+    return ` ${PREFIX_DURATION}${formatSeconds(value, opts)}`;
+  }
+
+  function formatSeconds(value, opts) {
+    // truncate to 1 millisecond accuracy
+    value = Math.round(value * 1000) / 1000;
+    return opts?.useFractions ? formatFraction(value) : `${value}`;
   }
 
   function formatTimespan(seconds, hoursOptional = true) {
@@ -2417,18 +2422,26 @@
       const raw = Scratch.Cast.toString(TEXT);
       let event = null;
       try {
-        event = {
-          ...JSON.parse(raw),
-        };
-        // rename aliases just in case
-        [
-          ["beats", "dur"],
-          ["offset", "pos"],
-          ["@", "time"],
-        ]
-          .filter(([alias, key]) => alias in event && event[key] == undefined)
-          .forEach(([alias, key]) => (event[key] = event[alias]));
+        event = JSON.parse(raw);
       } catch (error) {}
+
+      if (Array.isArray(event)) {
+        return event.map((e) => midiToString(e)).join("\n");
+      }
+      if (event === null) {
+        return "";
+      }
+      if (typeof event !== "object") {
+        return midiToString(stringToMidi(event));
+      }
+      // rename aliases just in case
+      [
+        ["beats", "dur"],
+        ["offset", "pos"],
+        ["@", "time"],
+      ]
+        .filter(([alias, key]) => alias in event && event[key] == undefined)
+        .forEach(([alias, key]) => (event[key] = event[alias]));
       return event ? midiToString(event) : "";
     }
     /** MIDI FILE FUNCTIONS **/

From 1c4dfb517308fe0c6e108cbf7dd8e1e574ceaf17 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 18 Mar 2025 01:06:23 -0400
Subject: [PATCH 22/61] fix linting

---
 extensions/midi/midi.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 97fe40ed0e..6b3eef3ecf 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -66,7 +66,7 @@
             time: roundToMillisecond(note.time),
             dur: roundToMillisecond(note.duration),
             // REVIEW should scale be MIDI (0-127), (0-1) or (0-100)?
-            velocity: Math.round(note.velocity * 127)
+            velocity: Math.round(note.velocity * 127),
           };
         });
       });
@@ -1712,7 +1712,7 @@
           {
             opcode: "parseMidiDataUrl",
             blockType: Scratch.BlockType.REPORTER,
-            text: "Parse MIDI Data URL [DATA_URL]",
+            text: Scratch.translate("Parse MIDI Data URL [DATA_URL]"),
             arguments: {
               DATA_URL: {
                 type: Scratch.ArgumentType.STRING,

From 5263530a77a38fdf9f0cd0139605dc9085dee29a Mon Sep 17 00:00:00 2001
From: Thomas Weber <muffin@muffin.ink>
Date: Sat, 22 Mar 2025 14:00:48 -0500
Subject: [PATCH 23/61] cloudlink: remove broken servers, put major verison in
 name (#2043)

The intent with having serverlist.json being fetched remotely was so
they could be changed without modifying the extension, but I guess that
didn't happen

This extension fails ESLint horribly including some very obvious real
errors but okay. Some of them are not obvious what the intent was.
---
 extensions/cloudlink.js | 35 ++++++++++++-----------------------
 1 file changed, 12 insertions(+), 23 deletions(-)

diff --git a/extensions/cloudlink.js b/extensions/cloudlink.js
index bc1d524eee..fdb014de1c 100644
--- a/extensions/cloudlink.js
+++ b/extensions/cloudlink.js
@@ -1,4 +1,4 @@
-// Name: Cloudlink
+// Name: CloudLink V4
 // ID: cloudlink
 // Description: A powerful WebSocket extension for Scratch.
 // By: MikeDEV
@@ -235,7 +235,16 @@
     handshakeAttempted: false,
 
     // Storage for the publically available CloudLink instances.
-    serverList: {},
+    serverList: {
+      "0": {
+        id: "Localhost",
+        url: "ws://127.0.0.1:3000/"
+      },
+      "7": {
+        id: "MikeDEV's Spare CL 0.2.0 Server",
+        url: "wss://cl.mikedev101.cc/"
+      }
+    }
   }
 
   function generateVersionString() {
@@ -791,32 +800,12 @@
     }
   }
 
-  // GET the serverList
-  try {
-    Scratch.fetch(
-      "https://raw.githubusercontent.com/MikeDev101/cloudlink/master/serverlist.json"
-    )
-      .then((response) => {
-        return response.text();
-      })
-      .then((data) => {
-        clVars.serverList = JSON.parse(data);
-      })
-      .catch((err) => {
-        console.log("[CloudLink] An error has occurred while parsing the public server list:", err);
-        clVars.serverList = {};
-      });
-  } catch (err) {
-    console.log("[CloudLink] An error has occurred while fetching the public server list:", err);
-    clVars.serverList = {};
-  }
-
   // Declare the CloudLink library.
   class CloudLink {
     getInfo() {
       return {
         id: 'cloudlink',
-        name: 'CloudLink',
+        name: 'CloudLink V4',
         blockIconURI: cl_block,
         menuIconURI: cl_icon,
         docsURI: "https://github.com/MikeDev101/cloudlink/wiki/Scratch-Client",

From 50e87ccb72fb0c6511ad6f2f51d19e58943a1191 Mon Sep 17 00:00:00 2001
From: Thomas Weber <muffin@muffin.ink>
Date: Wed, 26 Mar 2025 16:36:25 -0500
Subject: [PATCH 24/61] Lily/AllMenus: mark as scratch-compatible (#2045)

---
 extensions/Lily/AllMenus.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/extensions/Lily/AllMenus.js b/extensions/Lily/AllMenus.js
index d51f05ba0c..6ea7e20a47 100644
--- a/extensions/Lily/AllMenus.js
+++ b/extensions/Lily/AllMenus.js
@@ -3,6 +3,7 @@
 // Description: Special category with every menu from every Scratch category and extensions.
 // By: LilyMakesThings <https://scratch.mit.edu/users/LilyMakesThings/>
 // License: MIT AND LGPL-3.0
+// Scratch-compatible: true
 
 (function (Scratch) {
   "use strict";

From 40cc01de148873261c8fff2972e105120fea1802 Mon Sep 17 00:00:00 2001
From: Dango Cat <dangocat@muffin.ink>
Date: Wed, 26 Mar 2025 16:41:41 -0500
Subject: [PATCH 25/61] [Automated] Update translations 2025-03-26 (#2049)

This pull request was made by a robot.

Co-authored-by: DangoCat[bot] <dangocat@users.noreply.github.com>
---
 translations/extension-runtime.json | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/translations/extension-runtime.json b/translations/extension-runtime.json
index f286cd7367..ab5dafd058 100644
--- a/translations/extension-runtime.json
+++ b/translations/extension-runtime.json
@@ -3447,6 +3447,7 @@
         "SharkPool/Camera@_move [CAMERA] camera [NUM] steps": "カメラ[CAMERA]を[NUM]歩動かす",
         "SharkPool/Camera@_move [CAMERA] camera to [TARGET]": "カメラ[CAMERA]を[TARGET]に動かす",
         "SharkPool/Camera@_myself": "自分自身",
+        "SharkPool/Camera@_pen layer": "ペンのレイヤー",
         "SharkPool/Camera@_point [CAMERA] camera towards [TARGET]": "カメラ[CAMERA]を[TARGET]の方向に向ける",
         "SharkPool/Camera@_rendered x position of [TARGET]": "描かれた[TARGET]のx座標",
         "SharkPool/Camera@_rendered y position of [TARGET]": "描かれた[TARGET]のy座標",
@@ -3710,6 +3711,9 @@
         "bitwise@_[LEFT] or [RIGHT]": "[LEFT]または[RIGHT]",
         "bitwise@_is [CENTRAL] binary?": "[CENTRAL]がバイナリ",
         "box2d@griffpatch.categoryName": "物理",
+        "box2d@griffpatch.disablePhysics": "このスプライトの物理演算を無効にする",
+        "box2d@griffpatch.getGravityX": "x座標方向の重力",
+        "box2d@griffpatch.getGravityY": "y座標方向の重力",
         "box2d@griffpatch.getRestitution": "バウンド",
         "clipboard@_Clipboard": "クリップボード",
         "clipboard@_clipboard": "クリップボードの内容",

From 7147add4e90feac9101c8988698a6938f6caaa5f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 28 Mar 2025 09:18:22 -0500
Subject: [PATCH 26/61] build(deps-dev): bump eslint from 9.22.0 to 9.23.0
 (#2046)

---
 package-lock.json | 32 ++++++++++++++++----------------
 package.json      |  2 +-
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index f80d339762..1e9a54b058 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -21,7 +21,7 @@
       },
       "devDependencies": {
         "@transifex/api": "^7.1.3",
-        "eslint": "^9.22.0",
+        "eslint": "^9.23.0",
         "espree": "^9.6.1",
         "esquery": "^1.6.0",
         "prettier": "^3.5.3",
@@ -77,9 +77,9 @@
       }
     },
     "node_modules/@eslint/config-helpers": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.1.0.tgz",
-      "integrity": "sha512-kLrdPDJE1ckPo94kmPPf9Hfd0DU0Jw6oKYrhe+pwSC0iTUInmTa+w6fw8sGgcfkFJGNdWOUeOaDM4quW4a7OkA==",
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.2.0.tgz",
+      "integrity": "sha512-yJLLmLexii32mGrhW29qvU3QBVTu0GUmEf/J4XsBtVhp4JkIUFN/BjWqTF63yRvGApIDpZm5fa97LtYtINmfeQ==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
@@ -100,9 +100,9 @@
       }
     },
     "node_modules/@eslint/eslintrc": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.0.tgz",
-      "integrity": "sha512-yaVPAiNAalnCZedKLdR21GOGILMLKPyqSLWaAjQFvYA2i/ciDi8ArYVr69Anohb6cH2Ukhqti4aFnYyPm8wdwQ==",
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz",
+      "integrity": "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -155,9 +155,9 @@
       }
     },
     "node_modules/@eslint/js": {
-      "version": "9.22.0",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.22.0.tgz",
-      "integrity": "sha512-vLFajx9o8d1/oL2ZkpMYbkLv8nDB6yaIwFNt7nI4+I80U/z03SxmfOMsLbvWr3p7C+Wnoh//aOu2pQW8cS0HCQ==",
+      "version": "9.23.0",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.23.0.tgz",
+      "integrity": "sha512-35MJ8vCPU0ZMxo7zfev2pypqTwWTofFZO6m4KAtdoFhRpLJUpHTZZ+KB3C7Hb1d7bULYwO4lJXGCi5Se+8OMbw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -706,19 +706,19 @@
       }
     },
     "node_modules/eslint": {
-      "version": "9.22.0",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.22.0.tgz",
-      "integrity": "sha512-9V/QURhsRN40xuHXWjV64yvrzMjcz7ZyNoF2jJFmy9j/SLk0u1OLSZgXi28MrXjymnjEGSR80WCdab3RGMDveQ==",
+      "version": "9.23.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.23.0.tgz",
+      "integrity": "sha512-jV7AbNoFPAY1EkFYpLq5bslU9NLNO8xnEeQXwErNibVryjk67wHVmddTBilc5srIttJDBrB0eMHKZBFbSIABCw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.12.1",
         "@eslint/config-array": "^0.19.2",
-        "@eslint/config-helpers": "^0.1.0",
+        "@eslint/config-helpers": "^0.2.0",
         "@eslint/core": "^0.12.0",
-        "@eslint/eslintrc": "^3.3.0",
-        "@eslint/js": "9.22.0",
+        "@eslint/eslintrc": "^3.3.1",
+        "@eslint/js": "9.23.0",
         "@eslint/plugin-kit": "^0.2.7",
         "@humanfs/node": "^0.16.6",
         "@humanwhocodes/module-importer": "^1.0.1",
diff --git a/package.json b/package.json
index 7cc08334d2..8bd0473084 100644
--- a/package.json
+++ b/package.json
@@ -38,7 +38,7 @@
   },
   "devDependencies": {
     "@transifex/api": "^7.1.3",
-    "eslint": "^9.22.0",
+    "eslint": "^9.23.0",
     "espree": "^9.6.1",
     "esquery": "^1.6.0",
     "prettier": "^3.5.3",

From 35bf8c9061bed42257b8db5c4fbc967da3905d80 Mon Sep 17 00:00:00 2001
From: Thomas Weber <muffin@muffin.ink>
Date: Sun, 30 Mar 2025 20:42:46 -0500
Subject: [PATCH 27/61] cloudlink: more fixes (#2044)

- enable prettier
- enable eslint
- fix resetNewVarData having accidental (?) fallthrough
- fix (?) `clVars.listeners.varStates[String(args.ID)] =` simply always throwing an error
- change default value of server id and url blocks to something that will actually work
---
 extensions/cloudlink.js | 818 ++++++++++++++++++++++++----------------
 1 file changed, 503 insertions(+), 315 deletions(-)

diff --git a/extensions/cloudlink.js b/extensions/cloudlink.js
index fdb014de1c..68507f62a7 100644
--- a/extensions/cloudlink.js
+++ b/extensions/cloudlink.js
@@ -4,10 +4,7 @@
 // By: MikeDEV
 // License: MIT
 
-/* eslint-disable */
-// prettier-ignore
 (function (Scratch) {
-
   /*
   CloudLink Extension for TurboWarp v0.1.2.
 
@@ -37,9 +34,9 @@
   */
 
   // Require extension to be unsandboxed.
-  'use strict';
+  "use strict";
   if (!Scratch.extensions.unsandboxed) {
-    throw new Error('The CloudLink extension must run unsandboxed.');
+    throw new Error("The CloudLink extension must run unsandboxed.");
   }
 
   // Declare icons as static SVG URIs
@@ -81,7 +78,6 @@
 
   // Store extension state
   var clVars = {
-
     // Editor-specific variable for hiding old, legacy-support blocks.
     hideCLDeprecatedBlocks: true,
 
@@ -236,22 +232,23 @@
 
     // Storage for the publically available CloudLink instances.
     serverList: {
-      "0": {
+      0: {
         id: "Localhost",
-        url: "ws://127.0.0.1:3000/"
+        url: "ws://127.0.0.1:3000/",
       },
-      "7": {
+      7: {
         id: "MikeDEV's Spare CL 0.2.0 Server",
-        url: "wss://cl.mikedev101.cc/"
-      }
-    }
-  }
+        url: "wss://cl.mikedev101.cc/",
+      },
+    },
+  };
 
   function generateVersionString() {
     return `${version.editorType} ${version.versionString}`;
   }
 
   // Makes values safe for Scratch to represent.
+  // eslint-disable-next-line require-await
   async function makeValueScratchSafe(data) {
     if (typeof data == "object") {
       try {
@@ -337,12 +334,14 @@
   function sendMessage(message) {
     // Prevent running this while disconnected
     if (clVars.socket == null) {
-      console.warn("[CloudLink] Ignoring attempt to send a packet while disconnected.");
+      console.warn(
+        "[CloudLink] Ignoring attempt to send a packet while disconnected."
+      );
       return;
     }
 
     // See if the outgoing val argument can be converted into JSON
-    if (message.hasOwnProperty("val")) {
+    if (Object.prototype.hasOwnProperty.call(message, "val")) {
       try {
         message.val = JSON.parse(message.val);
       } catch {}
@@ -350,28 +349,33 @@
 
     // Attach listeners
     if (clVars.listeners.enablerState) {
-
       // 0.1.8.x was the first server version to support listeners.
       if (clVars.linkState.identifiedProtocol >= 2) {
         message.listener = clVars.listeners.enablerValue;
 
         // Create listener
-        clVars.listeners.varStates[String(args.ID)] = {
+        clVars.listeners.varStates[message.listener] = {
           hasNew: false,
           varState: {},
           eventHatTick: false,
         };
-
       } else {
-        console.warn("[CloudLink] Server is too old! Must be at least 0.1.8.x to support listeners.");
+        console.warn(
+          "[CloudLink] Server is too old! Must be at least 0.1.8.x to support listeners."
+        );
       }
       clVars.listeners.enablerState = false;
     }
 
     // Check if server supports rooms
-    if (((message.cmd == "link") || (message.cmd == "unlink")) && (clVars.linkState.identifiedProtocol < 2)) {
+    if (
+      (message.cmd == "link" || message.cmd == "unlink") &&
+      clVars.linkState.identifiedProtocol < 2
+    ) {
       // 0.1.8.x was the first server version to support rooms.
-      console.warn("[CloudLink] Server is too old! Must be at least 0.1.8.x to support room linking/unlinking.");
+      console.warn(
+        "[CloudLink] Server is too old! Must be at least 0.1.8.x to support room linking/unlinking."
+      );
       return;
     }
 
@@ -380,7 +384,10 @@
     try {
       outgoing = JSON.stringify(message);
     } catch (SyntaxError) {
-      console.warn("[CloudLink] Failed to send a packet, invalid syntax:", message);
+      console.warn(
+        "[CloudLink] Failed to send a packet, invalid syntax:",
+        message
+      );
       return;
     }
 
@@ -402,12 +409,13 @@
           versionNumber: version.versionNumber,
         },
       },
-      listener: "handshake_cfg"
+      listener: "handshake_cfg",
     });
     clVars.handshakeAttempted = true;
   }
 
   // Compare the version string of the server to known compatible variants to configure clVars.linkState.identifiedProtocol.
+  // eslint-disable-next-line require-await
   async function setServerVersion(version) {
     console.log(`[CloudLink] Server version: ${String(version)}`);
     clVars.server_version = version;
@@ -422,47 +430,56 @@
       "S2.2": 0, // 0.1.5
       "0.1.": 0, // 0.1.5 or legacy
       "S2.": 0, // Legacy
-      "S1.": -1 // Obsolete
+      "S1.": -1, // Obsolete
     };
 
     for (const [key, value] of Object.entries(versions)) {
       if (version.includes(key)) {
         if (clVars.linkState.identifiedProtocol < value) {
-
           // Disconnect if protcol is too old
           if (value == -1) {
-            console.warn(`[CloudLink] Server is too old to enable leagacy support. Disconnecting.`);
+            console.warn(
+              `[CloudLink] Server is too old to enable leagacy support. Disconnecting.`
+            );
             return clVars.socket.close(1000, "");
           }
-          
+
           // Set the identified protocol variant
           clVars.linkState.identifiedProtocol = value;
         }
       }
-    };
+    }
 
     // Log configured spec version
-    console.log(`[CloudLink] Configured protocol spec to v${clVars.linkState.identifiedProtocol}.`);
+    console.log(
+      `[CloudLink] Configured protocol spec to v${clVars.linkState.identifiedProtocol}.`
+    );
 
     // Fix timing bug
     clVars.linkState.status = 2;
 
     // Fire event hats (only one not broken)
-    runtime.startHats('cloudlink_onConnect');
+    runtime.startHats("cloudlink_onConnect");
 
     // Don't nag user if they already trusted this server
     if (clVars.currentServerUrl === clVars.lastServerUrl) return;
 
     // Ask user if they wish to stay connected if the server is unsupported
-    if ((clVars.linkState.identifiedProtocol < 4) && (!confirm(
-      `You have connected to an old CloudLink server, running version ${clVars.server_version}.\n\nFor your security and privacy, we recommend you disconnect from this server and connect to an up-to-date server.\n\nClick/tap \"OK\" to stay connected.`
-    ))) {
+    if (
+      clVars.linkState.identifiedProtocol < 4 &&
+      !confirm(
+        `You have connected to an old CloudLink server, running version ${clVars.server_version}.\n\nFor your security and privacy, we recommend you disconnect from this server and connect to an up-to-date server.\n\nClick/tap "OK" to stay connected.`
+      )
+    ) {
       // Close the connection if they choose "Cancel"
       clVars.linkState.isAttemptingGracefulDisconnect = true;
-      clVars.socket.close(1000, "Client going away (legacy server rejected by end user)");
+      clVars.socket.close(
+        1000,
+        "Client going away (legacy server rejected by end user)"
+      );
       return;
     }
-    
+
     // Don't nag user the next time they connect to this server
     clVars.lastServerUrl = clVars.currentServerUrl;
   }
@@ -472,15 +489,21 @@
     // Parse the message JSON
     let packet = {};
     try {
-      packet = JSON.parse(data)
+      packet = JSON.parse(data);
     } catch (SyntaxError) {
-      console.error("[CloudLink] Incoming message parse failure! Is this really a CloudLink server?", data);
+      console.error(
+        "[CloudLink] Incoming message parse failure! Is this really a CloudLink server?",
+        data
+      );
       return;
-    };
+    }
 
     // Handle packet commands
-    if (!packet.hasOwnProperty("cmd")) {
-      console.error("[CloudLink] Incoming message read failure! This message doesn't contain the required \"cmd\" key. Is this really a CloudLink server?", packet);
+    if (!Object.prototype.hasOwnProperty.call(packet, "cmd")) {
+      console.error(
+        '[CloudLink] Incoming message read failure! This message doesn\'t contain the required "cmd" key. Is this really a CloudLink server?',
+        packet
+      );
       return;
     }
     console.log("[CloudLink] RX:", packet);
@@ -521,7 +544,7 @@
 
       case "direct":
         // Handle events from older server versions
-        if (packet.val.hasOwnProperty("cmd")) {
+        if (Object.prototype.hasOwnProperty.call(packet.val, "cmd")) {
           switch (packet.val.cmd) {
             // Server 0.1.5 (at least)
             case "vers":
@@ -531,7 +554,9 @@
 
             // Server 0.1.7 (at least)
             case "motd":
-              console.log(`[CloudLink] Message of the day: \"${packet.val.val}\"`);
+              console.log(
+                `[CloudLink] Message of the day: "${packet.val.val}"`
+              );
               clVars.motd = packet.val.val;
               return;
           }
@@ -553,7 +578,9 @@
         // Store direct value
         // Protocol v0 (0.1.5 and legacy) don't implement status codes.
         if (clVars.linkState.identifiedProtocol == 0) {
-          console.warn("[CloudLink] Received a statuscode message while using protocol v0. This event shouldn't happen. It's likely that this server is modified (did MikeDEV overlook some unexpected behavior?).");
+          console.warn(
+            "[CloudLink] Received a statuscode message while using protocol v0. This event shouldn't happen. It's likely that this server is modified (did MikeDEV overlook some unexpected behavior?)."
+          );
           return;
         }
 
@@ -565,30 +592,32 @@
         // Protocol v2 (0.1.8.x) uses "code" instead.
         // Protocol v3-v4 (0.1.9.x - latest, 0.2.0) adds "code_id" to the payload. Ignored by Scratch clients.
         else {
-
           // Handle setup listeners
-          if (packet.hasOwnProperty("listener")) {
+          if (Object.prototype.hasOwnProperty.call(packet, "listener")) {
             switch (packet.listener) {
               case "username_cfg":
-
                 // Username accepted
                 if (packet.code.includes("I:100")) {
                   clVars.myUserObject = packet.val;
                   clVars.username.value = packet.val.username;
                   clVars.username.accepted = true;
-                  console.log(`[CloudLink] Username has been set to \"${clVars.username.value}\" successfully!`);
+                  console.log(
+                    `[CloudLink] Username has been set to "${clVars.username.value}" successfully!`
+                  );
 
-                // Username rejected / error
+                  // Username rejected / error
                 } else {
-                  console.log(`[CloudLink] Username rejected by the server! Error code ${packet.code}.}`);
+                  console.log(
+                    `[CloudLink] Username rejected by the server! Error code ${packet.code}.}`
+                  );
                 }
                 return;
-              
+
               case "handshake_cfg":
                 // Prevent handshake responses being stored in the statuscode variables
                 console.log("[CloudLink] Server responded to our handshake!");
                 return;
-              
+
               case "link":
                 // Room link accepted
                 if (!clVars.rooms.isAttemptingLink) return;
@@ -597,12 +626,14 @@
                   clVars.rooms.isLinked = true;
                   console.log("[CloudLink] Room linked successfully!");
 
-                // Room link rejected / error
+                  // Room link rejected / error
                 } else {
-                  console.log(`[CloudLink] Room link rejected! Error code ${packet.code}.}`);
+                  console.log(
+                    `[CloudLink] Room link rejected! Error code ${packet.code}.}`
+                  );
                 }
                 return;
-              
+
               case "unlink":
                 // Room unlink accepted
                 if (!clVars.rooms.isAttemptingUnlink) return;
@@ -611,9 +642,11 @@
                   clVars.rooms.isLinked = false;
                   console.log("[CloudLink] Room unlinked successfully!");
 
-                // Room link rejected / error
+                  // Room link rejected / error
                 } else {
-                  console.log(`[CloudLink] Room unlink rejected! Error code ${packet.code}.}`);
+                  console.log(
+                    `[CloudLink] Room unlink rejected! Error code ${packet.code}.}`
+                  );
                 }
                 return;
             }
@@ -632,21 +665,25 @@
       case "ulist":
         // Protocol v0-v1 (0.1.5 and legacy - 0.1.7) use a semicolon (;) separated string for the userlist.
         if (
-          (clVars.linkState.identifiedProtocol == 0)
-          || 
-          (clVars.linkState.identifiedProtocol == 1)
+          clVars.linkState.identifiedProtocol == 0 ||
+          clVars.linkState.identifiedProtocol == 1
         ) {
           // Split the username list string
-          clVars.ulist = String(packet.val).split(';');
+          clVars.ulist = String(packet.val).split(";");
 
           // Get rid of blank entry at the end of the list
-          clVars.ulist.pop(clVars.ulist.length);
+          clVars.ulist.pop();
 
           // Check if username has been set (since older servers don't implement statuscodes or listeners)
-          if ((clVars.username.attempted) && (clVars.ulist.includes(clVars.username.temp))) {
+          if (
+            clVars.username.attempted &&
+            clVars.ulist.includes(clVars.username.temp)
+          ) {
             clVars.username.value = clVars.username.temp;
             clVars.username.accepted = true;
-            console.log(`[CloudLink] Username has been set to \"${clVars.username.value}\" successfully!`);
+            console.log(
+              `[CloudLink] Username has been set to "${clVars.username.value}" successfully!`
+            );
           }
         }
 
@@ -658,23 +695,27 @@
         // Protocol v3-v4 (0.1.9.x - latest, 0.2.0) uses "mode" to add/set/remove entries to the userlist.
         else {
           // Check for "mode" key
-          if (!packet.hasOwnProperty("mode")) {
-            console.warn("[CloudLink] Userlist message did not specify \"mode\" while running in protocol mode 3 or 4.");
+          if (!Object.prototype.hasOwnProperty.call(packet, "mode")) {
+            console.warn(
+              '[CloudLink] Userlist message did not specify "mode" while running in protocol mode 3 or 4.'
+            );
             return;
-          };
+          }
           // Handle methods
           switch (packet.mode) {
-            case 'set':
+            case "set":
               clVars.ulist = packet.val;
               break;
-            case 'add':
+            case "add":
               clVars.ulist.push(packet.val);
               break;
-            case 'remove':
+            case "remove":
               clVars.ulist.slice(clVars.ulist.indexOf(packet.val), 1);
               break;
             default:
-              console.warn(`[CloudLink] Unrecognised userlist mode: \"${packet.mode}\".`);
+              console.warn(
+                `[CloudLink] Unrecognised userlist mode: "${packet.mode}".`
+              );
               break;
           }
         }
@@ -689,27 +730,28 @@
 
       case "client_ip":
         console.log(`[CloudLink] Client IP address: ${packet.val}`);
-        console.warn("[CloudLink] This server has relayed your identified IP address to you. Under normal circumstances, this will be erased server-side when you disconnect, but you should still be careful. Unless you trust this server, it is not recommended to send login credentials or personal info.");
+        console.warn(
+          "[CloudLink] This server has relayed your identified IP address to you. Under normal circumstances, this will be erased server-side when you disconnect, but you should still be careful. Unless you trust this server, it is not recommended to send login credentials or personal info."
+        );
         clVars.client_ip = packet.val;
         break;
 
       case "motd":
-        console.log(`[CloudLink] Message of the day: \"${packet.val}\"`);
+        console.log(`[CloudLink] Message of the day: "${packet.val}"`);
         clVars.motd = packet.val;
         break;
 
       default:
-        console.warn(`[CloudLink] Unrecognised command: \"${packet.cmd}\".`);
+        console.warn(`[CloudLink] Unrecognised command: "${packet.cmd}".`);
         return;
     }
 
     // Handle listeners
-    if (packet.hasOwnProperty("listener")) {
+    if (Object.prototype.hasOwnProperty.call(packet, "listener")) {
       if (clVars.listeners.current.includes(String(packet.listener))) {
-
         // Remove the listener from the currently listening list
         clVars.listeners.current.splice(
-          clVars.listeners.current.indexOf(String(packet.listener)), 
+          clVars.listeners.current.indexOf(String(packet.listener)),
           1
         );
 
@@ -726,7 +768,9 @@
   // Basic netcode needed to make the extension work
   async function newClient(url) {
     if (!(await Scratch.canFetch(url))) {
-      console.warn("[CloudLink] Did not get permission to connect, aborting...");
+      console.warn(
+        "[CloudLink] Did not get permission to connect, aborting..."
+      );
       return;
     }
 
@@ -737,6 +781,7 @@
     // Establish a connection to the server
     console.log("[CloudLink] Connecting to server:", url);
     try {
+      // eslint-disable-next-line extension/check-can-fetch
       clVars.socket = new WebSocket(url);
     } catch (e) {
       console.warn("[CloudLink] An exception has occurred:", e);
@@ -746,13 +791,15 @@
     // Bind connection established event
     clVars.socket.onopen = function (event) {
       clVars.currentServerUrl = url;
-      
+
       // Set the link state to connected.
       console.log("[CloudLink] Connected.");
 
       // If a server_version message hasn't been received in over half a second, try to broadcast a handshake
-      clVars.handshakeTimeout = window.setTimeout(function() {
-        console.log("[CloudLink] Hmm... This server hasn't sent us it's server info. Going to attempt a handshake.");
+      clVars.handshakeTimeout = window.setTimeout(function () {
+        console.log(
+          "[CloudLink] Hmm... This server hasn't sent us it's server info. Going to attempt a handshake."
+        );
         sendHandshake();
       }, 500);
 
@@ -776,14 +823,21 @@
           break;
 
         case 2: // Was already connected
-          if (event.wasClean || clVars.linkState.isAttemptingGracefulDisconnect) {
+          if (
+            event.wasClean ||
+            clVars.linkState.isAttemptingGracefulDisconnect
+          ) {
             // Set the link state to graceful disconnect.
-            console.log(`[CloudLink] Disconnected (${event.code} ${event.reason}).`);
+            console.log(
+              `[CloudLink] Disconnected (${event.code} ${event.reason}).`
+            );
             clVars.linkState.status = 3;
             clVars.linkState.disconnectType = 0;
           } else {
             // Set the link state to ungraceful disconnect.
-            console.log(`[CloudLink] Lost connection (${event.code} ${event.reason}).`);
+            console.log(
+              `[CloudLink] Lost connection (${event.code} ${event.reason}).`
+            );
             clVars.linkState.status = 4;
             clVars.linkState.disconnectType = 2;
           }
@@ -794,39 +848,39 @@
       resetOnClose();
 
       // Run all onClose event blocks
-      runtime.startHats('cloudlink_onClose');
+      runtime.startHats("cloudlink_onClose");
       // Return promise (during setup)
       return;
-    }
+    };
   }
 
   // Declare the CloudLink library.
   class CloudLink {
     getInfo() {
       return {
-        id: 'cloudlink',
-        name: 'CloudLink V4',
+        id: "cloudlink",
+        // eslint-disable-next-line extension/should-translate
+        name: "CloudLink V4",
         blockIconURI: cl_block,
         menuIconURI: cl_icon,
         docsURI: "https://github.com/MikeDev101/cloudlink/wiki/Scratch-Client",
         blocks: [
-
           {
             opcode: "returnGlobalData",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("global data")
+            text: Scratch.translate("global data"),
           },
 
           {
             opcode: "returnPrivateData",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("private data")
+            text: Scratch.translate("private data"),
           },
 
           {
             opcode: "returnDirectData",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("direct data")
+            text: Scratch.translate("direct data"),
           },
 
           "---",
@@ -834,13 +888,13 @@
           {
             opcode: "returnLinkData",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("link status")
+            text: Scratch.translate("link status"),
           },
 
           {
             opcode: "returnStatusCode",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("status code")
+            text: Scratch.translate("status code"),
           },
 
           "---",
@@ -848,20 +902,22 @@
           {
             opcode: "returnUserListData",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("usernames")
+            text: Scratch.translate("usernames"),
           },
 
           {
             opcode: "returnUsernameDataNew",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("my username")
+            text: Scratch.translate("my username"),
           },
 
           {
             opcode: "returnUsernameData",
             blockType: Scratch.BlockType.REPORTER,
             hideFromPalette: clVars.hideCLDeprecatedBlocks,
-            text: Scratch.translate("(OLD - DO NOT USE IN NEW PROJECTS) my username")
+            text: Scratch.translate(
+              "(OLD - DO NOT USE IN NEW PROJECTS) my username"
+            ),
           },
 
           "---",
@@ -869,25 +925,25 @@
           {
             opcode: "returnVersionData",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("extension version")
+            text: Scratch.translate("extension version"),
           },
 
           {
             opcode: "returnServerVersion",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("server version")
+            text: Scratch.translate("server version"),
           },
 
           {
             opcode: "returnServerList",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("server list")
+            text: Scratch.translate("server list"),
           },
 
           {
             opcode: "returnMOTD",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("server MOTD")
+            text: Scratch.translate("server MOTD"),
           },
 
           "---",
@@ -895,13 +951,13 @@
           {
             opcode: "returnClientIP",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("my IP address")
+            text: Scratch.translate("my IP address"),
           },
 
           {
             opcode: "returnUserObject",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("my user object")
+            text: Scratch.translate("my user object"),
           },
 
           "---",
@@ -975,11 +1031,12 @@
             arguments: {
               PATH: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: 'fruit/apples',
+                defaultValue: "fruit/apples",
               },
               JSON_STRING: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: '{"fruit": {"apples": 2, "bananas": 3}, "total_fruit": 5}',
+                defaultValue:
+                  '{"fruit": {"apples": 2, "bananas": 3}, "total_fruit": 5}',
               },
             },
           },
@@ -988,7 +1045,7 @@
             opcode: "getFromJSONArray",
             blockType: Scratch.BlockType.REPORTER,
             hideFromPalette: clVars.hideCLDeprecatedBlocks,
-            text: Scratch.translate('[NUM] from JSON array [ARRAY]'),
+            text: Scratch.translate("[NUM] from JSON array [ARRAY]"),
             arguments: {
               NUM: {
                 type: Scratch.ArgumentType.NUMBER,
@@ -997,8 +1054,8 @@
               ARRAY: {
                 type: Scratch.ArgumentType.STRING,
                 defaultValue: '["foo","bar"]',
-              }
-            }
+              },
+            },
           },
 
           {
@@ -1022,12 +1079,12 @@
             arguments: {
               JSON_STRING: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: '{"fruit": {"apples": 2, "bananas": 3}, "total_fruit": 5}',
+                defaultValue:
+                  '{"fruit": {"apples": 2, "bananas": 3}, "total_fruit": 5}',
               },
             },
           },
 
-
           "---",
 
           {
@@ -1047,7 +1104,9 @@
             opcode: "requestURL",
             blockType: Scratch.BlockType.REPORTER,
             hideFromPalette: clVars.hideCLDeprecatedBlocks,
-            text: Scratch.translate("send request with method [method] for URL [url] with data [data] and headers [headers]"),
+            text: Scratch.translate(
+              "send request with method [method] for URL [url] with data [data] and headers [headers]"
+            ),
             arguments: {
               method: {
                 type: Scratch.ArgumentType.STRING,
@@ -1089,7 +1148,9 @@
           {
             opcode: "onListener",
             blockType: Scratch.BlockType.HAT,
-            text: Scratch.translate("when I receive new message with listener [ID]"),
+            text: Scratch.translate(
+              "when I receive new message with listener [ID]"
+            ),
             isEdgeActivated: true,
             arguments: {
               ID: {
@@ -1226,9 +1287,9 @@
             arguments: {
               IP: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "ws://127.0.0.1:3000/",
-              }
-            }
+                defaultValue: "wss://cl.mikedev101.cc/",
+              },
+            },
           },
 
           {
@@ -1238,15 +1299,15 @@
             arguments: {
               ID: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 1,
-              }
-            }
+                defaultValue: "7",
+              },
+            },
           },
 
           {
             opcode: "closeSocket",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate("disconnect")
+            text: Scratch.translate("disconnect"),
           },
 
           "---",
@@ -1275,13 +1336,12 @@
                 defaultValue: "example-listener",
               },
             },
-
           },
 
           "---",
 
           {
-            opcode: 'linkToRooms',
+            opcode: "linkToRooms",
             blockType: Scratch.BlockType.COMMAND,
             text: Scratch.translate("link to room(s) [ROOMS]"),
             arguments: {
@@ -1289,7 +1349,7 @@
                 type: Scratch.ArgumentType.STRING,
                 defaultValue: Scratch.translate('["test"]'),
               },
-            }
+            },
           },
 
           {
@@ -1359,7 +1419,9 @@
           {
             opcode: "sendPDataAsVar",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate("send variable [VAR] to [ID] with data [DATA]"),
+            text: Scratch.translate(
+              "send variable [VAR] to [ID] with data [DATA]"
+            ),
             arguments: {
               DATA: {
                 type: Scratch.ArgumentType.STRING,
@@ -1474,7 +1536,7 @@
                 menu: "allmenu",
                 defaultValue: "All data",
               },
-            }
+            },
           },
 
           "---",
@@ -1494,45 +1556,71 @@
           },
 
           "---",
-
         ],
         menus: {
           datamenu: {
             items: [
-              {text: Scratch.translate('Global data'), value: 'Global data'},
-              {text: Scratch.translate('Private data'), value: 'Private data'},
-              {text: Scratch.translate('Direct data'), value: 'Direct data'},
-              {text: Scratch.translate('Status code'), value: 'Status code'}
-            ]
+              { text: Scratch.translate("Global data"), value: "Global data" },
+              {
+                text: Scratch.translate("Private data"),
+                value: "Private data",
+              },
+              { text: Scratch.translate("Direct data"), value: "Direct data" },
+              { text: Scratch.translate("Status code"), value: "Status code" },
+            ],
           },
           varmenu: {
             items: [
-              {text: Scratch.translate('Global variables'), value: "Global variables"},
-              {text: Scratch.translate('Private variables'), value: "Private variables"}
-            ]
+              {
+                text: Scratch.translate("Global variables"),
+                value: "Global variables",
+              },
+              {
+                text: Scratch.translate("Private variables"),
+                value: "Private variables",
+              },
+            ],
           },
           allmenu: {
             items: [
-              {text: Scratch.translate('Global data'), value: 'Global data'},
-              {text: Scratch.translate('Private data'), value: 'Private data'},
-              {text: Scratch.translate('Direct data'), value: 'Direct data'},
-              {text: Scratch.translate('Status code'), value: 'Status code'},
-              {text: Scratch.translate("Global variables"), value: "Global variables"},
-              {text: Scratch.translate("Private variables"), value: "Private variables"},
-              {text: Scratch.translate("All data"), value: "All data"}
-              ]
+              { text: Scratch.translate("Global data"), value: "Global data" },
+              {
+                text: Scratch.translate("Private data"),
+                value: "Private data",
+              },
+              { text: Scratch.translate("Direct data"), value: "Direct data" },
+              { text: Scratch.translate("Status code"), value: "Status code" },
+              {
+                text: Scratch.translate("Global variables"),
+                value: "Global variables",
+              },
+              {
+                text: Scratch.translate("Private variables"),
+                value: "Private variables",
+              },
+              { text: Scratch.translate("All data"), value: "All data" },
+            ],
           },
           almostallmenu: {
             items: [
-              {text: Scratch.translate('Global data'), value: 'Global data'},
-              {text: Scratch.translate('Private data'), value: 'Private data'},
-              {text: Scratch.translate('Direct data'), value: 'Direct data'},
-              {text: Scratch.translate('Status code'), value: 'Status code'},
-              {text: Scratch.translate("Global variables"), value: "Global variables"},
-              {text: Scratch.translate("Private variables"), value: "Private variables"}
-              ]
+              { text: Scratch.translate("Global data"), value: "Global data" },
+              {
+                text: Scratch.translate("Private data"),
+                value: "Private data",
+              },
+              { text: Scratch.translate("Direct data"), value: "Direct data" },
+              { text: Scratch.translate("Status code"), value: "Status code" },
+              {
+                text: Scratch.translate("Global variables"),
+                value: "Global variables",
+              },
+              {
+                text: Scratch.translate("Private variables"),
+                value: "Private variables",
+              },
+            ],
           },
-        }
+        },
       };
     }
 
@@ -1627,7 +1715,12 @@
     // Reporter - Returns data for a specific listener ID.
     // ID - String (listener ID)
     returnListenerData(args) {
-      if (!clVars.listeners.varStates.hasOwnProperty(String(args.ID))) {
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          clVars.listeners.varStates,
+          String(args.ID)
+        )
+      ) {
         console.warn(`[CloudLink] Listener ID ${args.ID} does not exist!`);
         return "";
       }
@@ -1638,19 +1731,19 @@
     // TYPE - String (menu allmenu)
     readQueueSize(args) {
       switch (args.TYPE) {
-        case 'Global data':
+        case "Global data":
           return clVars.gmsg.queue.length;
-        case 'Private data':
+        case "Private data":
           return clVars.pmsg.queue.length;
-        case 'Direct data':
+        case "Direct data":
           return clVars.direct.queue.length;
-        case 'Status code':
+        case "Status code":
           return clVars.statuscode.queue.length;
-        case 'Global variables':
+        case "Global variables":
           return clVars.gvar.queue.length;
-        case 'Private variables':
+        case "Private variables":
           return clVars.pvar.queue.length;
-        case 'All data':
+        case "All data":
           return (
             clVars.gmsg.queue.length +
             clVars.pmsg.queue.length +
@@ -1666,26 +1759,26 @@
     // TYPE - String (menu allmenu)
     readQueueData(args) {
       switch (args.TYPE) {
-        case 'Global data':
+        case "Global data":
           return makeValueScratchSafe(clVars.gmsg.queue);
-        case 'Private data':
+        case "Private data":
           return makeValueScratchSafe(clVars.pmsg.queue);
-        case 'Direct data':
+        case "Direct data":
           return makeValueScratchSafe(clVars.direct.queue);
-        case 'Status code':
+        case "Status code":
           return makeValueScratchSafe(clVars.statuscode.queue);
-        case 'Global variables':
+        case "Global variables":
           return makeValueScratchSafe(clVars.gvar.queue);
-        case 'Private variables':
+        case "Private variables":
           return makeValueScratchSafe(clVars.pvar.queue);
-        case 'All data':
+        case "All data":
           return makeValueScratchSafe({
             gmsg: clVars.gmsg.queue,
             pmsg: clVars.pmsg.queue,
             direct: clVars.direct.queue,
             statuscode: clVars.statuscode.queue,
             gvar: clVars.gvar.queue,
-            pvar: clVars.pvar.queue
+            pvar: clVars.pvar.queue,
           });
       }
     }
@@ -1694,42 +1787,58 @@
     // TYPE - String (menu varmenu), VAR - String (variable name)
     returnVarData(args) {
       switch (args.TYPE) {
-      case 'Global variables':
-        if (!clVars.gvar.varStates.hasOwnProperty(String(args.VAR))) {
-          console.warn(`[CloudLink] Global variable ${args.VAR} does not exist!`);
-          return "";
-        }
-        return clVars.gvar.varStates[String(args.VAR)].varState;
-      case 'Private variables':
-        if (!clVars.pvar.varStates.hasOwnProperty(String(args.VAR))) {
-          console.warn(`[CloudLink] Private variable ${args.VAR} does not exist!`);
-          return "";
-        }
-        return clVars.pvar.varStates[String(args.VAR)].varState;
+        case "Global variables":
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              clVars.gvar.varStates,
+              String(args.VAR)
+            )
+          ) {
+            console.warn(
+              `[CloudLink] Global variable ${args.VAR} does not exist!`
+            );
+            return "";
+          }
+          return clVars.gvar.varStates[String(args.VAR)].varState;
+        case "Private variables":
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              clVars.pvar.varStates,
+              String(args.VAR)
+            )
+          ) {
+            console.warn(
+              `[CloudLink] Private variable ${args.VAR} does not exist!`
+            );
+            return "";
+          }
+          return clVars.pvar.varStates[String(args.VAR)].varState;
       }
     }
 
     // Reporter - Gets a JSON key value from a JSON string.
     // PATH - String, JSON_STRING - String
-    parseJSON(args) { 
+    parseJSON(args) {
       try {
-        const path = args.PATH.toString().split('/').map(prop => decodeURIComponent(prop));
-        if (path[0] === '') path.splice(0, 1);
-        if (path[path.length - 1] === '') path.splice(-1, 1);
+        const path = args.PATH.toString()
+          .split("/")
+          .map((prop) => decodeURIComponent(prop));
+        if (path[0] === "") path.splice(0, 1);
+        if (path[path.length - 1] === "") path.splice(-1, 1);
         let json;
         try {
-          json = JSON.parse(' ' + args.JSON_STRING);
+          json = JSON.parse(" " + args.JSON_STRING);
         } catch (e) {
           return e.message;
-        };
-        path.forEach(prop => json = json[prop]);
-        if (json === null) return 'null';
-        else if (json === undefined) return '';
-        else if (typeof json === 'object') return JSON.stringify(json);
+        }
+        path.forEach((prop) => (json = json[prop]));
+        if (json === null) return "null";
+        else if (json === undefined) return "";
+        else if (typeof json === "object") return JSON.stringify(json);
         else return json.toString();
       } catch (err) {
-        return '';
-      };
+        return "";
+      }
     }
 
     // Reporter - Returns an entry from a JSON array (0-based).
@@ -1740,11 +1849,11 @@
         return "";
       } else {
         let data = json_array[args.NUM];
-  
-        if (typeof (data) == "object") {
+
+        if (typeof data == "object") {
           data = JSON.stringify(data); // Make the JSON safe for Scratch
         }
-  
+
         return data;
       }
     }
@@ -1752,9 +1861,9 @@
     // Reporter - Returns a RESTful GET promise.
     // url - String
     fetchURL(args) {
-      return Scratch.fetch(args.url, {method: "GET"})
-        .then(response => response.text())
-        .catch(error => {
+      return Scratch.fetch(args.url, { method: "GET" })
+        .then((response) => response.text())
+        .catch((error) => {
           console.warn(`[CloudLink] Fetch error: ${error}`);
         });
     }
@@ -1765,25 +1874,25 @@
       if (args.method == "GET" || args.method == "HEAD") {
         return Scratch.fetch(args.url, {
           method: args.method,
-          headers: JSON.parse(args.headers)
+          headers: JSON.parse(args.headers),
         })
-          .then(response => response.text())
-          .catch(error => {
+          .then((response) => response.text())
+          .catch((error) => {
             console.warn(`[CloudLink] Request error: ${error}`);
           });
       } else {
         return Scratch.fetch(args.url, {
           method: args.method,
           headers: JSON.parse(args.headers),
-          body: JSON.parse(args.data)
+          body: JSON.parse(args.data),
         })
-          .then(response => response.text())
-          .catch(error => {
+          .then((response) => response.text())
+          .catch((error) => {
             console.warn(`[CloudLink] Request error: ${error}`);
           });
       }
     }
-    
+
     // Event
     // ID - String (listener)
     onListener(args) {
@@ -1792,7 +1901,13 @@
       if (clVars.linkState.status != 2) return false;
 
       // Listener must exist
-      if (!clVars.listeners.varStates.hasOwnProperty(args.ID)) return false;
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          clVars.listeners.varStates,
+          args.ID
+        )
+      )
+        return false;
 
       // Run event
       if (clVars.listeners.varStates[args.ID].eventHatTick) {
@@ -1811,42 +1926,42 @@
 
       // Run event
       switch (args.TYPE) {
-        case 'Global data':
+        case "Global data":
           if (clVars.gmsg.eventHatTick) {
             clVars.gmsg.eventHatTick = false;
             return true;
           }
           break;
 
-        case 'Private data':
+        case "Private data":
           if (clVars.pmsg.eventHatTick) {
             clVars.pmsg.eventHatTick = false;
             return true;
           }
           break;
 
-        case 'Direct data':
+        case "Direct data":
           if (clVars.direct.eventHatTick) {
             clVars.direct.eventHatTick = false;
             return true;
           }
           break;
 
-        case 'Status code':
+        case "Status code":
           if (clVars.statuscode.eventHatTick) {
             clVars.statuscode.eventHatTick = false;
             return true;
           }
           break;
 
-        case 'Global variables':
+        case "Global variables":
           if (clVars.gvar.eventHatTick) {
             clVars.gvar.eventHatTick = false;
             return true;
           }
           break;
 
-        case 'Private variables':
+        case "Private variables":
           if (clVars.pvar.eventHatTick) {
             clVars.pvar.eventHatTick = false;
             return true;
@@ -1865,10 +1980,15 @@
 
       // Run event
       switch (args.TYPE) {
-        case 'Global variables':
-
+        case "Global variables":
           // Variable must exist
-          if (!clVars.gvar.varStates.hasOwnProperty(String(args.VAR))) break;
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              clVars.gvar.varStates,
+              String(args.VAR)
+            )
+          )
+            break;
           if (clVars.gvar.varStates[String(args.VAR)].eventHatTick) {
             clVars.gvar.varStates[String(args.VAR)].eventHatTick = false;
             return true;
@@ -1876,10 +1996,15 @@
 
           break;
 
-        case 'Private variables':
-
+        case "Private variables":
           // Variable must exist
-          if (!clVars.pvar.varStates.hasOwnProperty(String(args.VAR))) break;
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              clVars.pvar.varStates,
+              String(args.VAR)
+            )
+          )
+            break;
           if (clVars.pvar.varStates[String(args.VAR)].eventHatTick) {
             clVars.pvar.varStates[String(args.VAR)].eventHatTick = false;
             return true;
@@ -1893,61 +2018,64 @@
     // Reporter - Returns a JSON-ified value.
     // toBeJSONified - String
     makeJSON(args) {
-      if (typeof(args.toBeJSONified) == "string") {
+      if (typeof args.toBeJSONified == "string") {
         try {
           JSON.parse(args.toBeJSONified);
           return String(args.toBeJSONified);
-        } catch(err) {
+        } catch (err) {
           return "Not JSON!";
         }
-      } else if (typeof(args.toBeJSONified) == "object") {
+      } else if (typeof args.toBeJSONified == "object") {
         return JSON.stringify(args.toBeJSONified);
       } else {
         return "Not JSON!";
-      };
+      }
     }
 
     // Boolean - Returns true if connected.
     getComState() {
-      return ((clVars.linkState.status == 2) && (clVars.socket != null));
+      return clVars.linkState.status == 2 && clVars.socket != null;
     }
 
     // Boolean - Returns true if linked to rooms (other than "default")
     getRoomState() {
-      return ((clVars.socket != null) && (clVars.rooms.isLinked));
+      return clVars.socket != null && clVars.rooms.isLinked;
     }
 
     // Boolean - Returns true if the connection was dropped.
     getComLostConnectionState() {
-      return ((clVars.linkState.status == 4) && (clVars.linkState.disconnectType == 2));
+      return (
+        clVars.linkState.status == 4 && clVars.linkState.disconnectType == 2
+      );
     }
 
     // Boolean - Returns true if the client failed to establish a connection.
     getComFailedConnectionState() {
-      return ((clVars.linkState.status == 4) && (clVars.linkState.disconnectType == 1));
+      return (
+        clVars.linkState.status == 4 && clVars.linkState.disconnectType == 1
+      );
     }
 
     // Boolean - Returns true if the username was set successfully.
     getUsernameState() {
-      return ((clVars.socket != null) && (clVars.username.accepted));
+      return clVars.socket != null && clVars.username.accepted;
     }
 
     // Boolean - Returns true if there is new gmsg/pmsg/direct/statuscode data.
     // TYPE - String (menu datamenu)
     returnIsNewData(args) {
-
       // Must be connected
       if (clVars.socket == null) return false;
 
       // Run event
       switch (args.TYPE) {
-        case 'Global data':
+        case "Global data":
           return clVars.gmsg.hasNew;
-        case 'Private data':
+        case "Private data":
           return clVars.pmsg.hasNew;
-        case 'Direct data':
+        case "Direct data":
           return clVars.direct.hasNew;
-        case 'Status code':
+        case "Status code":
           return clVars.statuscode.hasNew;
       }
     }
@@ -1956,15 +2084,29 @@
     // TYPE - String (menu varmenu), VAR - String (variable name)
     returnIsNewVarData(args) {
       switch (args.TYPE) {
-        case 'Global variables':
-          if (!clVars.gvar.varStates.hasOwnProperty(String(args.VAR))) {
-            console.warn(`[CloudLink] Global variable ${args.VAR} does not exist!`);
+        case "Global variables":
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              clVars.gvar.varStates,
+              String(args.VAR)
+            )
+          ) {
+            console.warn(
+              `[CloudLink] Global variable ${args.VAR} does not exist!`
+            );
             return false;
           }
           return clVars.gvar.varStates[String(args.ID)].hasNew;
-        case 'Private variables':
-          if (!clVars.pvar.varStates.hasOwnProperty(String(args.VAR))) {
-            console.warn(`[CloudLink] Private variable ${args.VAR} does not exist!`);
+        case "Private variables":
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              clVars.pvar.varStates,
+              String(args.VAR)
+            )
+          ) {
+            console.warn(
+              `[CloudLink] Private variable ${args.VAR} does not exist!`
+            );
             return false;
           }
           return clVars.pvar.varStates[String(args.ID)].hasNew;
@@ -1974,7 +2116,12 @@
     // Boolean - Returns true if a listener has a new value.
     // ID - String (listener ID)
     returnIsNewListener(args) {
-      if (!clVars.listeners.varStates.hasOwnProperty(String(args.ID))) {
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          clVars.listeners.varStates,
+          String(args.ID)
+        )
+      ) {
         console.warn(`[CloudLink] Listener ID ${args.ID} does not exist!`);
         return false;
       }
@@ -1984,37 +2131,34 @@
     // Boolean - Returns true if a username/ID/UUID/object exists in the userlist.
     // ID - String (username or user object)
     checkForID(args) {
-
       // Legacy ulist handling
       if (clVars.ulist.includes(args.ID)) return true;
 
       // New ulist handling
       if (clVars.linkState.identifiedProtocol > 2) {
         if (this.isValidJSON(args.ID)) {
-          return clVars.ulist.some(o => (
-            (o.username === JSON.parse(args.ID).username)
-            && 
-            (o.id == JSON.parse(args.ID).id)
-          ));
+          return clVars.ulist.some(
+            (o) =>
+              o.username === JSON.parse(args.ID).username &&
+              o.id == JSON.parse(args.ID).id
+          );
         } else {
-          return clVars.ulist.some(o => (
-            (o.username === String(args.ID))
-            || 
-            (o.id == args.ID)
-          ));
+          return clVars.ulist.some(
+            (o) => o.username === String(args.ID) || o.id == args.ID
+          );
         }
       } else return false;
     }
 
     // Boolean - Returns true if the input JSON is valid.
     // JSON_STRING - String
-    isValidJSON(args) { 
+    isValidJSON(args) {
       try {
         JSON.parse(args.JSON_STRING);
         return true;
       } catch {
         return false;
-      };
+      }
     }
 
     // Command - Establishes a connection to a server.
@@ -2023,7 +2167,7 @@
       if (clVars.socket != null) {
         console.warn("[CloudLink] Already connected to a server.");
         return;
-      };
+      }
       return newClient(args.IP);
     }
 
@@ -2033,11 +2177,16 @@
       if (clVars.socket != null) {
         console.warn("[CloudLink] Already connected to a server.");
         return;
-      };
-      if (!clVars.serverList.hasOwnProperty(String(args.ID))) {
+      }
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          clVars.serverList,
+          String(args.ID)
+        )
+      ) {
         console.warn("[CloudLink] Not a valid server ID!");
         return;
-      };
+      }
       return newClient(clVars.serverList[String(args.ID)]["url"]);
     }
 
@@ -2046,7 +2195,7 @@
       if (clVars.socket == null) {
         console.warn("[CloudLink] Already disconnected.");
         return;
-      };
+      }
       console.log("[CloudLink] Disconnecting...");
       clVars.linkState.isAttemptingGracefulDisconnect = true;
       clVars.socket.close(1000, "Client going away");
@@ -2062,13 +2211,13 @@
       if (clVars.username.attempted) {
         console.warn("[CloudLink] Already attempting to set username!");
         return;
-      };
+      }
 
       // Prevent running if the username is already set.
       if (clVars.username.accepted) {
         console.warn("[CloudLink] Already set username!");
         return;
-      };
+      }
 
       // Update state
       clVars.username.attempted = true;
@@ -2081,28 +2230,31 @@
     // Command - Prepares the next transmitted message to have a listener ID attached to it.
     // ID - String (listener ID)
     createListener(args) {
-
       // Must be connected to set a username.
       if (clVars.socket == null) return;
-      
+
       // Require server support
       if (clVars.linkState.identifiedProtocol < 2) {
-        console.warn("[CloudLink] Server is too old! Must be at least 0.1.8.x to support listeners.");
+        console.warn(
+          "[CloudLink] Server is too old! Must be at least 0.1.8.x to support listeners."
+        );
         return;
       }
 
       // Prevent running if the username hasn't been set.
       if (!clVars.username.accepted) {
-        console.warn("[CloudLink] Username must be set before creating a listener!");
+        console.warn(
+          "[CloudLink] Username must be set before creating a listener!"
+        );
         return;
-      };
+      }
 
       // Must be used once per packet
       if (clVars.listeners.enablerState) {
         console.warn("[CloudLink] Cannot create multiple listeners at a time!");
         return;
       }
-      
+
       // Update state
       clVars.listeners.enablerState = true;
       clVars.listeners.enablerValue = args.ID;
@@ -2110,34 +2262,37 @@
 
     // Command - Subscribes to various rooms on a server.
     // ROOMS - String (JSON Array or single string)
-    linkToRooms(args) { 
-
+    linkToRooms(args) {
       // Must be connected to set a username.
       if (clVars.socket == null) return;
 
       // Require server support
       if (clVars.linkState.identifiedProtocol < 2) {
-        console.warn("[CloudLink] Server is too old! Must be at least 0.1.8.x to support rooms.");
+        console.warn(
+          "[CloudLink] Server is too old! Must be at least 0.1.8.x to support rooms."
+        );
         return;
       }
 
       // Prevent running if the username hasn't been set.
       if (!clVars.username.accepted) {
-        console.warn("[CloudLink] Username must be set before linking to rooms!");
+        console.warn(
+          "[CloudLink] Username must be set before linking to rooms!"
+        );
         return;
-      };
+      }
 
       // Prevent running if already linked.
       if (clVars.rooms.isLinked) {
         console.warn("[CloudLink] Already linked to rooms!");
         return;
-      };
+      }
 
       // Prevent running if a room link is in progress.
       if (clVars.rooms.isAttemptingLink) {
         console.warn("[CloudLink] Currently linking to rooms! Please wait!");
         return;
-      };
+      }
 
       clVars.rooms.isAttemptingLink = true;
       sendMessage({ cmd: "link", val: args.ROOMS, listener: "link" });
@@ -2145,68 +2300,80 @@
 
     // Command - Specifies specific subscribed rooms to transmit messages to.
     // ROOMS - String (JSON Array or single string)
-    selectRoomsInNextPacket(args) { 
-
+    selectRoomsInNextPacket(args) {
       // Must be connected to user rooms.
       if (clVars.socket == null) return;
 
       // Require server support
       if (clVars.linkState.identifiedProtocol < 2) {
-        console.warn("[CloudLink] Server is too old! Must be at least 0.1.8.x to support rooms.");
+        console.warn(
+          "[CloudLink] Server is too old! Must be at least 0.1.8.x to support rooms."
+        );
         return;
       }
 
       // Prevent running if the username hasn't been set.
       if (!clVars.username.accepted) {
-        console.warn("[CloudLink] Username must be set before selecting rooms!");
+        console.warn(
+          "[CloudLink] Username must be set before selecting rooms!"
+        );
         return;
-      };
+      }
 
       // Require once per packet
       if (clVars.rooms.enablerState) {
-        console.warn("[CloudLink] Cannot use the room selector more than once at a time!");
+        console.warn(
+          "[CloudLink] Cannot use the room selector more than once at a time!"
+        );
         return;
       }
 
       // Prevent running if not linked.
       if (!clVars.rooms.isLinked) {
-        console.warn("[CloudLink] Cannot use room selector while not linked to rooms!");
+        console.warn(
+          "[CloudLink] Cannot use room selector while not linked to rooms!"
+        );
         return;
-      };
+      }
 
       clVars.rooms.enablerState = true;
       clVars.rooms.enablerValue = args.ROOMS;
-    } 
+    }
 
     // Command - Unsubscribes from all rooms and re-subscribes to the the "default" room on the server.
-    unlinkFromRooms() { 
-
+    unlinkFromRooms() {
       // Must be connected to user rooms.
       if (clVars.socket == null) return;
 
       // Require server support
       if (clVars.linkState.identifiedProtocol < 2) {
-        console.warn("[CloudLink] Server is too old! Must be at least 0.1.8.x to support rooms.");
+        console.warn(
+          "[CloudLink] Server is too old! Must be at least 0.1.8.x to support rooms."
+        );
         return;
       }
 
       // Prevent running if the username hasn't been set.
       if (!clVars.username.accepted) {
-        console.warn("[CloudLink] Username must be set before unjoining rooms!");
+        console.warn(
+          "[CloudLink] Username must be set before unjoining rooms!"
+        );
         return;
-      };
+      }
 
       // Prevent running if already unlinked.
       if (!clVars.rooms.isLinked) {
         console.warn("[CloudLink] Already unlinked from rooms!");
         return;
-      };
+      }
 
       // Prevent running if a room unlink is in progress.
       if (clVars.rooms.isAttemptingUnlink) {
-        console.warn("[CloudLink] Currently unlinking from rooms! Please wait!");
+        console.warn(
+          "[CloudLink] Currently unlinking from rooms! Please wait!"
+        );
         return;
-      };
+      }
 
       clVars.rooms.isAttemptingUnlink = true;
       sendMessage({ cmd: "unlink", val: "", listener: "unlink" });
@@ -2215,7 +2382,6 @@
     // Command - Sends a gmsg value.
     // DATA - String
     sendGData(args) {
-
       // Must be connected.
       if (clVars.socket == null) return;
 
@@ -2225,15 +2391,16 @@
     // Command - Sends a pmsg value.
     // DATA - String, ID - String (recipient ID)
     sendPData(args) {
-
       // Must be connected.
       if (clVars.socket == null) return;
 
       // Prevent running if the username hasn't been set.
       if (!clVars.username.accepted) {
-        console.warn("[CloudLink] Username must be set before sending private messages!");
+        console.warn(
+          "[CloudLink] Username must be set before sending private messages!"
+        );
         return;
-      };
+      }
 
       sendMessage({ cmd: "pmsg", val: args.DATA, id: args.ID });
     }
@@ -2241,7 +2408,6 @@
     // Command - Sends a gvar value.
     // DATA - String, VAR - String (variable name)
     sendGDataAsVar(args) {
-
       // Must be connected.
       if (clVars.socket == null) return;
 
@@ -2251,15 +2417,16 @@
     // Command - Sends a pvar value.
     // DATA - String, VAR - String (variable name), ID - String (recipient ID)
     sendPDataAsVar(args) {
-
       // Must be connected.
       if (clVars.socket == null) return;
 
       // Prevent running if the username hasn't been set.
       if (!clVars.username.accepted) {
-        console.warn("[CloudLink] Username must be set before sending private variables!");
+        console.warn(
+          "[CloudLink] Username must be set before sending private variables!"
+        );
         return;
-      };
+      }
 
       sendMessage({ cmd: "pvar", val: args.DATA, name: args.VAR, id: args.ID });
     }
@@ -2267,7 +2434,6 @@
     // Command - Sends a raw-format command without specifying an ID.
     // CMD - String (command), DATA - String
     runCMDnoID(args) {
-
       // Must be connected.
       if (clVars.socket == null) return;
 
@@ -2277,15 +2443,16 @@
     // Command - Sends a raw-format command with an ID.
     // CMD - String (command), DATA - String, ID - String (recipient ID)
     runCMD(args) {
-
       // Must be connected.
       if (clVars.socket == null) return;
 
       // Prevent running if the username hasn't been set.
       if (!clVars.username.accepted) {
-        console.warn("[CloudLink] Username must be set before using this command!");
+        console.warn(
+          "[CloudLink] Username must be set before using this command!"
+        );
         return;
-      };
+      }
 
       sendMessage({ cmd: args.CMD, val: args.DATA, id: args.ID });
     }
@@ -2294,16 +2461,16 @@
     // TYPE - String (menu datamenu)
     resetNewData(args) {
       switch (args.TYPE) {
-        case 'Global data':
+        case "Global data":
           clVars.gmsg.hasNew = false;
           break;
-        case 'Private data':
+        case "Private data":
           clVars.pmsg.hasNew = false;
           break;
-        case 'Direct data':
+        case "Direct data":
           clVars.direct.hasNew = false;
           break;
-        case 'Status code':
+        case "Status code":
           clVars.statuscode.hasNew = false;
           break;
       }
@@ -2313,25 +2480,46 @@
     // TYPE - String (menu varmenu), VAR - String (variable name)
     resetNewVarData(args) {
       switch (args.TYPE) {
-        case 'Global variables':
-          if (!clVars.gvar.varStates.hasOwnProperty(String(args.VAR))) {
-            console.warn(`[CloudLink] Global variable ${args.VAR} does not exist!`);
+        case "Global variables":
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              clVars.gvar.varStates,
+              String(args.VAR)
+            )
+          ) {
+            console.warn(
+              `[CloudLink] Global variable ${args.VAR} does not exist!`
+            );
             return;
           }
           clVars.gvar.varStates[String(args.ID)].hasNew = false;
-        case 'Private variables':
-          if (!clVars.pvar.varStates.hasOwnProperty(String(args.VAR))) {
-            console.warn(`[CloudLink] Private variable ${args.VAR} does not exist!`);
+          break;
+        case "Private variables":
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              clVars.pvar.varStates,
+              String(args.VAR)
+            )
+          ) {
+            console.warn(
+              `[CloudLink] Private variable ${args.VAR} does not exist!`
+            );
             return false;
           }
           clVars.pvar.varStates[String(args.ID)].hasNew = false;
+          break;
       }
     }
 
     // Command - Resets the "returnIsNewListener" boolean state.
     // ID - Listener ID
     resetNewListener(args) {
-      if (!clVars.listeners.varStates.hasOwnProperty(String(args.ID))) {
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          clVars.listeners.varStates,
+          String(args.ID)
+        )
+      ) {
         console.warn(`[CloudLink] Listener ID ${args.ID} does not exist!`);
         return;
       }
@@ -2342,25 +2530,25 @@
     // TYPE - String (menu allmenu)
     clearAllPackets(args) {
       switch (args.TYPE) {
-        case 'Global data':
+        case "Global data":
           clVars.gmsg.queue = [];
           break;
-        case 'Private data':
+        case "Private data":
           clVars.pmsg.queue = [];
           break;
-        case 'Direct data':
+        case "Direct data":
           clVars.direct.queue = [];
           break;
-        case 'Status code':
+        case "Status code":
           clVars.statuscode.queue = [];
           break;
-        case 'Global variables':
+        case "Global variables":
           clVars.gvar.queue = [];
           break;
-        case 'Private variables':
+        case "Private variables":
           clVars.pvar.queue = [];
           break;
-        case 'All data':
+        case "All data":
           clVars.gmsg.queue = [];
           clVars.pmsg.queue = [];
           clVars.direct.queue = [];

From f9969ff467178f5c2c1c7c515a558106962d1b6c Mon Sep 17 00:00:00 2001
From: yuri-kiss <135030944+yuri-kiss@users.noreply.github.com>
Date: Sun, 30 Mar 2025 21:43:00 -0400
Subject: [PATCH 28/61] Skyhigh173/json: fix undefined issues (#2058)

fixes #2056
---
 extensions/Skyhigh173/json.js | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/extensions/Skyhigh173/json.js b/extensions/Skyhigh173/json.js
index 06b4eb4521..2ffdc58eeb 100644
--- a/extensions/Skyhigh173/json.js
+++ b/extensions/Skyhigh173/json.js
@@ -680,7 +680,7 @@
         return json;
       } else {
         try {
-          return JSON.parse(json);
+          return JSON.parse(json) ?? "";
         } catch {
           return json;
         }
@@ -768,12 +768,14 @@
         json = JSON.parse(json);
         switch (Stype) {
           case "keys":
-            return JSON.stringify(Object.keys(json).map((key) => key));
+            return JSON.stringify(Object.keys(json).map((key) => key ?? ""));
           case "values":
-            return JSON.stringify(Object.keys(json).map((key) => json[key]));
+            return JSON.stringify(
+              Object.keys(json).map((key) => json[key] ?? "")
+            );
           case "datas":
             return JSON.stringify(
-              Object.keys(json).map((key) => [key, json[key]])
+              Object.keys(json).map((key) => [key, json[key] ?? ""])
             );
           default:
             return "";
@@ -787,7 +789,7 @@
       try {
         json = JSON.parse(json);
         if (hasOwn(json, item)) {
-          const result = json[item];
+          const result = json[item] ?? "";
           if (typeof result === "object") {
             return JSON.stringify(result);
           } else {
@@ -805,7 +807,8 @@
       if (Number.isNaN(value)) return "NaN";
       if (value === Infinity) return "Infinity";
       if (value === -Infinity) return "-Infinity";
-      return value;
+      // null and undefined -> empty
+      return value ?? "";
     }
 
     json_set({ item, value, json }) {
@@ -850,6 +853,7 @@
         } else {
           result = json[json.length + item];
         }
+        result = result ?? "";
         if (typeof result == "object") {
           return JSON.stringify(result);
         } else {
@@ -1032,7 +1036,7 @@
           if (Array.isArray(array)) {
             const safeArray = array.map((i) => {
               if (typeof i === "object") return JSON.stringify(i);
-              return i;
+              return i ?? "";
             });
             listVariable.value = safeArray;
           }

From 37cb2c49dfcbdf4f200a7dc133c13d79bbbb3dfb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 30 Mar 2025 23:53:42 -0500
Subject: [PATCH 29/61] build(deps): bump @turbowarp/types from `b89be2e` to
 `79ab4cc` (#2060)

---
 package-lock.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 1e9a54b058..e170f92abb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -276,8 +276,8 @@
     },
     "node_modules/@turbowarp/types": {
       "version": "0.0.13",
-      "resolved": "git+ssh://git@github.com/TurboWarp/types-tw.git#b89be2e3ce64fa84774540dff026a42dd915ee3c",
-      "integrity": "sha512-1VMhsp7fzrhLe+8pepcGO1/mglQbqJiuAJsFx2qpCgsexYEsc/6QPKr1as6F+QLMdmvqXWvmf9kNju8ofoZwRQ==",
+      "resolved": "git+ssh://git@github.com/TurboWarp/types-tw.git#79ab4cc947763b8151e214388985e6a89d1a6cd6",
+      "integrity": "sha512-EL/75glhoeHvIG/BqtcS15gLJ9f2mcBB9D6uFzlnJMJbvfaCI+NI+OPMYM8tkPsF45/5duFY90nxRQMChlC0Tg==",
       "license": "Apache-2.0"
     },
     "node_modules/@types/estree": {

From 1ae69edcbe54ddc0aee6c73b7bac79a91fee3c0b Mon Sep 17 00:00:00 2001
From: Brackets-Coder <142950368+Brackets-Coder@users.noreply.github.com>
Date: Mon, 31 Mar 2025 11:46:55 -0400
Subject: [PATCH 30/61] Documentation enhancement: support markdown alerts
 (#2054)

#2050

This is a simple pull request that adds support for alerts in extension
documentation markdown files:

> [!NOTE]
> Useful information that users should know, even when skimming content.

> [!TIP]
> Helpful advice for doing things better or more easily.

> [!IMPORTANT]
> Key information users need to know to achieve their goal.

> [!WARNING]
> Urgent info that needs immediate user attention to avoid problems.

> [!CAUTION]
> Advises about risks or negative outcomes of certain actions.

Some of the CSS is messy and the rule was poorly designed and I kind of
rushed this

---------

Co-authored-by: Cubester <cubester.spamlegends@gmail.com>
Co-authored-by: yuri-kiss <135030944+yuri-kiss@users.noreply.github.com>
---
 development/docs-template.ejs     | 38 +++++++++++++++
 development/render-docs.js        | 77 +++++++++++++++++++++++++++++++
 docs/CST1229/zip.md               |  3 +-
 docs/CubesterYT/WindowControls.md | 11 +++--
 docs/DNin/wake-lock.md            |  3 +-
 docs/Lily/Skins.md                |  7 +--
 docs/TheShovel/ShovelUtils.md     |  6 ++-
 docs/Xeltalliv/simple3D.md        | 14 ++++--
 docs/ar.md                        |  3 +-
 docs/box2d.md                     |  5 +-
 docs/godslayerakp/ws.md           |  3 +-
 docs/steamworks.md                |  7 +--
 12 files changed, 155 insertions(+), 22 deletions(-)

diff --git a/development/docs-template.ejs b/development/docs-template.ejs
index d704b5d46f..9f498e2f24 100644
--- a/development/docs-template.ejs
+++ b/development/docs-template.ejs
@@ -141,6 +141,44 @@
         margin: 1rem 0;
         font-size: small;
       }
+
+      /* General Alert Styles */
+      .alert {
+        padding-left: 15px;
+        line-height: 1;
+      }
+
+      /* Border colors for specific alerts */
+      .alert.alert-note { border-left: .25em solid #1f6feb; }
+      .alert.alert-tip { border-left: .25em solid #238636; }
+      .alert.alert-important { border-left: .25em solid #8957e5; }
+      .alert.alert-warning { border-left: .25em solid #9e6a03; }
+      .alert.alert-caution { border-left: .25em solid #da3633; }
+
+      /* Shared Styling for Alert Text */
+      .alert p:first-child {
+        padding-top: 10px;
+        font-weight: 500;
+        font-size: 14px;
+        display: flex;
+      }
+      
+      .alert p:last-child {
+        padding-bottom: 10px;
+      }
+
+      /* Specific Color Overrides for Each Alert */
+      .alert.alert-note > p:first-child { color: #4493f8; }
+      .alert.alert-tip > p:first-child { color: #3fb950; }
+      .alert.alert-important > p:first-child { color: #ab7df8; }
+      .alert.alert-warning > p:first-child { color: #d29922; }
+      .alert.alert-caution > p:first-child { color: #f85149; }
+
+      /* Icon Spacing */
+      div.alert svg {
+        margin-right: 8px;
+      }
+
     </style>
   </head>
   <body>
diff --git a/development/render-docs.js b/development/render-docs.js
index 3bdcfab88e..378cc38d63 100644
--- a/development/render-docs.js
+++ b/development/render-docs.js
@@ -2,6 +2,15 @@ const path = require("path");
 const MarkdownIt = require("markdown-it");
 const renderTemplate = require("./render-template");
 
+// From GitHub's markdown alert SVG icons: https://github.com/primer/octicons
+const blockIcons = {
+  note: `<svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true" fill="#4493f8"><path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>`,
+  tip: `<svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true" fill="#3fb950"><path d="M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 0 1-1.484.211c-.04-.282-.163-.547-.37-.847a8.456 8.456 0 0 0-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.751.751 0 0 1-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75ZM5.75 12h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1 0-1.5ZM6 15.25a.75.75 0 0 1 .75-.75h2.5a.75.75 0 0 1 0 1.5h-2.5a.75.75 0 0 1-.75-.75Z"></path></svg>`,
+  important: `<svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true" fill="#ab7df8"><path d="M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0 1 14.25 13H8.06l-2.573 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25Zm7 2.25v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 9a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path></svg>`,
+  warning: `<svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true" fill="#d29922"><path d="M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path></svg>`,
+  caution: `<svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true" fill="#f85149"><path d="M4.47.22A.749.749 0 0 1 5 0h6c.199 0 .389.079.53.22l4.25 4.25c.141.14.22.331.22.53v6a.749.749 0 0 1-.22.53l-4.25 4.25A.749.749 0 0 1 11 16H5a.749.749 0 0 1-.53-.22L.22 11.53A.749.749 0 0 1 0 11V5c0-.199.079-.389.22-.53Zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5ZM8 4a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 8 4Zm0 8a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>`,
+};
+
 const md = new MarkdownIt({
   html: true,
   linkify: true,
@@ -25,6 +34,74 @@ md.renderer.rules.fence = function (tokens, idx, options, env, self) {
   )}">${md.utils.escapeHtml(token.content)}</pre>`;
 };
 
+md.block.ruler.before(
+  "blockquote",
+  "custom_blockquote",
+  function (state, startLine, endLine, silent) {
+    const marker = state.src.slice(
+      state.bMarks[startLine],
+      state.eMarks[startLine]
+    );
+
+    const match = marker.match(/^\s*>\s*\[!([A-Z]+)]\s*(.*)/);
+    if (!match) return false;
+
+    const type = match[1].toLowerCase();
+    if (!blockIcons[type]) {
+      throw new TypeError(`Invalid alert type: ${match[1]}`);
+    }
+    const icon = blockIcons[type];
+
+    if (silent) return true;
+
+    // Open alert div
+    const tokenOpen = state.push("html_block", "", 0);
+    tokenOpen.content = `<div class="alert alert-${type}">`;
+
+    // Render title with Markdown support
+    state.push("paragraph_open", "p", 1);
+    const tokenTitle = state.push("inline", "", 0);
+    tokenTitle.content = `${icon} **${type.charAt(0).toUpperCase() + type.slice(1)}**`;
+    tokenTitle.children = [];
+    state.push("paragraph_close", "p", -1);
+
+    // Process all lines inside the blockquote
+    let nextLine = startLine + 1;
+    while (nextLine < endLine) {
+      const nextMarker = state.src.slice(
+        state.bMarks[nextLine],
+        state.eMarks[nextLine]
+      );
+
+      if (/^\s*>/.test(nextMarker)) {
+        const lineContent = nextMarker.replace(/^\s*>?\s*/, "").trim();
+
+        if (lineContent === "") {
+          state.push("paragraph_open", "p", 1);
+          state.push("paragraph_close", "p", -1);
+        } else {
+          state.push("paragraph_open", "p", 1);
+          const token = state.push("inline", "", 0);
+          token.content = lineContent;
+          token.children = [];
+          state.push("paragraph_close", "p", -1);
+        }
+
+        nextLine++;
+      } else {
+        break;
+      }
+    }
+
+    // Close alert div
+    const tokenClose = state.push("html_block", "", 0);
+    tokenClose.content = `</div>`;
+
+    state.line = nextLine;
+    return true;
+  }
+);
+
 /**
  * @param {string} markdownSource Markdown code
  * @param {string} slug Path slug like 'TestMuffin/fetch'
diff --git a/docs/CST1229/zip.md b/docs/CST1229/zip.md
index 5e0fa44ea6..163db0a625 100644
--- a/docs/CST1229/zip.md
+++ b/docs/CST1229/zip.md
@@ -45,7 +45,8 @@ The type can be one of the following:
 
 The name is used for dealing with multiple archives at time; it can be any non-empty string and does *not* have to be the archive's filename.
 
-If the file is not of zip format (like RAR or 7z) or is password-protected, it won't be opened. Make sure to check if it loaded successfully with the `error opening archive?` block. 
+> [!TIP]
+> If the file is not of zip format (like RAR or 7z) or is password-protected, it won't be opened. Make sure to check if it loaded successfully with the `error opening archive?` block. 
 
 ---
 
diff --git a/docs/CubesterYT/WindowControls.md b/docs/CubesterYT/WindowControls.md
index 2d6e61a07b..b3b396e070 100644
--- a/docs/CubesterYT/WindowControls.md
+++ b/docs/CubesterYT/WindowControls.md
@@ -2,11 +2,12 @@
 
 This extension provides a set of blocks that gives you greater control over the Program Window.
 
-**Note: Most of these blocks only work in Electron, Pop Ups/Web Apps containing HTML packaged projects, and normal Web Apps.**
-
-Examples include, but are not limited to: **TurboWarp Desktop App, TurboWarp Web App, Pop Up/Web App windows that contain the HTML packaged project, and plain Electron.**
-
-**Blocks that still work outside of these will be specified.**
+> [!NOTE]
+> **Most of these blocks only work in Electron, Pop Ups/Web Apps containing HTML packaged projects, and normal Web Apps.**
+>
+> Examples include, but are not limited to: **TurboWarp Desktop App, TurboWarp Web App, Pop Up/Web App windows that contain the HTML packaged project, and plain Electron.**
+>
+> **Blocks that still work outside of these will be specified.**
 
 ## Move Window Block
 
diff --git a/docs/DNin/wake-lock.md b/docs/DNin/wake-lock.md
index dc1e59f3cf..3f2d9b5e3d 100644
--- a/docs/DNin/wake-lock.md
+++ b/docs/DNin/wake-lock.md
@@ -19,7 +19,8 @@ Wake lock will also be released automatically when the project stops or is resta
 
 ## Browser support
 
-Not all browsers support wake lock (notably, Firefox does not). In these browsers requesting wake lock will not do anything.
+> [!WARNING]
+> Not all browsers support wake lock **(notably, Firefox does not)**. In these browsers requesting wake lock will not do anything.
 
 ## Note
 
diff --git a/docs/Lily/Skins.md b/docs/Lily/Skins.md
index 64522d77fa..79bb09b7f7 100644
--- a/docs/Lily/Skins.md
+++ b/docs/Lily/Skins.md
@@ -26,9 +26,10 @@ load skin from (costume 1 v) as [my skin] :: #6b56ff
 ```
 The second way is by loading a skin from a costume.
 
-It's important to note that this block will require the Advanced Option "Remove raw asset data after loading to save RAM" to be disabled in the packager in order for this block to work correctly in a packaged environment. **You do not need to do this within the editor.**
-
-If you intend to package your project, we don't encourage using this block for that reason. **None of the other blocks in this extension require this option to be disabled.**
+> [!IMPORTANT]
+> It's important to note that this block will require the Advanced Option "Remove raw asset data after loading to save RAM" to be disabled in the packager in order for this block to work correctly in a packaged environment. **You do not need to do this within the editor.**
+>
+> If you intend to package your project, we don't encourage using this block for that reason. **None of the other blocks in this extension require this option to be disabled.**
 
 ---
 
diff --git a/docs/TheShovel/ShovelUtils.md b/docs/TheShovel/ShovelUtils.md
index 06b659a5fe..50abae281e 100644
--- a/docs/TheShovel/ShovelUtils.md
+++ b/docs/TheShovel/ShovelUtils.md
@@ -2,7 +2,8 @@
 
 Shovel Utils is an extension focused mostly on injecting and modifying sprites and assets inside the project, as well as several other functions.
 
-**Disclaimer: Modifying and importing assets can be dangerous, and has the potential to corrupt your project. Be careful!**
+> [!CAUTION]
+> **Modifying and importing assets can be dangerous, and has the potential to corrupt your project. Be careful!**
 
 ## Importing Assets
 
@@ -10,7 +11,8 @@ Shovel Utils offers an easy way to import several types of assets, including spr
 
 ---
 
-**This goes for all blocks that fetch from a link: If you're experiences errors and are not able to import an asset from a link, check your console! You may be running into a CORS error. To resolve this, use a proxy like [corsproxy.io](https://corsproxy.io).**
+> [!TIP]
+> **This goes for all blocks that fetch from a link: If you're experiences errors and are not able to import an asset from a link, check your console! You may be running into a CORS error. To resolve this, use a proxy like [corsproxy.io](https://corsproxy.io).**
 
 ```scratch
 import sprite from [Link or data uri here]
diff --git a/docs/Xeltalliv/simple3D.md b/docs/Xeltalliv/simple3D.md
index 8fb8612456..e4376ca4aa 100644
--- a/docs/Xeltalliv/simple3D.md
+++ b/docs/Xeltalliv/simple3D.md
@@ -42,7 +42,9 @@ So in short, **this extension does not have any kind of scenes, objects, cameras
 3D models consist of vertices which together form primitives (points, lines, triangles). Each vertex has either 2D (XY) or 3D (XYZ) location described with 2 or 3 numbers respectively. Before drawing the mesh, you would usually set up transformation, which tells how to take those initial locations and transform them to correct location on your 2D screen. The typical way to do it, is to chain multiple simple transformations together. Simple transformations can be translation (offsetting), rotation, scaling, mirroring, skewing, etc.
 
 ## Drawing things <a name="simple-drawing"></a>
-**Note:** For a more complete tutorial, see [here](https://xeltalliv.github.io/simple3d-extension/examples/) (external link).
+
+> [!TIP]
+> For a more complete tutorial, see [here](https://xeltalliv.github.io/simple3d-extension/examples/) (external link).
 
 For now let's not worry about transformations and just draw something as is.
 First step would be to clear the screen:
@@ -543,7 +545,8 @@ set [my mesh] from [off v] [list v] :: sensing
 ```
 Decodes a 3D model file and uploads it into a mesh. Block continues instantly, but the model loading is performed in a separate thread, and it finishes with a delay. Currently, only one thread is used, so everything is queued and processed one by one. In the future, multiple threads might be used.
 
-**Note: This block is designed as a more of a shortcut for quick testing, rather than the main way of loading 3D models. For anything more complex make your own 3D model parser.**
+> [!IMPORTANT]
+> This block is designed as a more of a shortcut for quick testing, rather than the main way of loading 3D models. For anything more complex, make your own 3D model parser.
 
 File formats:
  - [obj](https://en.wikipedia.org/wiki/Wavefront_.obj_file) is a very common and well known 3D model file format. It supports UV texture coordinates, materials with colors and textures. However it does not have a standartized way to do vertex colors. This block implements a non-standart but widely supported way to represent vertex colors as 4th - 7th elements of `v`. The OBJ and MTL specification describes a lot of features, only some of which are currently (or even can be) supported by this importer. In particular, there is currently no way to import models which use multiple textures as this extensions only supports 1 texture per mesh. Normals and anything lighting related isn't and can't be supported. **In case both OBJ and MTL files need to be imported, combine them all into 1 list sequentially, first all of the MTL files and then the OBJ file.**
@@ -714,8 +717,11 @@ This block may cause stutter when drawing something for the first time, as it wi
 ```
 Creates texture from image at specified URL.
 Will show a prompt if URL is not approved.
-If an image fails to load, you can usually open browser console and see what the error is. (F12 or Ctrl+Shift+I)
-**Note that websites cannot access any data from any other websites unless those other sites explicetly allow it. The correct term for it is CORS (Cross Origin Resource Sharing). You can use some CORS proxy to bypass it.**
+If an image fails to load, you can usually open browser console and see what the error is (F12 or Ctrl+Shift+I).
+
+> [!WARNING]
+> Websites cannot access any data from any other websites unless those other sites explicetly allow it. The correct term for it is CORS (Cross Origin Resource Sharing). You can use some CORS proxy to bypass it.
+
 🐢 Texture gets loaded with a delay.
 
 ---
diff --git a/docs/ar.md b/docs/ar.md
index 5224b856c6..be7193e130 100644
--- a/docs/ar.md
+++ b/docs/ar.md
@@ -6,7 +6,8 @@
  - [ARCore](https://play.google.com/store/apps/details?id=com.google.ar.core) (if on Android)
  - browser with [WebXR API and immersive-ar](https://immersive-web.github.io/webxr-samples/report/) session type support
 
-At the moment of writing, only Chromium-based browsers on Android support immersive-ar session type.
+> [!WARNING]
+> At the moment of writing, only Chromium-based browsers on Android support immersive-ar session type.
 
 ## Other information
 
diff --git a/docs/box2d.md b/docs/box2d.md
index 8fe43e9cf3..9c78dfee2d 100644
--- a/docs/box2d.md
+++ b/docs/box2d.md
@@ -53,7 +53,10 @@ Make physics apply to this sprite. It can also collide with other sprites that h
  - `this circle`: Enable physics for the current sprite or clone as if it were shaped like a circle.
  - `all sprites`: Enable physics for all sprites.
 
-Precision mode will make the sprite work extra hard to make sure it doesn't overlap with anything. Note that this can decrease performance and even cause the project to get stuck, so use with care.
+Precision mode will make the sprite work extra hard to make sure it doesn't overlap with anything.
+
+> [!CAUTION]
+> Precision mode should be used with care as it can decrease performance and even cause the project to get stuck.
 
 ---
 
diff --git a/docs/godslayerakp/ws.md b/docs/godslayerakp/ws.md
index eb9600b70b..b6f5301b73 100644
--- a/docs/godslayerakp/ws.md
+++ b/docs/godslayerakp/ws.md
@@ -15,7 +15,8 @@ The URL should start with `ws://` or `wss://`. For security reasons, `ws://` URL
 
 Something simple to play with is the echo server: `wss://echoserver.redman13.repl.co`. Any message you send to it, it'll send right back to you.
 
-Note that connections are **per sprite**. Each sprite (or clone) can connect to one server at a time. Multiple sprites can connect to the same or different servers as much as your computer allows, but note those will all be separate connections.
+> [!NOTE] 
+> Connections are **per sprite**. Each sprite (or clone) can connect to one server at a time. Multiple sprites can connect to the same or different servers as much as your computer allows, but note those will all be separate connections.
 
 ---
 
diff --git a/docs/steamworks.md b/docs/steamworks.md
index 39006b0351..4b7bd062f6 100644
--- a/docs/steamworks.md
+++ b/docs/steamworks.md
@@ -27,9 +27,10 @@ You can run the packaged executable directly as usual; you don't need to start t
 
 ## Security considerations
 
-Using the Steamworks extension will not prevent people from pirating your game.
-
-The Steamworks extension is also inherently client-side, so a cheater could manipulate all of the Steamworks blocks to return whatever they want. You shouldn't use them for things that are security critical.
+> [!CAUTION]
+> **Using the Steamworks extension will not prevent people from pirating your game.**
+>
+> The Steamworks extension is also inherently client-side, so a cheater could manipulate all of the Steamworks blocks to return whatever they want. You shouldn't use them for things that are security critical.
 
 ## Demo game <a name="demo-game"></a>
 

From 4b1ec35a1c01386081011cc29331c8fcb2b173c3 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Tue, 1 Apr 2025 14:54:58 -0700
Subject: [PATCH 31/61] SharkPool/Camera: Clones should inherit camera from
 parent, add epsilon (#2057)

Requested by Cubester

![image](https://github.com/user-attachments/assets/56b31eb5-65a7-4f12-b392-c297ed3b02b8)

I also added a epsilon for float point issues and some minor
optimizations

---------

Co-authored-by: DangoCat[bot] <dangocat@users.noreply.github.com>
---
 extensions/SharkPool/Camera.js | 39 ++++++++++++++++++++++++++--------
 1 file changed, 30 insertions(+), 9 deletions(-)

diff --git a/extensions/SharkPool/Camera.js b/extensions/SharkPool/Camera.js
index 8fe9dc6a93..a57d607826 100644
--- a/extensions/SharkPool/Camera.js
+++ b/extensions/SharkPool/Camera.js
@@ -4,7 +4,7 @@
 // By: SharkPool
 // License: MIT
 
-// Version V.1.0.07
+// Version V.1.0.08
 
 (function (Scratch) {
   "use strict";
@@ -53,6 +53,10 @@
   }
 
   // camera utils
+  const radianConstant = Math.PI / 180;
+  const epsilon = 1e-12;
+  const applyEpsilon = (value) => (Math.abs(value) < epsilon ? 0 : value);
+
   function setupState(drawable) {
     drawable[cameraSymbol] = {
       name: "default",
@@ -65,23 +69,26 @@
 
   function translatePosition(xy, invert, camData) {
     if (invert) {
-      const invRads = (camData.ogDir / 180) * Math.PI;
+      const invRads = camData.ogDir * radianConstant;
       const invSin = Math.sin(invRads),
         invCos = Math.cos(invRads);
       const scaledX = xy[0] / camData.ogSZ;
       const scaledY = xy[1] / camData.ogSZ;
       const invOffX = scaledX * invCos + scaledY * invSin;
       const invOffY = -scaledX * invSin + scaledY * invCos;
-      return [invOffX - camData.ogXY[0], invOffY - camData.ogXY[1]];
+      return [
+        applyEpsilon(invOffX - camData.ogXY[0]),
+        applyEpsilon(invOffY - camData.ogXY[1]),
+      ];
     } else {
-      const rads = (camData.dir / 180) * Math.PI;
+      const rads = camData.dir * radianConstant;
       const sin = Math.sin(rads),
         cos = Math.cos(rads);
       const offX = xy[0] + camData.xy[0];
       const offY = xy[1] + camData.xy[1];
       return [
-        camData.zoom * (offX * cos - offY * sin),
-        camData.zoom * (offX * sin + offY * cos),
+        applyEpsilon(camData.zoom * (offX * cos - offY * sin)),
+        applyEpsilon(camData.zoom * (offX * sin + offY * cos)),
       ];
     }
   }
@@ -252,6 +259,20 @@
     this.skin?.emitWasAltered();
   };
 
+  // Clones should inherit the parents camera
+  const ogInitDrawable = vm.exports.RenderedTarget.prototype.initDrawable;
+  vm.exports.RenderedTarget.prototype.initDrawable = function (layerGroup) {
+    ogInitDrawable.call(this, layerGroup);
+    if (this.isOriginal) return;
+
+    const parentSprite = this.sprite.clones[0]; // clone[0] is always the original
+    const parentDrawable = render._allDrawables[parentSprite.drawableID];
+    const name = parentDrawable[cameraSymbol]?.name ?? "default";
+
+    const drawable = render._allDrawables[this.drawableID];
+    bindDrawable(drawable, name);
+  };
+
   // Turbowarp Extension Storage
   runtime.on("PROJECT_LOADED", () => {
     const stored = runtime.extensionStorage["SPcamera"];
@@ -700,10 +721,10 @@
     }
 
     translateAngledMovement(xy, steps, direction) {
-      const radians = direction * (Math.PI / 180);
+      const radians = direction * radianConstant;
       return [
-        xy[0] + steps * Math.cos(radians),
-        xy[1] + steps * Math.sin(radians),
+        applyEpsilon(xy[0] + steps * Math.cos(radians)),
+        applyEpsilon(xy[1] + steps * Math.sin(radians)),
       ];
     }
 

From 01ca2738a97ba81df1ef86716d0e8fde92cc1aa9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 7 Apr 2025 22:43:07 -0400
Subject: [PATCH 32/61] build(deps-dev): bump eslint from 9.23.0 to 9.24.0
 (#2069)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [eslint](https://github.com/eslint/eslint) from 9.23.0 to 9.24.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/eslint/eslint/releases">eslint's
releases</a>.</em></p>
<blockquote>
<h2>v9.24.0</h2>
<h2>Features</h2>
<ul>
<li><a
href="https://github.com/eslint/eslint/commit/556c25bbadd640ba9465ca6ec152f10959591666"><code>556c25b</code></a>
feat: support loading TS config files using
<code>--experimental-strip-types</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19401">#19401</a>)
(Arya Emami)</li>
<li><a
href="https://github.com/eslint/eslint/commit/72650acdb715fc25c675dc6368877b0e3f8d3885"><code>72650ac</code></a>
feat: support TS syntax in <code>init-declarations</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19540">#19540</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/03fb0bca2be41597fcea7c0e84456bbaf2e5acca"><code>03fb0bc</code></a>
feat: normalize patterns to handle &quot;./&quot; prefix in files and
ignores (<a
href="https://redirect.github.com/eslint/eslint/issues/19568">#19568</a>)
(Pixel998)</li>
<li><a
href="https://github.com/eslint/eslint/commit/071dcd3a8e34aeeb52d0b9c23c2c4a1e58b45858"><code>071dcd3</code></a>
feat: support TS syntax in <code>no-dupe-class-members</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19558">#19558</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/cd72bcc0c8d81fbf47ff3c8fe05ae48e1d862246"><code>cd72bcc</code></a>
feat: Introduce a way to suppress violations (<a
href="https://redirect.github.com/eslint/eslint/issues/19159">#19159</a>)
(Iacovos Constantinou)</li>
<li><a
href="https://github.com/eslint/eslint/commit/2a81578ac179b1eeb1484fddee31913ed99042a2"><code>2a81578</code></a>
feat: support TS syntax in <code>no-loss-of-precision</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19560">#19560</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/30ae4ed093d19e9950d09c2ab57f43d3564e31c9"><code>30ae4ed</code></a>
feat: add new options to class-methods-use-this (<a
href="https://redirect.github.com/eslint/eslint/issues/19527">#19527</a>)
(sethamus)</li>
<li><a
href="https://github.com/eslint/eslint/commit/b79ade6c1e0765457637f7ddaa52a39eed3aad38"><code>b79ade6</code></a>
feat: support TypeScript syntax in <code>no-array-constructor</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19493">#19493</a>)
(Tanuj Kanti)</li>
</ul>
<h2>Bug Fixes</h2>
<ul>
<li><a
href="https://github.com/eslint/eslint/commit/b23d1c5f0297c5e2e9a4ff70533f3c0bdbfc34b8"><code>b23d1c5</code></a>
fix: deduplicate variable names in no-loop-func error messages (<a
href="https://redirect.github.com/eslint/eslint/issues/19595">#19595</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/fb8cdb842edcc035969e14b7b7e3ee372304f2d7"><code>fb8cdb8</code></a>
fix: use <code>any[]</code> type for <code>context.options</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19584">#19584</a>)
(Francesco Trotta)</li>
</ul>
<h2>Documentation</h2>
<ul>
<li><a
href="https://github.com/eslint/eslint/commit/f8578206cc9b9fcd03dc5311f8a2d96b7b3359a5"><code>f857820</code></a>
docs: update documentation for <code>--experimental-strip-types</code>
(<a
href="https://redirect.github.com/eslint/eslint/issues/19594">#19594</a>)
(Nikolas Schröter)</li>
<li><a
href="https://github.com/eslint/eslint/commit/803e4af48e7fc3a2051e8c384f30fe4a318520e3"><code>803e4af</code></a>
docs: simplify gitignore path handling in includeIgnoreFile section (<a
href="https://redirect.github.com/eslint/eslint/issues/19596">#19596</a>)
(Thomas Broyer)</li>
<li><a
href="https://github.com/eslint/eslint/commit/6d979ccc183454e616bc82a598db5402e9d63dcf"><code>6d979cc</code></a>
docs: Update README (GitHub Actions Bot)</li>
<li><a
href="https://github.com/eslint/eslint/commit/82177e4108d6b3e63ece6072d923c0a2c08907bf"><code>82177e4</code></a>
docs: Update README (GitHub Actions Bot)</li>
<li><a
href="https://github.com/eslint/eslint/commit/e849dc01286cde5b6e2f0e04bf36928710633715"><code>e849dc0</code></a>
docs: replace existing var with const (<a
href="https://redirect.github.com/eslint/eslint/issues/19578">#19578</a>)
(Sweta Tanwar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/0c65c628022ff3ce40598c1a6ce95728e7eda317"><code>0c65c62</code></a>
docs: don't pass filename when linting rule examples (<a
href="https://redirect.github.com/eslint/eslint/issues/19571">#19571</a>)
(Milos Djermanovic)</li>
<li><a
href="https://github.com/eslint/eslint/commit/6be36c99432ecdc72e33b6fb3293cf28f66ab78d"><code>6be36c9</code></a>
docs: Update custom-rules.md code example of fixer (<a
href="https://redirect.github.com/eslint/eslint/issues/19555">#19555</a>)
(Yifan Pan)</li>
</ul>
<h2>Build Related</h2>
<ul>
<li><a
href="https://github.com/eslint/eslint/commit/366e3694afd85ab6605adf4fee4dfa1316be8b74"><code>366e369</code></a>
build: re-enable Prettier formatting for <code>package.json</code> files
(<a
href="https://redirect.github.com/eslint/eslint/issues/19569">#19569</a>)
(Francesco Trotta)</li>
</ul>
<h2>Chores</h2>
<ul>
<li><a
href="https://github.com/eslint/eslint/commit/ef6742091d49fc1809ad933f1daeff7124f57e93"><code>ef67420</code></a>
chore: upgrade <code>@​eslint/js</code><a
href="https://github.com/9"><code>@​9</code></a>.24.0 (<a
href="https://redirect.github.com/eslint/eslint/issues/19602">#19602</a>)
(Milos Djermanovic)</li>
<li><a
href="https://github.com/eslint/eslint/commit/4946847bb675ee26c3a52bfe3bca63a0dc5e5c61"><code>4946847</code></a>
chore: package.json update for <code>@​eslint/js</code> release
(Jenkins)</li>
<li><a
href="https://github.com/eslint/eslint/commit/a995acbe32471ce8c20cbf9f48b4f3e1d8bc2229"><code>a995acb</code></a>
chore: correct 'flter'/'filter' typo in package script (<a
href="https://redirect.github.com/eslint/eslint/issues/19587">#19587</a>)
(Josh Goldberg ✨)</li>
<li><a
href="https://github.com/eslint/eslint/commit/b9a5efa937046f2d3f97e6caabb67a4bc182c983"><code>b9a5efa</code></a>
test: skip symlink test on Windows (<a
href="https://redirect.github.com/eslint/eslint/issues/19503">#19503</a>)
(fisker Cheung)</li>
<li><a
href="https://github.com/eslint/eslint/commit/46eea6d1cbed41d020cb76841ebba30710b0afd0"><code>46eea6d</code></a>
chore: remove <code>Rule</code> &amp; <code>FormatterFunction</code>
from <code>shared/types.js</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19556">#19556</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/bdcc91d5b61ad1b3e55044767362548c906f5462"><code>bdcc91d</code></a>
chore: modify .editorconfig to keep parity with prettier config (<a
href="https://redirect.github.com/eslint/eslint/issues/19577">#19577</a>)
(Sweta Tanwar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/7790d8305a8cef7cc95c331205d59d6b3c2b4e2e"><code>7790d83</code></a>
chore: fix some typos in comment (<a
href="https://redirect.github.com/eslint/eslint/issues/19576">#19576</a>)
(todaymoon)</li>
<li><a
href="https://github.com/eslint/eslint/commit/76064a632438533bbb90e253ec72d172e948d200"><code>76064a6</code></a>
test: ignore <code>package-lock.json</code> for
<code>eslint-webpack-plugin</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19572">#19572</a>)
(Francesco Trotta)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a
href="https://github.com/eslint/eslint/blob/main/CHANGELOG.md">eslint's
changelog</a>.</em></p>
<blockquote>
<p>v9.24.0 - April 4, 2025</p>
<ul>
<li><a
href="https://github.com/eslint/eslint/commit/ef6742091d49fc1809ad933f1daeff7124f57e93"><code>ef67420</code></a>
chore: upgrade <code>@​eslint/js</code><a
href="https://github.com/9"><code>@​9</code></a>.24.0 (<a
href="https://redirect.github.com/eslint/eslint/issues/19602">#19602</a>)
(Milos Djermanovic)</li>
<li><a
href="https://github.com/eslint/eslint/commit/4946847bb675ee26c3a52bfe3bca63a0dc5e5c61"><code>4946847</code></a>
chore: package.json update for <code>@​eslint/js</code> release
(Jenkins)</li>
<li><a
href="https://github.com/eslint/eslint/commit/f8578206cc9b9fcd03dc5311f8a2d96b7b3359a5"><code>f857820</code></a>
docs: update documentation for <code>--experimental-strip-types</code>
(<a
href="https://redirect.github.com/eslint/eslint/issues/19594">#19594</a>)
(Nikolas Schröter)</li>
<li><a
href="https://github.com/eslint/eslint/commit/803e4af48e7fc3a2051e8c384f30fe4a318520e3"><code>803e4af</code></a>
docs: simplify gitignore path handling in includeIgnoreFile section (<a
href="https://redirect.github.com/eslint/eslint/issues/19596">#19596</a>)
(Thomas Broyer)</li>
<li><a
href="https://github.com/eslint/eslint/commit/6d979ccc183454e616bc82a598db5402e9d63dcf"><code>6d979cc</code></a>
docs: Update README (GitHub Actions Bot)</li>
<li><a
href="https://github.com/eslint/eslint/commit/b23d1c5f0297c5e2e9a4ff70533f3c0bdbfc34b8"><code>b23d1c5</code></a>
fix: deduplicate variable names in no-loop-func error messages (<a
href="https://redirect.github.com/eslint/eslint/issues/19595">#19595</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/556c25bbadd640ba9465ca6ec152f10959591666"><code>556c25b</code></a>
feat: support loading TS config files using
<code>--experimental-strip-types</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19401">#19401</a>)
(Arya Emami)</li>
<li><a
href="https://github.com/eslint/eslint/commit/82177e4108d6b3e63ece6072d923c0a2c08907bf"><code>82177e4</code></a>
docs: Update README (GitHub Actions Bot)</li>
<li><a
href="https://github.com/eslint/eslint/commit/a995acbe32471ce8c20cbf9f48b4f3e1d8bc2229"><code>a995acb</code></a>
chore: correct 'flter'/'filter' typo in package script (<a
href="https://redirect.github.com/eslint/eslint/issues/19587">#19587</a>)
(Josh Goldberg ✨)</li>
<li><a
href="https://github.com/eslint/eslint/commit/72650acdb715fc25c675dc6368877b0e3f8d3885"><code>72650ac</code></a>
feat: support TS syntax in <code>init-declarations</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19540">#19540</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/03fb0bca2be41597fcea7c0e84456bbaf2e5acca"><code>03fb0bc</code></a>
feat: normalize patterns to handle &quot;./&quot; prefix in files and
ignores (<a
href="https://redirect.github.com/eslint/eslint/issues/19568">#19568</a>)
(Pixel998)</li>
<li><a
href="https://github.com/eslint/eslint/commit/b9a5efa937046f2d3f97e6caabb67a4bc182c983"><code>b9a5efa</code></a>
test: skip symlink test on Windows (<a
href="https://redirect.github.com/eslint/eslint/issues/19503">#19503</a>)
(fisker Cheung)</li>
<li><a
href="https://github.com/eslint/eslint/commit/46eea6d1cbed41d020cb76841ebba30710b0afd0"><code>46eea6d</code></a>
chore: remove <code>Rule</code> &amp; <code>FormatterFunction</code>
from <code>shared/types.js</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19556">#19556</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/fb8cdb842edcc035969e14b7b7e3ee372304f2d7"><code>fb8cdb8</code></a>
fix: use <code>any[]</code> type for <code>context.options</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19584">#19584</a>)
(Francesco Trotta)</li>
<li><a
href="https://github.com/eslint/eslint/commit/071dcd3a8e34aeeb52d0b9c23c2c4a1e58b45858"><code>071dcd3</code></a>
feat: support TS syntax in <code>no-dupe-class-members</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19558">#19558</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/e849dc01286cde5b6e2f0e04bf36928710633715"><code>e849dc0</code></a>
docs: replace existing var with const (<a
href="https://redirect.github.com/eslint/eslint/issues/19578">#19578</a>)
(Sweta Tanwar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/bdcc91d5b61ad1b3e55044767362548c906f5462"><code>bdcc91d</code></a>
chore: modify .editorconfig to keep parity with prettier config (<a
href="https://redirect.github.com/eslint/eslint/issues/19577">#19577</a>)
(Sweta Tanwar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/7790d8305a8cef7cc95c331205d59d6b3c2b4e2e"><code>7790d83</code></a>
chore: fix some typos in comment (<a
href="https://redirect.github.com/eslint/eslint/issues/19576">#19576</a>)
(todaymoon)</li>
<li><a
href="https://github.com/eslint/eslint/commit/cd72bcc0c8d81fbf47ff3c8fe05ae48e1d862246"><code>cd72bcc</code></a>
feat: Introduce a way to suppress violations (<a
href="https://redirect.github.com/eslint/eslint/issues/19159">#19159</a>)
(Iacovos Constantinou)</li>
<li><a
href="https://github.com/eslint/eslint/commit/2a81578ac179b1eeb1484fddee31913ed99042a2"><code>2a81578</code></a>
feat: support TS syntax in <code>no-loss-of-precision</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19560">#19560</a>)
(Nitin Kumar)</li>
<li><a
href="https://github.com/eslint/eslint/commit/366e3694afd85ab6605adf4fee4dfa1316be8b74"><code>366e369</code></a>
build: re-enable Prettier formatting for <code>package.json</code> files
(<a
href="https://redirect.github.com/eslint/eslint/issues/19569">#19569</a>)
(Francesco Trotta)</li>
<li><a
href="https://github.com/eslint/eslint/commit/30ae4ed093d19e9950d09c2ab57f43d3564e31c9"><code>30ae4ed</code></a>
feat: add new options to class-methods-use-this (<a
href="https://redirect.github.com/eslint/eslint/issues/19527">#19527</a>)
(sethamus)</li>
<li><a
href="https://github.com/eslint/eslint/commit/b79ade6c1e0765457637f7ddaa52a39eed3aad38"><code>b79ade6</code></a>
feat: support TypeScript syntax in <code>no-array-constructor</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19493">#19493</a>)
(Tanuj Kanti)</li>
<li><a
href="https://github.com/eslint/eslint/commit/0c65c628022ff3ce40598c1a6ce95728e7eda317"><code>0c65c62</code></a>
docs: don't pass filename when linting rule examples (<a
href="https://redirect.github.com/eslint/eslint/issues/19571">#19571</a>)
(Milos Djermanovic)</li>
<li><a
href="https://github.com/eslint/eslint/commit/76064a632438533bbb90e253ec72d172e948d200"><code>76064a6</code></a>
test: ignore <code>package-lock.json</code> for
<code>eslint-webpack-plugin</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19572">#19572</a>)
(Francesco Trotta)</li>
<li><a
href="https://github.com/eslint/eslint/commit/6be36c99432ecdc72e33b6fb3293cf28f66ab78d"><code>6be36c9</code></a>
docs: Update custom-rules.md code example of fixer (<a
href="https://redirect.github.com/eslint/eslint/issues/19555">#19555</a>)
(Yifan Pan)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/eslint/eslint/commit/d49f5b7333e9a46aabdb0cff267a1d36cdbde598"><code>d49f5b7</code></a>
9.24.0</li>
<li><a
href="https://github.com/eslint/eslint/commit/9b6ed8a57aa7ec558d6a8a0aca263053fc878eb1"><code>9b6ed8a</code></a>
Build: changelog update for 9.24.0</li>
<li><a
href="https://github.com/eslint/eslint/commit/ef6742091d49fc1809ad933f1daeff7124f57e93"><code>ef67420</code></a>
chore: upgrade <code>@​eslint/js</code><a
href="https://github.com/9"><code>@​9</code></a>.24.0 (<a
href="https://redirect.github.com/eslint/eslint/issues/19602">#19602</a>)</li>
<li><a
href="https://github.com/eslint/eslint/commit/4946847bb675ee26c3a52bfe3bca63a0dc5e5c61"><code>4946847</code></a>
chore: package.json update for <code>@​eslint/js</code> release</li>
<li><a
href="https://github.com/eslint/eslint/commit/f8578206cc9b9fcd03dc5311f8a2d96b7b3359a5"><code>f857820</code></a>
docs: update documentation for <code>--experimental-strip-types</code>
(<a
href="https://redirect.github.com/eslint/eslint/issues/19594">#19594</a>)</li>
<li><a
href="https://github.com/eslint/eslint/commit/803e4af48e7fc3a2051e8c384f30fe4a318520e3"><code>803e4af</code></a>
docs: simplify gitignore path handling in includeIgnoreFile section (<a
href="https://redirect.github.com/eslint/eslint/issues/19596">#19596</a>)</li>
<li><a
href="https://github.com/eslint/eslint/commit/6d979ccc183454e616bc82a598db5402e9d63dcf"><code>6d979cc</code></a>
docs: Update README</li>
<li><a
href="https://github.com/eslint/eslint/commit/b23d1c5f0297c5e2e9a4ff70533f3c0bdbfc34b8"><code>b23d1c5</code></a>
fix: deduplicate variable names in no-loop-func error messages (<a
href="https://redirect.github.com/eslint/eslint/issues/19595">#19595</a>)</li>
<li><a
href="https://github.com/eslint/eslint/commit/556c25bbadd640ba9465ca6ec152f10959591666"><code>556c25b</code></a>
feat: support loading TS config files using
<code>--experimental-strip-types</code> (<a
href="https://redirect.github.com/eslint/eslint/issues/19">#19</a>...</li>
<li><a
href="https://github.com/eslint/eslint/commit/82177e4108d6b3e63ece6072d923c0a2c08907bf"><code>82177e4</code></a>
docs: Update README</li>
<li>Additional commits viewable in <a
href="https://github.com/eslint/eslint/compare/v9.23.0...v9.24.0">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=eslint&package-manager=npm_and_yarn&previous-version=9.23.0&new-version=9.24.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 package-lock.json | 24 ++++++++++++------------
 package.json      |  2 +-
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e170f92abb..757ccefe40 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -21,7 +21,7 @@
       },
       "devDependencies": {
         "@transifex/api": "^7.1.3",
-        "eslint": "^9.23.0",
+        "eslint": "^9.24.0",
         "espree": "^9.6.1",
         "esquery": "^1.6.0",
         "prettier": "^3.5.3",
@@ -62,9 +62,9 @@
       }
     },
     "node_modules/@eslint/config-array": {
-      "version": "0.19.2",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.19.2.tgz",
-      "integrity": "sha512-GNKqxfHG2ySmJOBSHg7LxeUx4xpuCoFjacmlCoYWEbaPXLwvfIjixRI12xCQZeULksQb23uiA8F40w5TojpV7w==",
+      "version": "0.20.0",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.20.0.tgz",
+      "integrity": "sha512-fxlS1kkIjx8+vy2SjuCB94q3htSNrufYTXubwiBFeaQHbH6Ipi43gFJq2zCMt6PHhImH3Xmr0NksKDvchWlpQQ==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -155,9 +155,9 @@
       }
     },
     "node_modules/@eslint/js": {
-      "version": "9.23.0",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.23.0.tgz",
-      "integrity": "sha512-35MJ8vCPU0ZMxo7zfev2pypqTwWTofFZO6m4KAtdoFhRpLJUpHTZZ+KB3C7Hb1d7bULYwO4lJXGCi5Se+8OMbw==",
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.24.0.tgz",
+      "integrity": "sha512-uIY/y3z0uvOGX8cp1C2fiC4+ZmBhp6yZWkojtHL1YEMnRt1Y63HB9TM17proGEmeG7HeUY+UP36F0aknKYTpYA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -706,19 +706,19 @@
       }
     },
     "node_modules/eslint": {
-      "version": "9.23.0",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.23.0.tgz",
-      "integrity": "sha512-jV7AbNoFPAY1EkFYpLq5bslU9NLNO8xnEeQXwErNibVryjk67wHVmddTBilc5srIttJDBrB0eMHKZBFbSIABCw==",
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.24.0.tgz",
+      "integrity": "sha512-eh/jxIEJyZrvbWRe4XuVclLPDYSYYYgLy5zXGGxD6j8zjSAxFEzI2fL/8xNq6O2yKqVt+eF2YhV+hxjV6UKXwQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.12.1",
-        "@eslint/config-array": "^0.19.2",
+        "@eslint/config-array": "^0.20.0",
         "@eslint/config-helpers": "^0.2.0",
         "@eslint/core": "^0.12.0",
         "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "9.23.0",
+        "@eslint/js": "9.24.0",
         "@eslint/plugin-kit": "^0.2.7",
         "@humanfs/node": "^0.16.6",
         "@humanwhocodes/module-importer": "^1.0.1",
diff --git a/package.json b/package.json
index 8bd0473084..1a5445f1a4 100644
--- a/package.json
+++ b/package.json
@@ -38,7 +38,7 @@
   },
   "devDependencies": {
     "@transifex/api": "^7.1.3",
-    "eslint": "^9.23.0",
+    "eslint": "^9.24.0",
     "espree": "^9.6.1",
     "esquery": "^1.6.0",
     "prettier": "^3.5.3",

From 6085feb311cbb0a4037e43ab5a8b055bd161002c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 7 Apr 2025 22:47:12 -0400
Subject: [PATCH 33/61] build(deps): bump image-size from 2.0.1 to 2.0.2
 (#2068)

Bumps [image-size](https://github.com/image-size/image-size) from 2.0.1
to 2.0.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/image-size/image-size/releases">image-size's
releases</a>.</em></p>
<blockquote>
<h2>v2.0.2</h2>
<h2>Fixes</h2>
<ul>
<li>fix potential Denial of Service via specially crafted payloads in <a
href="https://redirect.github.com/image-size/image-size/pull/436">image-size/image-size#436</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/image-size/image-size/compare/v2.0.1...v2.0.2">https://github.com/image-size/image-size/compare/v2.0.1...v2.0.2</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/image-size/image-size/commit/032c3347b86f09a2e16449e17537cf5e1009520c"><code>032c334</code></a>
2.0.2</li>
<li><a
href="https://github.com/image-size/image-size/commit/8994131c7c3ee8da1699e04700c95e0e683a0c68"><code>8994131</code></a>
fix potential Denial of Service via specially crafted payloads (<a
href="https://redirect.github.com/image-size/image-size/issues/436">#436</a>)</li>
<li><a
href="https://github.com/image-size/image-size/commit/e62c61f1c58126310e9d7faac1b2e7ad1de9ea82"><code>e62c61f</code></a>
delete the part about partial downloading</li>
<li>See full diff in <a
href="https://github.com/image-size/image-size/compare/v2.0.1...v2.0.2">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=image-size&package-manager=npm_and_yarn&previous-version=2.0.1&new-version=2.0.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 package-lock.json | 8 ++++----
 package.json      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 757ccefe40..74562f46c4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,7 +16,7 @@
         "chokidar": "^4.0.3",
         "ejs": "^3.1.10",
         "express": "^4.21.2",
-        "image-size": "^2.0.1",
+        "image-size": "^2.0.2",
         "markdown-it": "^14.1.0"
       },
       "devDependencies": {
@@ -1241,9 +1241,9 @@
       }
     },
     "node_modules/image-size": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/image-size/-/image-size-2.0.1.tgz",
-      "integrity": "sha512-NI6NK/2zchlZopsQrcVIS7jxA0/rtIy74B+/rx5s7rKQyFebmQjZVhzxXgRZJROk+WhhOq+S6sUaODxp0L5hfg==",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/image-size/-/image-size-2.0.2.tgz",
+      "integrity": "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w==",
       "license": "MIT",
       "bin": {
         "image-size": "bin/image-size.js"
diff --git a/package.json b/package.json
index 1a5445f1a4..fa0d5c9eeb 100644
--- a/package.json
+++ b/package.json
@@ -33,7 +33,7 @@
     "chokidar": "^4.0.3",
     "ejs": "^3.1.10",
     "express": "^4.21.2",
-    "image-size": "^2.0.1",
+    "image-size": "^2.0.2",
     "markdown-it": "^14.1.0"
   },
   "devDependencies": {

From 5703354f6fba7ebcd1d0045705aa4c792ff0142d Mon Sep 17 00:00:00 2001
From: Dango Cat <dangocat@muffin.ink>
Date: Sat, 12 Apr 2025 09:34:06 -0500
Subject: [PATCH 34/61] [Automated] Update translations 2025-04-12 (#2078)

This pull request was made by a robot.

Co-authored-by: DangoCat[bot] <dangocat@users.noreply.github.com>
---
 translations/extension-metadata.json |  2 +
 translations/extension-runtime.json  | 60 ++++++++++++++++++++++++++--
 2 files changed, 59 insertions(+), 3 deletions(-)

diff --git a/translations/extension-metadata.json b/translations/extension-metadata.json
index 0da75cfc3f..0c923a1c9b 100644
--- a/translations/extension-metadata.json
+++ b/translations/extension-metadata.json
@@ -1280,6 +1280,7 @@
         "DNin/wake-lock@description": "Предотвратите переход компьютера в спящий режим.",
         "DNin/wake-lock@name": "Антисон",
         "DT/cameracontrols@description": "Переместите видимую часть сцены.",
+        "DT/cameracontrols@name": "Камера V1",
         "JeremyGamer13/tween@description": "Упрощенные методы для плавной анимации.",
         "JeremyGamer13/tween@name": "Плавность",
         "Lily/AllMenus@description": "Специальная категория с каждым меню из каждой Scratch категории и расширениями.",
@@ -1328,6 +1329,7 @@
         "PwLDev/vibration@description": "Контролируйте вибрацию устройства. Работает только в Chrome для Android.",
         "PwLDev/vibration@name": "Вибрация",
         "SharkPool/Camera@description": "Переместите видимую часть сцены.",
+        "SharkPool/Camera@name": "Камера V2",
         "SharkPool/Font-Manager@description": "Добавляйте, удаляйте, и управляйте шрифтами.",
         "SharkPool/Font-Manager@name": "Менеджер Шрифтов",
         "Skyhigh173/bigint@description": "Математические блоки, которые работают с бесконечно большими целыми числами (без десятичных).",
diff --git a/translations/extension-runtime.json b/translations/extension-runtime.json
index ab5dafd058..23a5ef6ef0 100644
--- a/translations/extension-runtime.json
+++ b/translations/extension-runtime.json
@@ -8270,6 +8270,8 @@
         "CubesterYT/KeySimulation@_Key Simulation": "Симуляция Клавиш",
         "CubesterYT/KeySimulation@_backspace": "задний пробел",
         "CubesterYT/KeySimulation@_caps lock": "лок КАПСА",
+        "CubesterYT/KeySimulation@_click [BUTTON] mouse button at x: [X] y: [Y] for [SECONDS] seconds and [AND_WAIT]": "нажать [BUTTON] кнопку мыши на x: [X] y: [Y] на [SECONDS] секунд и [AND_WAIT]",
+        "CubesterYT/KeySimulation@_continue": "продолжить",
         "CubesterYT/KeySimulation@_control": "контрол",
         "CubesterYT/KeySimulation@_delete": "удалить",
         "CubesterYT/KeySimulation@_down arrow": "стрелка вниз",
@@ -8284,12 +8286,14 @@
         "CubesterYT/KeySimulation@_move mouse to x: [X] y: [Y]": "переместить мышь в x: [X] y: [Y]",
         "CubesterYT/KeySimulation@_page down": "страница вниз",
         "CubesterYT/KeySimulation@_page up": "страница вверх",
+        "CubesterYT/KeySimulation@_press [KEY] for [SECONDS] seconds and [AND_WAIT]": "нажать [KEY] на [SECONDS] секунд и [AND_WAIT]",
         "CubesterYT/KeySimulation@_right": "правому краю",
         "CubesterYT/KeySimulation@_right arrow": "стрелка направо",
         "CubesterYT/KeySimulation@_scroll lock": "лок кручения",
         "CubesterYT/KeySimulation@_shift": "шифт",
         "CubesterYT/KeySimulation@_space": "пробле",
         "CubesterYT/KeySimulation@_up arrow": "стрелка вверх",
+        "CubesterYT/KeySimulation@_wait": "подождать",
         "CubesterYT/TurboHook@_content": "контент",
         "CubesterYT/TurboHook@_icon": "иконка",
         "CubesterYT/TurboHook@_name": "имя",
@@ -8341,6 +8345,7 @@
         "DNin/wake-lock@_off": "выключить",
         "DNin/wake-lock@_on": "включить",
         "DNin/wake-lock@_turn wake lock [enabled]": "включить режим антисна [enabled]",
+        "DT/cameracontrols@_Camera V1": "Камера V1",
         "DT/cameracontrols@_background color": "цвет заднего фона",
         "DT/cameracontrols@_camera direction": "направление камеры",
         "DT/cameracontrols@_camera x": "x камеры",
@@ -8349,13 +8354,13 @@
         "DT/cameracontrols@_change camera x by [val]": "изменить x камеры на [val]",
         "DT/cameracontrols@_change camera y by [val]": "изменить y камеры на [val]",
         "DT/cameracontrols@_change camera zoom by [val]": "изменить приближение камеры на [val]",
-        "DT/cameracontrols@_move camera [val] steps": "пойти камеру на [val] шагов",
-        "DT/cameracontrols@_move camera to [sprite]": "двинуть камеру на [sprite]",
+        "DT/cameracontrols@_move camera [val] steps": "камерой идти [val] шагов",
+        "DT/cameracontrols@_move camera to [sprite]": "переместить камеру на [sprite]",
         "DT/cameracontrols@_no sprites exist": "никаких спрайтов не существует",
         "DT/cameracontrols@_point camera towards [sprite]": "навести камеру на [sprite]",
         "DT/cameracontrols@_set background color to [val]": "задать цвет заднего фона на [val]",
         "DT/cameracontrols@_set camera direction to [val]": "задать направление камеры на [val]",
-        "DT/cameracontrols@_set camera to x: [x] y: [y]": "задать позиции камеры на x: [x] y: [y]",
+        "DT/cameracontrols@_set camera to x: [x] y: [y]": "задать позицию камеры на x: [x] y: [y]",
         "DT/cameracontrols@_set camera x to [val]": "задать x камеры на [val]",
         "DT/cameracontrols@_set camera y to [val]": "задать y камеры на [val]",
         "DT/cameracontrols@_set camera zoom to [val] %": "задать приближение камены в [val]%",
@@ -8410,11 +8415,13 @@
         "Lily/Assets@_name of sound # [INDEX]": "имя звука # [INDEX]",
         "Lily/Assets@_open project from URL [URL]": "открыть проект из URL-адреса [URL]",
         "Lily/Assets@_project JSON": "JSON проекта",
+        "Lily/Assets@_project [EXPORT]": "проект [EXPORT]",
         "Lily/Assets@_rename costume [COSTUME] to [NAME]": "переименовать костюм [COSTUME] в [NAME]",
         "Lily/Assets@_rename sound [SOUND] to [NAME]": "переименовать звук [SOUND] в [NAME]",
         "Lily/Assets@_rename sprite [TARGET] to [NAME]": "переименовать спрайт [TARGET] в [NAME]",
         "Lily/Assets@_reorder costume # [INDEX1] to index [INDEX2]": "пересортировать костюм # [INDEX1] в индекс [INDEX2]",
         "Lily/Assets@_reorder sound # [INDEX1] to index [INDEX2]": "пересортировать звук # [INDEX1] в индекс [INDEX2]",
+        "Lily/Assets@_sprite [EXPORT]": "спрайт [EXPORT]",
         "Lily/Assets@_sprite name": "имя спрайта",
         "Lily/Cast@_Cast": "Каст",
         "Lily/Cast@_boolean": "логическое",
@@ -8781,10 +8788,47 @@
         "PwLDev/vibration@_play vibration pattern [PATTERN]": "играть вибрацию с последовательностью [PATTERN]",
         "PwLDev/vibration@_start vibrating for [SECONDS] seconds": "начать вибрацию на [SECONDS] секунд",
         "PwLDev/vibration@_stop vibrating": "остановить вибрацию",
+        "SharkPool/Camera@_Add Camera": "Добавить Камеру",
+        "SharkPool/Camera@_Camera Controls": "Контроль Камеры",
+        "SharkPool/Camera@_Camera Manager": "Менеджер Камеры",
+        "SharkPool/Camera@_Camera V2": "Камера V2",
+        "SharkPool/Camera@_New Camera name:": "Новое имя Камеры:",
+        "SharkPool/Camera@_Remove Camera": "Удалить Камеру",
+        "SharkPool/Camera@_Remove Camera named:": "Имя Удалённой Камеры:",
         "SharkPool/Camera@_Stage": "Сцена",
+        "SharkPool/Camera@_Utility": "Утилита",
+        "SharkPool/Camera@_[CAMERA] camera direction": "направление камеры [CAMERA]",
+        "SharkPool/Camera@_[CAMERA] camera x": "x камеры [CAMERA]",
+        "SharkPool/Camera@_[CAMERA] camera y": "y камеры [CAMERA]",
+        "SharkPool/Camera@_[CAMERA] camera zoom": "приближение камеры [CAMERA]",
+        "SharkPool/Camera@_all objects": "все объекты",
         "SharkPool/Camera@_background color": "цвет заднего фона",
+        "SharkPool/Camera@_bind": "привязка",
+        "SharkPool/Camera@_bind [TARGET] to camera [CAMERA]": "привязать [TARGET] на камеру [CAMERA]",
+        "SharkPool/Camera@_camera of [TARGET]": "камера [TARGET]",
+        "SharkPool/Camera@_change [CAMERA] camera x by [NUM]": "изменить x камеры [CAMERA] на [NUM]",
+        "SharkPool/Camera@_change [CAMERA] camera y by [NUM]": "изменить y камеры [CAMERA] на [NUM]",
+        "SharkPool/Camera@_change [CAMERA] camera zoom by [NUM]": "изменить приближение камеры [CAMERA] на [NUM]",
         "SharkPool/Camera@_default": "по умолчанию",
+        "SharkPool/Camera@_mouse x in camera [CAMERA]": "x курсора мыши в камере [CAMERA]",
+        "SharkPool/Camera@_mouse y in camera [CAMERA]": "y курсора мыши в камере [CAMERA]",
+        "SharkPool/Camera@_move [CAMERA] camera [NUM] steps": "идти камерой [CAMERA] на [NUM] шагов",
+        "SharkPool/Camera@_move [CAMERA] camera to [TARGET]": "переместить камеру [CAMERA] на [TARGET]",
         "SharkPool/Camera@_myself": "самого себя",
+        "SharkPool/Camera@_pen layer": "слой ручки",
+        "SharkPool/Camera@_point [CAMERA] camera towards [TARGET]": "указать камеру [CAMERA] на [TARGET]",
+        "SharkPool/Camera@_rendered x position of [TARGET]": "визуализированная позиция x из [TARGET]",
+        "SharkPool/Camera@_rendered y position of [TARGET]": "визуализированная позиция y из [TARGET]",
+        "SharkPool/Camera@_set [CAMERA] camera direction to [NUM]": "задать направление камеры [CAMERA] на [NUM]",
+        "SharkPool/Camera@_set [CAMERA] camera to x: [X] y: [Y]": "задать камеру [CAMERA] на x: [X] y: [Y]",
+        "SharkPool/Camera@_set [CAMERA] camera x to [NUM]": "задать x камеры [CAMERA] на [NUM]",
+        "SharkPool/Camera@_set [CAMERA] camera y to [NUM]": "задать y камеры [CAMERA] на [NUM]",
+        "SharkPool/Camera@_set [CAMERA] camera zoom to [NUM]%": "задать приближение камеры [CAMERA] на [NUM]%",
+        "SharkPool/Camera@_set background color to [COLOR]": "задать цвет заднего фона на [COLOR]",
+        "SharkPool/Camera@_turn [CAMERA] camera [IMG] [NUM] degrees": "повернуть камеру [CAMERA] [IMG] на [NUM] градусов",
+        "SharkPool/Camera@_unbind": "отвязать",
+        "SharkPool/Camera@_unbind [TARGET] from camera [CAMERA]": "отвязать [TARGET] с камеры [CAMERA]",
+        "SharkPool/Camera@_video layer": "слой видео",
         "SharkPool/Font-Manager@_Font Manager": "Менеджер Шрифтов",
         "SharkPool/Font-Manager@_[ADDED] fonts": "[ADDED] шрифты",
         "SharkPool/Font-Manager@_[DATA] of font [NAME]": "[DATA] шрифта [NAME]",
@@ -8815,6 +8859,7 @@
         "Skyhigh173/json@_General Utils": "Главные Утилиты",
         "Skyhigh173/json@_Lists": "Списки",
         "Skyhigh173/json@_Object": "Объект",
+        "Skyhigh173/json@_[analysis] of array [list]": "[analysis] массива [list]",
         "Skyhigh173/json@_[json] contains key [key]?": "[json] содержит ключ [key]?",
         "Skyhigh173/json@_[json] contains value [value]?": "[json] содержит значение [value]?",
         "Skyhigh173/json@_add [item] to array [json]": "добавить [item] к массиву [json]",
@@ -8822,6 +8867,7 @@
         "Skyhigh173/json@_array concat [json] [json2]": "соединить массив [json] и [json2]",
         "Skyhigh173/json@_array from text [json]": "массив из текста [json]",
         "Skyhigh173/json@_ascending": "нарастающей",
+        "Skyhigh173/json@_average": "среднее",
         "Skyhigh173/json@_create array by [text] with delimiter [d]": "создать массив из [text] с разделителем [d]",
         "Skyhigh173/json@_datas": "данные",
         "Skyhigh173/json@_delete [item] in [json]": "удалить [item] из [json]",
@@ -8841,6 +8887,10 @@
         "Skyhigh173/json@_keys": "ключи",
         "Skyhigh173/json@_length of array [json]": "длина массива [json]",
         "Skyhigh173/json@_length of json [json]": "длина json [json]",
+        "Skyhigh173/json@_maximum value": "максимальное значение",
+        "Skyhigh173/json@_median": "медиан",
+        "Skyhigh173/json@_minimum value": "минимальное значение",
+        "Skyhigh173/json@_mode": "режим",
         "Skyhigh173/json@_new [json]": "новый [json]",
         "Skyhigh173/json@_replace item [pos] of [json] with [item]": "заменить число [pos] матрицы [json] на [item]",
         "Skyhigh173/json@_reverse array [json]": "обернуть массив [json]",
@@ -8849,8 +8899,10 @@
         "Skyhigh173/json@_set length of array [json] to [len]": "задать длину массива [json] на [len]",
         "Skyhigh173/json@_set list [list] to [json]": "задать список [list] в [json]",
         "Skyhigh173/json@_sort array [list] in [order] order": "сортировать массив [list] в порядке [order]",
+        "Skyhigh173/json@_sum": "сумма",
         "Skyhigh173/json@_value of [item] in [json]": "значение [item] в [json]",
         "Skyhigh173/json@_values": "значения",
+        "Skyhigh173/json@_variance": "расхождение",
         "TheShovel/CanvasEffects@_Canvas Effects": "Canvas Эффекты",
         "TheShovel/CanvasEffects@_background": "задний фон",
         "TheShovel/CanvasEffects@_blur": "блюр",
@@ -9938,6 +9990,8 @@
         "true-fantom/math@_is safe number [A]?": "[A] безопасное число?",
         "true-fantom/math@_log of [A] with base [B]": "логарифм [A] с основанием [B]",
         "true-fantom/math@_map [A] from range [m1] - [M1] to range [m2] - [M2]": "карта [A] из расстояния [m1] - [M1] до расстояния [m2] - [M2]",
+        "true-fantom/math@_sign of [A]": "знак [A]",
+        "true-fantom/math@_true [OPERATOR] [NUM]": "правда [OPERATOR] [NUM] ",
         "true-fantom/math@_trunc of [A]": "усечение [A]",
         "true-fantom/math@_trunc of [A] with [B] digits after dot": "усечение [A] с [B] цифрами после точки",
         "true-fantom/network@_(1) text": "(1) текст",

From afb763cc680f1fda293bcea6978922aecf7f07e2 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Wed, 5 Mar 2025 12:12:00 -0500
Subject: [PATCH 35/61] Add midi extension

Added midi extension for input/output of midi using the WebMidi API. Still pending documentation and peer-review
---
 extensions/midi/midi.js | 1884 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 1884 insertions(+)
 create mode 100644 extensions/midi/midi.js

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
new file mode 100644
index 0000000000..dbec4a46c6
--- /dev/null
+++ b/extensions/midi/midi.js
@@ -0,0 +1,1884 @@
+// Name: MIDI
+// ID: extmidi
+// Description: An extension to use the WebMidi API for midi input/output.
+// License: MPL-2.0
+
+(function (Scratch) {
+  "use strict";
+
+  if (!Scratch.extensions.unsandboxed) {
+    throw new Error("Midi must be run unsandboxed");
+  }
+
+  const EXT_ID = "extmidi";
+
+  /** 
+   * This section includes logic to map raw data coming from the 'midimessage'
+   * event into a friendly object representation of the event
+   * 
+   * 
+   * // definition for the parsed midi event
+   * @typedef {keyof typeof eventMapping} EventType
+   * @typedef {object} MidiEvent
+   * @property {EventType | 'rest'} type
+   * @property {number} [value1]
+   * @property {number} [value2]
+   * @property {number} [channel]
+   * @property {number} [device]
+   * @property {number} [time]
+   * @property {number} [pitch]
+   * @property {number} [velocity]
+   * @property {number} [cc]
+   * @property {number} [value]
+   * @property {number} [pos]
+   * @property {number} [dur]
+   * @property {string} [_str]
+   * 
+   * 
+   * @typedef {object} FormatOptions
+   * @property {number} [tempo]
+   * @property {boolean} [useFlats]
+   * @property {boolean} [noMinify]
+   * @property {'omit' | 'timestamp' | 'absolute'} [timestampFormat]
+   * @property {number} [startTimestamp]
+   * @property {boolean} [fixedWidth]
+   * @property {boolean} [useHex]
+   * @property {number} [defaultOctave]
+   */
+
+  /**
+   * MIDI commands with code, name, and parameters
+   * From: https://ccrma.stanford.edu/~craig/articles/linuxmidi/misc/essenmidi.html
+   * https://www.midi.org/specifications/item/table-1-summary-of-midi-message
+   *
+   * adapted from https://github.com/fheyen/musicvis-lib/blob/905edbdc8280e8ca76a329ffc83a160f3cda674a/src/fileFormats/Midi.js#L41
+   * 
+   * each key (the "EventType" relates to a raw midi "command". The "shorthand" could
+   * be used to format midi events to string (future). param1 and param2 determine what property of the object the value1 + value2 bytes mean (i.e. noteOn gets pitch + velocity, cc gets cc# and value)
+   */
+  const SHARPS = "C C# D D# E F F# G G# A A# B".split(" ");
+  const FLATS = "C Db D Eb E F Gb G Ab A Bb B".split(" ");
+  function midiPitchToNoteName(midi, { useFlats = false, fixedWidth = false } = {}) {
+    if (!isFinite(midi)) return "";
+    let chroma = (useFlats ? FLATS : SHARPS)[midi % 12];
+    if (fixedWidth) chroma = chroma.padEnd(2, "_");
+    const octave = Math.floor(midi / 12) - 1;
+    return `${chroma}${octave}`;
+  }
+  /**
+   * convert a note string name (or raw midi number) to midi number value
+   * @param {string} note 
+   * @param {number} [defaultOctave] 
+   * @returns {number | null}
+   */
+  function noteNameToMidiPitch(note, defaultOctave = 4) {
+    const parts = /(?<pitch>[A-G])(?<flat>[b♭]+)?(?<sharp>[#♯]+)?_?(?<octave>-?\d+)?/i.exec(note || '');
+    if (!parts?.groups) {
+      const numVal = typeof note === 'string' ? parseInt(note.trim(), 10) : +note;
+      return (numVal >= 0 && numVal <= 127) ? numVal : null;
+    }
+    const { pitch, octave, flat, sharp } = parts.groups;
+    let chroma = SHARPS.indexOf(pitch.toUpperCase()) - (flat?.length || 0) + (sharp?.length || 0);
+    const height = octave ? parseInt(octave, 10) : defaultOctave;
+    return chroma + ((height + 1) * 12);
+  }
+  function parseNumValue(text, defaultValue, opts) {
+    if (!text) return defaultValue;
+    text = text.trim();
+    const useHex = opts?.useHex ?? /[a-f]/.test(text);
+    const radix = useHex ? 16 : 10;
+    const val = parseInt(text, radix);
+    return isNaN(val) ? defaultValue : val;
+  }
+  function formatHex(value, pad = 2) {
+    return Math.round(value).toString(16).padStart(pad, "0");
+  }
+
+  const eventMapping = {
+    ["noteOn" /* Note */]: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
+    ["noteOff" /* NoteOff */]: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
+    ["cc" /* CC */]: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
+    ["polyTouch" /* NoteAftertouch */]: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
+    ["programChange" /* ProgramChange */]: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
+    ["pitchBend" /* PitchBend */]: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
+    ["channelPressure" /* ChannelPressure */]: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
+    ["songPosition" /* SongPosition */]: { shorthand: "songpos", command: 242, description: "Song Position Pointer (Sys Common)", highResParam: "value" },
+    ["songSelect" /* SongSelect */]: { shorthand: "songsel", command: 243, description: "Song Select (Sys Common)", param1: "value" },
+    ["clock" /* Clock */]: { shorthand: "clock", command: 248, description: "Timing Clock (Sys Realtime)" },
+    ["start" /* Start */]: { shorthand: "start", command: 250, description: "Start (Sys Realtime)" },
+    ["continue" /* Continue */]: { shorthand: "continue", command: 251, description: "Continue (Sys Realtime)" },
+    ["stop" /* Stop */]: { shorthand: "stop", command: 252, description: "Stop (Sys Realtime)" },
+    ["activeSensing" /* ActiveSensing */]: { shorthand: "ping", command: 254, description: "Active Sensing (Sys Realtime)" },
+    ["reset" /* Reset */]: { shorthand: "reset", command: 255, description: "System Reset (Sys Realtime)" }
+  };
+  /** @type {Map<number, EventType>} */
+  // @ts-ignore
+  const commandLookup = new Map(Object.entries(eventMapping).map(([key, { command }]) => [command, key]));
+  /** @type {Map<string, EventType>} */
+  // @ts-ignore
+  const shorthandLookup = Object.fromEntries([
+    ...Object.entries(eventMapping).map(([key, { shorthand }]) => [shorthand, key]),
+    ...Object.keys(eventMapping).map(key => [key.toLowerCase(), key])
+  ]);
+  const shorthands = Object.fromEntries(Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand]));
+  /**
+   * @param {string} value 
+   * @returns {EventType | undefined}
+   */
+  function normalizeType(value) {
+    if (typeof value === "number") {
+      return commandLookup.get(value);
+    }
+    if (typeof value !== "string") return undefined;
+    return eventMapping[value] !== undefined
+      ? value
+      : shorthandLookup[value.toLowerCase()];
+  }
+
+  function formatNumValue(value, opts) {
+    const str = opts?.useHex ? formatHex(value) : value.toFixed().padStart(opts?.fixedWidth ? 2 : 3, "0");
+    return str;
+  }
+  function formatDefault(type, value, value2, opts) {
+    return `${type} ${formatNumValue(value, opts)}${value2 != undefined ? " " + formatNumValue(value2, opts) : ""}`;
+  }
+  function formatNoteType(type, note, value, opts = {}) {
+    return `${type ? type + " " : ""}${midiPitchToNoteName(note, opts)} ${formatNumValue(value, opts)}`;
+  }
+  /** @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>} */
+  const formatters = {
+    noteOn({ value1: note, value2: velocity = eventMapping.noteOn.defaults[1] }, opts = {}) {
+      return formatNoteType(opts?.noMinify ? shorthands.noteOn : undefined, note, velocity, opts);
+    },
+    noteOff({ value1: note }, opts = {}) {
+      return formatNoteType(opts?.noMinify ? shorthands.noteOff : undefined, note, 0, opts);
+    },
+    polyTouch({ value1: note, value2: value = eventMapping.polyTouch.defaults[1] }, opts = {}) {
+      return formatNoteType(shorthands.polyTouch, note, value, opts);
+    },
+    cc({ value1: cc, value2: value }, opts) {
+      return formatDefault(shorthands.cc, cc, value, opts);
+    },
+    programChange({ value1: program }, opts) {
+      return formatDefault(shorthands.programChange, program, undefined, opts);
+    },
+    channelPressure: ({ value1: value }, opts) => formatDefault(shorthands.channelPressure, value, undefined, opts),
+    pitchBend({ value1 = 0, value2 = 64 }, opts) {
+      return `${shorthands.pitchBend} ${formatHighResValue(value1, value2, opts)}`;
+    },
+    songPosition({ value1 = 0, value2 = 0 }, opts) {
+      return `${shorthands.songPosition} ${formatHighResValue(value1, value2, opts)}`;
+    },
+    songSelect: ({ value1 }, opts) => formatDefault(shorthands.songSelect, value1, undefined, opts),
+    // tuneRequest: () => shorthands.tuneRequest,
+    continue: () => shorthands.continue,
+    activeSensing: () => shorthands.activeSensing,
+    clock: () => shorthands.clock,
+    start: () => shorthands.start,
+    stop: () => shorthands.stop,
+    reset: () => shorthands.reset
+  };
+
+  const PREFIX_CHANNEL = "ch";
+  const PREFIX_DEVICE = "dev";
+  const PREFIX_WHEN = "@";
+  const PREFIX_POS = 'pos=';
+  const PREFIX_DURATION = 'beats=';
+  /** Used when creating lists - treat ~ as empty no value */
+  const REST_LITERAL = '~';
+
+  // FUTURE - convert everything after data1/data2 to an iterator to parse tokens so they don't need to be in specific order
+  // FUTURE - support unicode note durations https://en.wikipedia.org/wiki/Musical_Symbols_(Unicode_block)
+  const midiStringRegex = /^\s*(?<type>[a-zA-Z]{2,})?\s*(?<pitch>[A-G][#b♯♭_]*-?\d?)?\s*(?<data1>\b-?[0-9a-f]{1,5}\b)?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(ch=?(?<channel>[0-9a-f]{1,2}))?\s*(dev=?(?<device>[0-9a-f]))?\s*((@|time=)\s*(?<time>[\d:.]+))?\s*((pos|offset)=(?<pos>[\d./]+))?\s*((beats|dur)=(?<dur>[\d:./]+))?\s*$/;
+
+  /**
+   * 
+   * @param {MidiEvent} event 
+   * @param {FormatOptions} opts 
+   * @returns 
+   */
+  function midiToString(event, opts = {}) {
+    const { noMinify } = opts;
+    let type = shorthands[event.type];
+    const formatter = formatters[event.type];
+    if (!formatter) {
+      console.debug(`unknown event type ${event.type}`);
+      return "";
+    }
+    let msg = formatter(event, opts);
+    if (event.channel != undefined || noMinify) {
+      msg += formatChannel(event.channel, opts);
+    }
+    if (event.device || noMinify) {
+      msg += formatDevice(event.device, opts);
+    }
+    if (event.time != undefined) {
+      msg += formatTime(event, opts);
+    }
+    if (event.pos) {
+      msg += formatPosition(event.pos, opts);
+    }
+    if (event.dur) {
+      msg += formatDuration(event.dur, opts);
+    }
+    return msg;
+  }
+
+  /**
+   * convert a string representation of a note to a midievent
+   * @param {string} text 
+   * @param {FormatOptions} opts 
+   * @returns {MidiEvent}
+   */
+  function stringToMidi(text, opts = {}) {
+    const match = midiStringRegex.exec(text);
+    if (!match?.groups) return null;
+    let {
+      type: shorthand,
+      pitch,
+      data1,
+      data2,
+      channel: rawChannel,
+      device: rawDevice,
+      time,
+      pos,
+      dur
+    } = match.groups;
+    const value1 = data1 ? parseNumValue(data1, undefined, opts) : undefined;
+    const value2 = data2 ? parseNumValue(data2, undefined, opts) : undefined;
+    /** @type {EventType | 'rest'} */
+    let type = normalizeType(shorthand);
+
+    if (!type && shorthand === REST_LITERAL) {
+      type = 'rest';
+    }
+    type || (type = "noteOn" /* Note */);
+    const spec = eventMapping[type];
+    /** @type {MidiEvent} */
+    const event = {
+      type,
+      channel: parseNumValue(rawChannel, undefined, opts),
+      device: parseNumValue(rawDevice, undefined, opts)
+    };
+    if (time) {
+      event.time = parseTimespan(time);
+    }
+    if (pos) {
+      event.pos = parseFraction(pos);
+      // REVIEW is this right?
+      event.time = (event.time || 0) + event.pos;
+    }
+    if (dur) {
+      event.dur = parseFraction(dur);
+    }
+    switch (type) {
+      case "noteOn" /* Note */:
+      case "noteOff" /* NoteOff */:
+      case "polyTouch" /* NoteAftertouch */:
+        const note = pitch ? noteNameToMidiPitch(pitch, opts.defaultOctave) : value1 || null;
+        if (note == null) return null;
+        const velocity = pitch ? value1 : value2;
+        if (event.type !== "polyTouch" /* NoteAftertouch */ && velocity == 0) {
+          event.type = "noteOff" /* NoteOff */;
+        }
+        event.value1 = note;
+        event.value2 = velocity ?? 64;
+        break;
+      case "cc" /* CC */:
+        if (value1 == undefined || value2 == undefined) return null;
+        event.value1 = value1;
+        event.value2 = value2;
+        break;
+      case "programChange" /* ProgramChange */:
+      case "channelPressure" /* ChannelPressure */:
+      case "songSelect" /* SongSelect */:
+        event.value1 = value1 || 0;
+        break;
+      case "songPosition" /* SongPosition */:
+      case "pitchBend" /* PitchBend */:
+        if (value1 == undefined) return null;
+        const { value: highResValue, ...normedValues } = parseHighResValue(value1, value2);
+        Object.assign(event, normedValues);
+        event[spec.highResParam ?? "value"] = highResValue;
+        break;
+      case "clock" /* Clock */:
+      case "start" /* Start */:
+      case "continue" /* Continue */:
+      case "stop" /* Stop */:
+      case "activeSensing" /* ActiveSensing */:
+      case "reset" /* Reset */:
+        break;
+      case "rest":
+      // do nothing
+    }
+    if (spec?.param1 && event.value1 != undefined) {
+      event[spec.param1] = event.value1;
+    }
+    if (spec?.param2 && event.value2 != undefined) {
+      event[spec.param2] = event.value2;
+    }
+    return event;
+  }
+
+  function formatChannel(channel = 0, opts) {
+    const str = opts?.useHex ? formatHex(channel, 1) : channel.toFixed().padStart(2, "0");
+    return ` ${PREFIX_CHANNEL}${str}`;
+  }
+  function formatDevice(device = 0, opts) {
+    const str = opts?.useHex ? formatHex(device, 1) : device.toFixed();
+    return ` ${PREFIX_DEVICE}${str}`;
+  }
+  function formatTime({ time = undefined }, { noMinify = false, timestampFormat = "absolute", startTimestamp = 0 }) {
+    if (timestampFormat === "omit" || time == undefined) {
+      return "";
+    }
+    if (timestampFormat === "absolute") {
+      return ` ${PREFIX_WHEN}${time.toFixed(3)}`;
+    }
+    const ONE_DAY = 1e3 * 60 * 60 * 24;
+    let val = (time - startTimestamp) % ONE_DAY;
+    return ` ${PREFIX_WHEN}${formatTimespan(val)}`;
+  }
+
+  // TODO FUTURE add in opts flag to use fractions or not
+  function formatPosition(value, opts) {
+    return `${PREFIX_POS}${formatFraction(value)}`
+  }
+
+  // TODO FUTURE add in opts flag to use fractions or not
+  function formatDuration(value, opts) {
+    return `${PREFIX_DURATION}${formatFraction(value)}`
+  }
+
+
+  function formatTimespan(seconds, hoursOptional = true) {
+    const ms = 1e3 * (seconds % 1);
+    let t = Math.floor(seconds);
+    const s = t % 60;
+    const m = Math.floor(t / 60);
+    const h = Math.floor(t / 3600);
+    const parts = hoursOptional && h === 0 ? [m, s] : [h, m, s];
+    return `${parts.map((p) => p.toFixed(0).padStart(2, "0")).join(":")}.${ms.toFixed().padEnd(3, "0")}`;
+  }
+  /**
+   * 
+   * @param {string} text 
+   * @returns 
+   */
+  function parseTimespan(text) {
+    if (!text) return 0;
+    // split into [hh]:mm:ss.000 parts
+    const parts = text.split(':');
+    // somewhat unnecessarily clever method to sum [hh][mm][ss]
+    // by incrementing the scale from [1, 60, 3600].
+    // goes right to left because hours and minutes are optional
+    const [value] = parts.reduceRight(([acc, scale], part) => {
+      const val = (parseFloat(part) || 0) * scale;
+      return [acc + val, scale * 60];
+    }, [0, 1]);
+    return value;
+  }
+  function parseFraction(text) {
+    if (typeof text !== 'string') {
+      return +text || 0;
+    }
+    const [top, bottom] = text.split('/');
+    return (parseFloat(top) / (parseFloat(bottom) || 1)) || 0;
+  }
+  function formatFraction(value, threshold = 2e-3) {
+    for (let d of [4, 3, 10, 8, 1]) {
+      const numerator = value * d;
+      if (Math.abs(numerator % 1) <= threshold) {
+        return `${numerator}/${d}`;
+      }
+    }
+    // truncate to milliseconds (0.001)
+    return `${value}`.replace(/(\.\d{3})\d+$/, '$1');
+  }
+
+  function valueToMsbLsb(value) {
+    return {
+      value1: value & 127,
+      value2: value >> 7
+    };
+  }
+  function msbLsbToValue(lsb, msb) {
+    return (msb << 7) + lsb;
+  }
+  function parseHighResValue(value1, value2) {
+    const value = typeof value2 == undefined ? value1 : msbLsbToValue(value1, value2);
+    return {
+      value,
+      ...valueToMsbLsb(value)
+    };
+  }
+  function formatHighResValue(value1, value2, opts = {}) {
+    if (opts?.useHex) {
+      return `${shorthands.pitchBend} ${formatHex(value1)} ${formatHex(value2)}`;
+    }
+    const value = msbLsbToValue(value1, value2);
+    let txt = value.toFixed();
+    if (opts?.fixedWidth) {
+      txt = txt.padStart(5, " ");
+    }
+    return txt;
+  }
+
+  /**
+   * 
+   * @param {Uint8Array} data 
+   * @returns {MidiEvent | null}
+   */
+  function rawMessageToMidi(data) {
+    const [commandAndChannel, value1, value2] = data;
+    const channel = commandAndChannel % 16;
+    const command = commandAndChannel - channel;
+    const type = commandLookup.get(command);
+    if (!type) {
+      console.debug("unknown command type", command);
+      return null;
+    }
+    /** @type {MidiEvent} */
+    const event = {
+      type,
+      channel: channel + 1,
+      ...value1 != undefined && { value1 },
+      ...value2 != undefined && { value2 }
+    };
+    const spec = eventMapping[type];
+    if (spec?.param1 && event.value1 != undefined) {
+      event[spec.param1] = event.value1;
+    }
+    if (spec?.param2 && event.value2 != undefined) {
+      event[spec.param2] = event.value2;
+    }
+    if (spec.highResParam) {
+      const { value } = parseHighResValue(value1, value2);
+      event[spec.highResParam] = value;
+    }
+    return event;
+  }
+  /**
+   * 
+   * @param {MidiEvent} event
+   * @returns {Uint8Array}
+   */
+  function midiToRawMessage(event) {
+    let {
+      type,
+      value1,
+      value2,
+      channel = 1
+    } = event;
+    const spec = eventMapping[type];
+    // return empty if not valid event
+    if (!spec) return new Uint8Array();
+    const commandAndChannel = spec.command + Math.max(channel - 1, 0);
+    if (spec.param1 && value1 == undefined) {
+      value1 = (event[spec.param1] ?? spec.defaults?.[0]) || 0;
+    }
+    if (spec.param2 && value2 == undefined) {
+      value2 = (event[spec.param2] ?? spec.defaults?.[1]) ?? undefined;
+    }
+    if (spec.highResParam && event.value != undefined) {
+      const highRes = parseHighResValue(event.value);
+      [value1, value2] = [highRes.value1, highRes.value2];
+    }
+    return new Uint8Array([commandAndChannel, value1, ...(value2 !== undefined ? [value2] : [])]);
+  }
+  /**
+   * 
+   * @param {Pick<MidiEvent, 'time' | 'pos' | 'dur'>} event 
+   * @param {number} [offsetMs] time to return relative to. Default is now
+   */
+  function getMidiOffsetTime(event, offsetMs = window.performance.now()) {
+    const { pos = 0, dur } = event;
+    return {
+      start: offsetMs + (pos * 1000),
+      ...(dur > 0) && {
+        end: offsetMs + ((pos + dur) * 1000)
+      }
+    };
+  }
+  function isPitchedEvent(type) {
+    return !!type && (type === "noteOn" /* Note */ || type === "noteOff" /* NoteOff */ || type === "polyTouch" /* NoteAftertouch */);
+  }
+
+  // Make a full array of notes in full midi range from 0 (C-1) to 127 (G-9)
+  const MIDI_NOTES = "_".repeat(11).split('')
+    .flatMap((_, i) => SHARPS.map(c => `${c}${i - 1}`))
+    .slice(0, 128);
+
+  const ANY_TYPE = "*";
+  const eventProps = {
+    type: { key: "type", text: Scratch.translate("Event Type") },
+    pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
+    velocity: { key: "velocity", type: "noteOn" /* Note */, text: Scratch.translate("Velocity") },
+    ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
+    ccValue: { key: "value", type: "cc" /* CC */, text: Scratch.translate("CC Value") },
+    channel: { key: "channel", text: Scratch.translate("Channel") },
+    device: { key: "device", text: Scratch.translate("Device") },
+    pitchbend: { key: "value", type: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
+    aftertouch: { key: "value", type: "polyTouch" /* NoteAftertouch */, text: Scratch.translate("Aftertouch") },
+    time: { key: "time", text: Scratch.translate("Timestamp") }
+  };
+
+  // src/midi/midi-backend.ts
+  class MidiBackend extends EventTarget {
+    constructor() {
+      super();
+      this.status = "pending" /* Initial */;
+      /** @type {MIDIInput[]} */
+      this.inputs = [];
+      /** @type {MIDIOutput[]} */
+      this.outputs = [];
+      this._init = undefined;
+      /** @type {MidiEvent} */
+      this._defaultOutputEvent = {
+        type: 'noteOn',
+        channel: 1,
+        device: 0,
+        pitch: 60,
+        dur: 0.5,
+        velocity: 196
+      }
+      // TIP! If you use arrow functions on class methos then 'this' is automatically bound correctly, even if using as event listener
+      this.refreshDevices = () => {
+        for (const input of this.access.inputs.values()) {
+          if (!this.inputs.some((d) => d.id === input.id)) {
+            input.addEventListener("midimessage", this._onInputEvent);
+            input.addEventListener("statechange", this._onDeviceStateChange);
+            this.inputs.push(input);
+          }
+        }
+        for (const output of this.access.outputs.values()) {
+          if (!this.outputs.some((d) => d.id === output.id)) {
+            this.outputs.push(output);
+          }
+        }
+      };
+      this._onDeviceStateChange = (event) => {
+        const { port } = event;
+        if (!port) return;
+        const { type, id, name } = port;
+        const deviceList = type === "input" ? this.inputs : this.outputs;
+        const index = deviceList.findIndex((dev) => dev.id === id);
+        if (index === -1) {
+          this.refreshDevices();
+          return;
+        }
+        this._emit("device:status", { index, id, name, type, state: port.state });
+      };
+      this._onInputEvent = (event) => {
+        const {
+          target: device,
+          data,
+          timeStamp
+        } = event;
+        if (!data) return;
+        const deviceIndex = this.inputs.indexOf(device);
+        const midiEvent = rawMessageToMidi(data);
+        if (!midiEvent) {
+          console.warn("Unable to parse message", data);
+          this._emit("midi:unhandled", event);
+          return;
+        } else {
+          midiEvent.time = timeStamp / 1000;
+          if (deviceIndex !== -1) {
+            midiEvent.device = deviceIndex;
+          }
+          midiEvent._str = midiToString(midiEvent, { noMinify: true });
+          this._emit("midi", midiEvent);
+        }
+      };
+    }
+    get defaultInput() {
+      return this.inputs.find(d => d.state === 'connected');
+    }
+    get defaultOutput() {
+      return this.outputs.find(d => d.state === 'connected');
+    }
+    async initialize({ sysex = false, force = false, timeoutMS = 1e3 * 30 } = {}) {
+      if (this._init && !force) {
+        return this._init;
+      }
+      if (!navigator.requestMIDIAccess) {
+        return false;
+      }
+      return this._init = (async () => {
+        this.status = "initializing" /* Initializing */;
+        this._emit("status", { status: this.status });
+        try {
+          let timer;
+          const whenTimeout = new Promise((resolve, reject) => {
+            timer = setTimeout(() => reject(new DOMException("Timeout waiting for midi access")), timeoutMS);
+          });
+          const midiAccess = await Promise.race([
+            navigator.requestMIDIAccess({ sysex }),
+            whenTimeout
+          ]);
+          clearTimeout(timer);
+          this.access = midiAccess;
+          midiAccess.addEventListener("statechange", this.refreshDevices);
+          this.refreshDevices();
+          this.status = "connected" /* Connected */;
+          return true;
+        } catch (error) {
+          console.warn("Request failure", error);
+          if (sysex) {
+            return this.initialize({ sysex: false, force: true, timeoutMS });
+          }
+          this.status = "error" /* Error */;
+          return false;
+        } finally {
+          this._emit("status", { status: this.status });
+        }
+      })();
+    }
+    /**
+     * 
+     * @param {MidiEvent | string | number} event
+     * @param {MidiEvent} [defaults]
+     * @param {FormatOptions} [formatOpts]
+     */
+    sendOutputEvent(event, defaults = this._defaultOutputEvent, formatOpts = {}) {
+      /** @type {MidiEvent} */
+      let data;
+      // midi pitch = noteon now for 1/2 beat
+      if (typeof event === 'number') {
+        data = {
+          ...defaults,
+          pitch: event
+        };
+      } else if (typeof event === 'string') {
+        data = {
+          ...defaults,
+          ...stringToMidi(event, formatOpts)
+        };
+      } else if (typeof event === 'object') {
+        data = event;
+      } else {
+        throw new TypeError('Invalid data to send to output - must be midievent object, string or number');
+      }
+
+      // ignore, just placebo rest event
+      if (data.type === 'rest') {
+        return false;
+      }
+
+      const device = (data.device != undefined && this.outputs[data.device]) || this.defaultOutput;
+      if (!device) {
+        // no output. Should this throw error?
+        return false;
+      }
+      // ensure 0 velocity is interpreted as noteOff
+      if (data.type === 'noteOn' && data.velocity === 0) {
+        data.type = 'noteOff';
+      }
+
+      // TODO be able to specify offset time to calculate from?
+      const { start, end } = getMidiOffsetTime(data);
+      let raw = midiToRawMessage(data);
+      device.send(raw, start);
+      // also send off event
+      if (data.type === 'noteOn' && end) {
+        /** @type {MidiEvent} */
+        const offEvent = {
+          ...data,
+          type: 'noteOff',
+          value2: 0,
+          velocity: 0
+        };
+        raw = midiToRawMessage(offEvent);
+        device.send(raw, end);
+      }
+
+      // Keep track of notes so stop events can be sent if necessary
+      this._trackActiveNotes(data, device);
+    }
+
+    /**
+     * Stop all notes on all devices and clear pending
+     */
+    panic() {
+      for (let [device, active] of this._activeNotes.entries()) {
+        if (device.state !== 'connected') continue;
+        for (let key of active) {
+          const [channel, pitch] = key.split('_');
+          const raw = midiToRawMessage({
+            type: 'noteOff',
+            channel: parseInt(channel, 10),
+            pitch: parseInt(pitch)
+          });
+          // console.debug(`Stopping note ${pitch} on ${channel}`);
+          device.send(raw);
+        }
+      }
+      this._activeNotes.clear();
+    }
+    /**
+     * Keep track of events sent to midi devices to allow panic stopping them if necessary
+     * @private
+     * @param {MidiEvent} event 
+     * @param {MIDIOutput} device
+     */
+    _trackActiveNotes(event, device) {
+      // NOTE - same default channel as midiToRawEvent, maybe default should be a magic value?
+      const { type, pitch, channel = 1 } = event;
+      if (!(type === 'noteOn' || type === 'noteOff')) {
+        return;
+      }
+      const key = `${channel}_${pitch}`;
+      if (!this._activeNotes.has(device)) {
+        this._activeNotes.set(device, new Set());
+      }
+      const list = this._activeNotes.get(device);
+      if (type === 'noteOn') {
+        list.add(key);
+      } else {
+        list.delete(key);
+      }
+    }
+    /** @type {Map<MIDIOutput, Set<string>>} */
+    _activeNotes = new Map();
+    _emit(name, data) {
+      const event = new CustomEvent(name, { detail: data });
+      this.dispatchEvent(event);
+    }
+    // @ts-ignore
+    _whenEvent(event, { target = this, signal, timeoutMS = 1e3 * 60 } = {}) {
+      const events = Array.isArray(event) ? event : [event];
+      let timer;
+      return new Promise((resolve, reject) => {
+        events.forEach((name) => target.addEventListener(name, resolve, { once: true, signal }));
+        timer = setTimeout(() => {
+          events.forEach((name) => target.removeEventListener(name, resolve));
+          reject(new DOMException("Timeout", "TimeoutError"));
+        }, timeoutMS);
+      }).finally(() => clearTimeout(timer));
+    }
+    on(type, callback, options) {
+      return super.addEventListener(type, callback, options);
+    }
+    off(type, callback) {
+      return super.removeEventListener(type, callback);
+    }
+  };
+
+  // src/midi/midi-recorder.ts
+  class MidiRecorder extends EventTarget {
+    constructor() {
+      super();
+      this.active = /* @__PURE__ */ new Map();
+      // REVIEW should this just be a {[key: channel]: Map()}  instead?
+      this.activeByChannel = /* @__PURE__ */ new Map();
+      this.ccs = {};
+      this.lastNotes = {};
+      this.buffer = [];
+      this.paused = false;
+      this.recordStart = 0;
+      // 5 minute record time should be safe...midi doesn't take up much memory
+      this.bufferSeconds = 60 * 5;
+      this.maxEntries = 256 * 256;
+    }
+    _now() {
+      return (globalThis.performance ? globalThis.performance.now() : Date.now()) / 1000;
+    }
+    /**
+     * REVIEW should record start be a protection against purging?
+     */
+    startRecording(waitForEvent = true) {
+      if (!waitForEvent) {
+        this.recordStart = this._now();
+      }
+      this.paused = false;
+    }
+    /**
+     * REVIEW should stop recording pause collecting events? probably bad
+     */
+    stopRecording() {
+      this.paused = true;
+      const { recordStart } = this;
+      this.recordStart = 0;
+      return recordStart ? this.buffer.filter((evt) => evt.when >= recordStart) : this.buffer;
+    }
+    /**
+     * add note to buffer
+     * @param evt 
+     * @param when -- note, only used for setting "when" of active notes...evt should already have time value
+     * @returns 
+     */
+    add(evt, when = this._now()) {
+      const doc = { ...evt, when };
+      if (!this.paused) {
+        this.buffer.push(doc);
+        this._prune(when);
+      }
+      switch (evt.type) {
+        case "noteOn" /* Note */:
+          this._onNoteOn(evt);
+          break;
+        case "noteOff" /* NoteOff */:
+          this._onNoteOff(doc);
+          break;
+        case "polyTouch" /* NoteAftertouch */:
+          this._onNoteTouch(doc);
+          break;
+        case "cc" /* CC */:
+          Object.assign(this.ccs, {
+            [`${evt.cc}_${evt.channel}`]: evt,
+            [`${evt.cc}`]: evt
+          });
+          break;
+      }
+    }
+    _onNoteOn(evt) {
+      if (evt.pitch == undefined) return;
+      this.active.set(evt.pitch, evt);
+      this.lastNotes[`${evt.pitch}`] = evt;
+      if (evt.channel) {
+        this.lastNotes[`${evt.pitch}_${evt.channel}`] = evt;
+      }
+      this.activeByChannel.set(channelKeyForEvent(evt.pitch, evt.channel), evt);
+    }
+    _onNoteOff(evt) {
+      const { pitch, channel } = evt;
+      if (pitch == undefined) return;
+      const key = channelKeyForEvent(pitch, channel);
+      const existing = this.activeByChannel.get(key) || this.active.get(pitch);
+      if (!existing) return;
+      existing.duration = evt.when - existing.when;
+      this.active.delete(pitch);
+      this.activeByChannel.delete(key);
+    }
+    _onNoteTouch(evt) {
+      const { pitch, channel } = evt;
+      if (pitch == undefined) return;
+      const key = channelKeyForEvent(pitch, channel);
+      const existing = this.activeByChannel.get(key) || this.active.get(pitch);
+      if (!existing) return;
+      existing.aftertouch = evt.value;
+    }
+    isNoteActive(pitch, channel) {
+      if (channel == undefined) {
+        return this.active.has(pitch);
+      }
+      const key = channelKeyForEvent(pitch, channel);
+      return this.activeByChannel.has(key);
+    }
+    getActiveNote(pitch, channel) {
+      if (pitch == undefined) {
+        const list = this.getActiveNotes(channel);
+        return list.length == 0 ? undefined : list.reduce((a, b) => a.when > b.when ? a : b);
+      }
+      if (channel == undefined) {
+        return this.active.get(pitch);
+      }
+      const key = channelKeyForEvent(pitch, channel);
+      return this.activeByChannel.get(key);
+    }
+    getActiveNotes(channel) {
+      if (channel == undefined) {
+        return [...this.active.values()];
+      }
+      return [...this.activeByChannel.values()].filter((c) => c.channel == channel);
+      ;
+    }
+    clear(newStartTime = 0) {
+      this.lastNotes = {};
+      this.active.clear();
+      this.activeByChannel.clear();
+      this.ccs = {};
+      this.recordStart = newStartTime;
+      // remove old events
+      this._prune(newStartTime + this.bufferSeconds);
+    }
+    getRange(start = this.recordStart ?? 0, end) {
+      const first = this.buffer.findIndex((e) => (e.time ?? e.when) >= start);
+      if (!end) {
+        return this.buffer.slice(first);
+      }
+      const last = findLastIndex(this.buffer, (e) => (e.time ?? e.when) <= end);
+      return this.buffer.slice(first, last);
+    }
+    getLastEvent(channel) {
+      return this.getLast(undefined, undefined, channel);
+    }
+    getLastNote(pitch, channel) {
+      return this.getLast("noteOn" /* Note */, pitch, channel);
+    }
+    getLastCC(cc, channel) {
+      return this.getLast("cc" /* CC */, cc, channel);
+    }
+    getLastAftertouch(pitch, channel) {
+      return this.getLast("polyTouch" /* NoteAftertouch */, pitch, channel);
+    }
+    getLast(type, value1, channel) {
+      if (type === value1 === channel === undefined) {
+        return this.buffer[this.buffer.length - 1];
+      }
+      if (type === "cc" /* CC */ && value1) {
+        const key = channel != undefined ? `${value1}_${channel}` : `${value1}`;
+        const foundCC = this.ccs[key];
+        if (foundCC) return foundCC;
+      }
+      for (let i = this.buffer.length - 1; i >= 0; i--) {
+        const evt = this.buffer[i];
+        if (value1 != undefined && evt.value1 != value1) continue;
+        if (channel != undefined && evt.channel != channel) continue;
+        if (type) {
+          const eType = evt.type;
+          const isType = Array.isArray(type) ? type.includes(eType) : type === eType;
+          if (!isType) continue;
+        }
+        return evt;
+      }
+    }
+    *streamLast(type) {
+      for (let i = this.buffer.length; i >= 0; i--) {
+        const evt = this.buffer[i];
+        if (type && evt.type != type) continue;
+        yield evt;
+      }
+    }
+    _prune(when = this._now()) {
+      this.recordStart || (this.recordStart = when);
+      const threshold = when - this.bufferSeconds;
+      const n = this.buffer.length;
+      if (this.buffer.length > this.maxEntries) {
+        this.buffer = this.buffer.slice(-1 * this.maxEntries);
+      }
+      const firstNonStaleEvent = this.buffer.findIndex((e) => e.when >= threshold);
+      if (firstNonStaleEvent === -1) {
+        this.buffer = [];
+      } else {
+        this.buffer = this.buffer.slice(firstNonStaleEvent);
+      }
+    }
+  };
+  // polyfill for findLastIndex for 5% of browsers without it
+  const findLastIndex = (arr, cb) => {
+    if (typeof arr.findLastIndex === 'function') {
+      return arr.findLastIndex(cb);
+    }
+    let i = arr.length - 1;
+    while (i > -1 && !cb(arr[i], i, arr)) {
+      i -= 1;
+    }
+    return i;
+  }
+
+  function channelKeyForEvent(value = 0, channel = 0) {
+    return msbLsbToValue(value, channel);
+  }
+
+  // src/midi/midi-thread.ts
+  const TARGET_MIDI_KEY = "_midi";
+  /**
+   * 
+   * @param {import("scratch-vm").Thread} thread 
+   * @returns {MidiEvent | undefined}
+   */
+  function getThreadMidiValue(thread) {
+    return thread[TARGET_MIDI_KEY];
+  }
+  function setThreadMidiValue(thread, evt) {
+    thread[TARGET_MIDI_KEY] = evt;
+  }
+  function setThreadActiveNotes(thread, value) {
+    thread._activeNotes = value;
+  }
+  function getThreadActiveNotes(thread) {
+    return thread._activeNotes;
+  }
+  /**
+   * Get the current tempo.
+   * @return {number} - the current tempo, in beats per minute.
+   */
+  function getTempo() {
+    const stage = Scratch.vm.runtime.getTargetForStage();
+    if (stage) {
+      return stage.tempo;
+    }
+    return 60;
+  }
+  function beatsToSeconds(beats = 1, tempo = getTempo()) {
+    return beats * 60 / tempo;
+  }
+  function secondsToBeats(seconds = 1, tempo = getTempo()) {
+    return seconds * tempo / 60;
+  }
+
+  //#endregion
+
+  //#region Scratch Extension
+
+  const HATS = {
+    NOTE: `${EXT_ID}_whenNoteOnOff`,
+    NOTEANY: `${EXT_ID}_whenAnyNoteOnOff`,
+    MIDI: `${EXT_ID}_whenMidiEvent`
+  };
+  /** @type {'---'} */
+  const SEPARATOR = '---';
+  const { Cast } = Scratch;
+  class MidiExtension {
+    constructor() {
+      this.midi = new MidiBackend();
+      this.recorder = new MidiRecorder();
+      this._ensureInitialize = (evt) => {
+        if (this.midi.status === "pending" /* Initial */) {
+          this.initialize().catch(() => {
+          });
+        }
+      };
+      this._addListeners();
+      // globalThis.midiExt = this;
+      const vm = Scratch.vm;
+      vm.runtime.once("BEFORE_EXECUTE", this._ensureInitialize);
+    }
+    /**
+     * This helper actually glues together the extension with the MidiBackend / recorder. In particular it triggers HATS when incoming midi events occur
+     */
+    _addListeners() {
+      const vm = globalThis.Scratch.vm;
+      this.midi.on("midi", (domEvent) => {
+        const midiEvent = domEvent.detail;
+        this.recorder.add(midiEvent);
+        const threads = vm.runtime.startHats(HATS.MIDI);
+        // set the thread local variable to the passed in midi event for use with the "input event" reporter
+        for (let thread of threads) {
+          setThreadMidiValue(thread, midiEvent);
+        }
+        switch (midiEvent.type) {
+          case "noteOn":
+          case "noteOff":
+            vm.runtime.startHats(HATS.NOTE);
+            vm.runtime.startHats(HATS.NOTEANY);
+            break;
+          // case "cc" /* CC */:
+          //   vm.runtime.startHats(HATS.CC);
+          //   break;
+        }
+      });
+    }
+    getInfo() {
+      const EVENT_TYPES_ITEMS = [
+        { value: "noteOn" /* Note */, text: Scratch.translate("Note On") },
+        { value: "noteOff" /* NoteOff */, text: Scratch.translate("Note Off") },
+        { value: "cc" /* CC */, text: Scratch.translate("CC") },
+        { value: "polyTouch" /* NoteAftertouch */, text: Scratch.translate("AfterTouch") },
+        { value: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
+        { value: "programChange" /* ProgramChange */, text: Scratch.translate("Program Change") },
+        { value: "channelPressure" /* ChannelPressure */, text: Scratch.translate("Channel Pressure") }
+      ];
+
+      return {
+        id: EXT_ID,
+        name: Scratch.translate("Midi"),
+        menuIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
+        blockIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
+        blocks: [
+          // {
+          //   opcode: "initialize",
+          //   text: Scratch.translate("Initialize force? [FORCE]"),
+          //   blockType: Scratch.BlockType.COMMAND,
+          //   arguments: {
+          //     FORCE: {
+          //       type: Scratch.ArgumentType.NUMBER,
+          //       defaultValue: 1
+          //     }
+          //   }
+          // },
+          {
+            opcode: "numDevices",
+            text: Scratch.translate("number of [DEVICE_TYPE] devices"),
+            blockType: Scratch.BlockType.REPORTER,
+            arguments: {
+              DEVICE_TYPE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: 'DEVICE_TYPES',
+                defaultValue: 'input'
+              }
+            }
+          },
+          {
+            opcode: "getDeviceInfo",
+            text: Scratch.translate("[DEVICE_PROP] of [DEVICE_TYPE] device at [INDEX]"),
+            blockType: Scratch.BlockType.REPORTER,
+            arguments: {
+              DEVICE_PROP: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "DEVICE_PROPS",
+                defaultValue: "name"
+              },
+              DEVICE_TYPE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: 'DEVICE_TYPES',
+                defaultValue: 'input'
+              },
+              INDEX: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              }
+            }
+          },
+          SEPARATOR,
+          {
+            opcode: "whenNoteOnOff",
+            blockType: Scratch.BlockType.HAT,
+            text: Scratch.translate("when note [NOTE] [PRESS]"),
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              PRESS: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "NOTE_EVENT_TYPE",
+                defaultValue: ANY_TYPE
+              }
+            }
+          },
+          {
+            opcode: "whenAnyNoteOnOff",
+            blockType: Scratch.BlockType.HAT,
+            text: Scratch.translate("when any note [PRESS]"),
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            arguments: {
+              PRESS: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "NOTE_EVENT_TYPE",
+                defaultValue: ANY_TYPE
+              }
+            }
+          },
+          {
+            opcode: "whenMidiEvent",
+            blockType: Scratch.BlockType.HAT,
+            text: Scratch.translate("when input event [TYPE]"),
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            arguments: {
+              TYPE: {
+                menu: "EVENT_TYPES_OPTIONAL",
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: ANY_TYPE
+              }
+            }
+          },
+          {
+            opcode: "lastEvent",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Input Event"),
+            disableMonitor: true,
+            allowDropAnywhere: true
+          },
+          {
+            opcode: "getEventProp",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("[PROP] of [EVENT]"),
+            arguments: {
+              EVENT: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "note C4 82 ch1 dev0 @1000"
+              },
+              PROP: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "type",
+                menu: "PROPS"
+              }
+            }
+          },
+          {
+            opcode: "isNoteActive",
+            blockType: Scratch.BlockType.BOOLEAN,
+            text: Scratch.translate("Is Note [NOTE] Pressed?"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              CHANNEL: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "CHANNELS",
+                defaultValue: "0"
+              }
+            }
+          },
+          {
+            opcode: "isEventOfType",
+            blockType: Scratch.BlockType.BOOLEAN,
+            text: Scratch.translate("Is input event [TYPE]?"),
+            arguments: {
+              TYPE: {
+                menu: "EVENT_TYPES",
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "noteOn"
+              }
+            }
+          },
+          SEPARATOR,
+          {
+            opcode: "getActiveNotes",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Active Notes")
+          },
+          {
+            opcode: "numActiveNotes",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("length of active notes")
+          },
+          {
+            opcode: "getActiveNoteByIndex",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Note [INDEX] of active notes"),
+            arguments: {
+              INDEX: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              }
+            }
+          },
+          {
+            opcode: "setActiveNoteList",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("Set list [LIST] to Active Notes"),
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              }
+            }
+          },
+          SEPARATOR,
+          {
+            opcode: "playNoteForBeats",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("play midi note [NOTE] for [BEATS] beats"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              BEATS: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0.25
+              }
+            }
+          },
+          {
+            opcode: "sendOutputEvent",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("schedule [EVENT] for [POS] beats from now"),
+            arguments: {
+              EVENT: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "Eb4 beats=1/4"
+              },
+              POS: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              }
+            }
+          },
+          {
+            opcode: "makeOutputNote",
+            blockType: Scratch.BlockType.REPORTER,
+            // FUTURE - event_types has "any" type...should rename to EVENT_TYPES_OPTIONAL and make EVENT_TYPES that doesn't have "any"
+            text: Scratch.translate("Note [NOTE] Duration [BEATS] Volume [VELOCITY]% [CHANNEL] [DEVICE]"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              BEATS: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0.25
+              },
+              VELOCITY: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 96
+              },
+              CHANNEL: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "CHANNELS",
+                defaultValue: "1"
+              },
+              DEVICE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "OUTPUT_DEVICES"
+              }
+            }
+          },
+          {
+            opcode: "makeOutputEvent",
+            blockType: Scratch.BlockType.REPORTER,
+            // FUTURE - event_types has "any" type...should rename to EVENT_TYPES_OPTIONAL and make EVENT_TYPES that doesn't have "any"
+            text: Scratch.translate("Event [TYPE] [VALUE1] [VALUE2] [CHANNEL] [DEVICE]"),
+            arguments: {
+              TYPE: {
+                menu: "EVENT_TYPES",
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: 'cc'
+              },
+              VALUE1: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              },
+              VALUE2: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0
+              },
+              CHANNEL: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "CHANNELS",
+                defaultValue: "1"
+              },
+              DEVICE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "OUTPUT_DEVICES"
+              }
+            }
+          },
+          {
+            opcode: "stopAllNotes",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("stop all notes on output devices")
+          },
+          SEPARATOR,
+
+          {
+            opcode: "noteForName",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("MIDI Note # [NOTE]"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "NOTE_NAMES",
+                defaultValue: "C4"
+              }
+            }
+          },
+          {
+            opcode: "nameForNote",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Pitch Name of [NOTE] (use [ACCIDENTAL])"),
+            arguments: {
+              NOTE: {
+                type: Scratch.ArgumentType.NOTE,
+                defaultValue: 60
+              },
+              ACCIDENTAL: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "ACCIDENTALS",
+                defaultValue: 'sharps'
+              }
+            }
+          },
+          {
+            opcode: "normalizeMidiVal",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Scale MIDI Value [VALUE] to min=[MIN] max=[MAX]"),
+            arguments: {
+              VALUE: { type: Scratch.ArgumentType.NUMBER, defaultValue: 0 },
+              MIN: { type: Scratch.ArgumentType.NUMBER, defaultValue: -1 },
+              MAX: { type: Scratch.ArgumentType.NUMBER, defaultValue: 1 }
+            }
+          },
+          {
+            opcode: "eventToJSON",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Convert MIDI Event [EVENT] to JSON"),
+            arguments: {
+              EVENT: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "note Eb4 96 pos=0.25 beats=1/4"
+              }
+            }
+          },
+          {
+            opcode: "jsonToEvent",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("Convert JSON [JSON] to MIDI Event"),
+            arguments: {
+              JSON: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}'
+              }
+            }
+          },
+          SEPARATOR,
+          {
+            opcode: "getMidiStartTime",
+            text: Scratch.translate("MIDI Start Time"),
+            blockType: Scratch.BlockType.REPORTER
+          },
+          {
+            opcode: "getMidiCurrentTime",
+            text: Scratch.translate("MIDI Current Time"),
+            blockType: Scratch.BlockType.REPORTER
+          },
+          {
+            opcode: "clearEvents",
+            text: Scratch.translate("Clear event buffer"),
+            blockType: Scratch.BlockType.COMMAND,
+            arguments: {
+              TIME: {
+                type: Scratch.ArgumentType.NUMBER
+              }
+            }
+          },
+          {
+            opcode: "setMidiEventList",
+            text: Scratch.translate("Set list [LIST] to events in last [TIME] seconds"),
+            blockType: Scratch.BlockType.COMMAND,
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              TIME: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 5
+              }
+            }
+          }
+        ],
+        menus: {
+          EVENT_TYPES: {
+            acceptReporters: true,
+            items: EVENT_TYPES_ITEMS
+          },
+          EVENT_TYPES_OPTIONAL: {
+            acceptReporters: true,
+            items: [
+              ...EVENT_TYPES_ITEMS,
+              { value: ANY_TYPE, text: Scratch.translate("Any") }
+            ]
+          },
+          INPUT_DEVICES: {
+            acceptReporters: true,
+            items: "inputDevicesMenu"
+          },
+          OUTPUT_DEVICES: {
+            acceptReporters: true,
+            items: "outputDevicesMenu"
+          },
+          DEVICE_TYPES: {
+            acceptReporters: true,
+            items: [
+              { value: 'input', text: Scratch.translate("input") },
+              { value: 'output', text: Scratch.translate("output") },
+            ]
+          },
+          DEVICE_PROP: {
+            acceptReporters: true,
+            items: [
+              { value: "id", text: Scratch.translate("Device ID") },
+              { value: "manufacturer", text: Scratch.translate("Manufacturer") },
+              { value: "name", text: Scratch.translate("Device Name") },
+              { value: "state", text: Scratch.translate("State") }
+            ]
+          },
+          NOTE_EVENT_TYPE: {
+            acceptReporters: true,
+            items: [
+              { value: ANY_TYPE, text: Scratch.translate("Note On/Off") },
+              { value: "noteOn" /* Note */, text: Scratch.translate("Note On") },
+              { value: "noteOff" /* NoteOff */, text: Scratch.translate("Note Off") }
+            ]
+          },
+          ACCIDENTALS: {
+            acceptReporters: true,
+            items: [
+              { value: "sharps", text: `♯ ${Scratch.translate("Sharps")}` },
+              { value: "flats", text: `♭ ${Scratch.translate("Flats")}` }
+            ]
+          },
+          NOTE_NAMES: {
+            acceptReporters: true,
+            // the result of these don't need translation - they're just "C4" or "G#6"
+            items: [...MIDI_NOTES.entries()]
+              .map(([index, text]) => ({ value: `${index}`, text }))
+          },
+          CHANNELS: {
+            acceptReporters: true,
+            items: [
+              { value: "0", text: Scratch.translate("any channel") },
+              ..."0".repeat(15).split("").map((_, i) => ({ value: `${i + 1}`, text: `channel ${i + 1}` }))
+            ]
+          },
+          PROPS: {
+            acceptReporters: true,
+            items: Object.entries(eventProps).map(([value, { text }]) => ({ value, text }))
+          },
+          DEVICE_PROPS: {
+            acceptReporters: true,
+            items: [
+              { value: "id", text: Scratch.translate("Id") },
+              { value: "name", text: Scratch.translate("Name") },
+              { value: "state", text: Scratch.translate("State") },
+              { value: "manufacturer", text: Scratch.translate("Manufacturer") }
+            ]
+          },
+          // taken from /Lily/ListTools.js
+          lists: {
+            acceptReporters: true,
+            items: "_getLists",
+          },
+        }
+      };
+    }
+    // taken from /Lily/ListTools.js
+    _getLists() {
+      if (typeof Blockly === "undefined") {
+        return [""];
+      }
+      const lists = Blockly.getMainWorkspace()
+        .getVariableMap()
+        // @ts-expect-error - Blockly not typed yet
+        .getVariablesOfType("list")
+        .map((model) => model.name);
+
+      if (lists.length > 0) {
+        return lists;
+      } else {
+        return [""];
+      }
+    }
+    async initialize({ sysex = false, FORCE = false } = {}, util) {
+      const force = Cast.toBoolean(FORCE);
+      await this.midi.initialize({ sysex, force });
+    }
+    _isAnyArg(val) {
+      return val == undefined || val == "" || val == ANY_TYPE || typeof val === "string" && /^\*|any$/i.test(val);
+    }
+    numDevices({ DEVICE_TYPE }) {
+      this._ensureInitialize();
+      const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
+      const deviceList = deviceType === 'output' ? this.midi.outputs : this.midi.inputs;
+
+      return deviceList.length;
+    }
+    numOutputDevices() {
+      this._ensureInitialize();
+      return this.midi.outputs.length;
+    }
+    getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
+      const index = Cast.toNumber(INDEX);
+      const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
+      const deviceList = deviceType === 'input' ? this.midi.inputs : this.midi.outputs;
+      const device = deviceList[index];
+      if (!device) return "";
+      return device[DEVICE_PROP];
+    }
+    inputDevicesMenu() {
+      const inputList = this.midi.inputs.map((d) => ({ text: d.name || d.id, value: d.id }));
+      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(inputList);
+    }
+    outputDevicesMenu() {
+      const outputList = this.midi.outputs.map((d) => ({ text: d.name || d.id, value: d.id }));
+      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(outputList);
+    }
+    whenNoteOnOff({ NOTE, PRESS }, util) {
+      const isAny = this._isAnyArg(PRESS);
+      let type = isAny ? ['noteOn', 'noteOff'] : [normalizeType(Scratch.Cast.toString(PRESS))];
+
+      const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
+      const last = this.recorder.getLast();
+
+      // filter if only note on or note off
+      if (last &&
+        type.includes(last.type) &&
+        (pitch === undefined || last.pitch === pitch)
+      ) {
+        setThreadMidiValue(util.thread, last);
+        return true;
+      }
+
+      return false;
+    }
+    whenAnyNoteOnOff({ PRESS }, util) {
+      const isAny = this._isAnyArg(PRESS);
+      let type = isAny ? ['noteOn', 'noteOff'] : [normalizeType(Scratch.Cast.toString(PRESS))];
+
+      const last = this.recorder.getLast();
+      // filter if only note on or note off
+      if (last && type.includes(last.type)) {
+        setThreadMidiValue(util.thread, last);
+        return true;
+      }
+
+      return false;
+    }
+    whenMidiEvent({ TYPE }, util) {
+      const isAny = this._isAnyArg(TYPE);
+      const type = isAny ? undefined : normalizeType(Scratch.Cast.toString(TYPE));
+      const last = this.recorder.getLast();
+      if (last && (isAny || last.type === type)) {
+        setThreadMidiValue(util.thread, last);
+        return !!last;
+      }
+      return false;
+    }
+    /**
+     * 
+     * @param {MidiEvent} event
+     * @returns {MidiEvent}
+     */
+    _eventBeatsToSeconds(event) {
+      const tempo = getTempo();
+      const { dur, pos } = event;
+      const out = { ...event };
+      if (dur != undefined) {
+        out.dur = beatsToSeconds(parseFraction(dur), tempo);
+      }
+      if (pos != undefined) {
+        out.pos = beatsToSeconds(parseFraction(pos), tempo);
+      }
+      return out;
+    }
+    playNoteForBeats({ NOTE, BEATS }, util) {
+      const pitch = noteNameToMidiPitch(Cast.toString(NOTE)) || undefined;
+      const beats = typeof BEATS === 'string' && BEATS.includes('/')
+        ? parseFraction(BEATS)
+        : Cast.toNumber(BEATS);
+
+      const event = this._eventBeatsToSeconds({
+        type: 'noteOn',
+        ...(pitch != undefined) && { pitch },
+        dur: beats
+      });
+      this.midi.sendOutputEvent(event);
+    }
+    sendOutputEvent({ EVENT, POS }, util) {
+      const text = Cast.toString(EVENT);
+      const pos = typeof POS === 'string' && POS.includes('/')
+        ? parseFraction(POS)
+        : Cast.toNumber(POS);
+      const event = this._eventBeatsToSeconds({
+        // default value is 0, so if event has something set (like "C#3 pos=1/4 beats=1") then let it take precedence, otherwise override
+        ...(pos > 0) && { pos },
+        ...stringToMidi(text),
+      });
+
+      this.midi.sendOutputEvent(event);
+    }
+    stopAllNotes() {
+      this.midi.panic();
+    }
+    getEventProp({ EVENT, PROP }, util) {
+      const propName = Cast.toString(PROP);
+      const { key = "value", type } = eventProps[propName] ?? {};
+      if (!EVENT) return "";
+      const last = getThreadMidiValue(util.thread);
+      // use cached thread value if available instead of re-parsing
+      const evt = last?._str === EVENT
+        ? last
+        : stringToMidi(EVENT);
+
+      return evt?.[key] ?? "";
+    }
+    lastEvent(args, util) {
+      let last = getThreadMidiValue(util.thread);
+      last || (last = this.recorder.getLast());
+      return last ? midiToString(last) : "";
+    }
+    isNoteActive({ NOTE, CHANNEL }, util) {
+      const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
+      const channel = Cast.toNumber(CHANNEL) || undefined;
+      if (pitch == undefined) {
+        const notes = this.recorder.getActiveNotes(channel);
+        setThreadActiveNotes(util.thread, { channel, notes });
+        return notes.length == 0 ? undefined : notes.reduce((a, b) => a.when > b.when ? a : b);
+      }
+      const note = this.recorder.getActiveNote(pitch, channel || undefined);
+      if (note) {
+        setThreadMidiValue(util.thread, note);
+      }
+      return !!note;
+    }
+    isEventOfType({ TYPE }, util) {
+      const type = TYPE === ANY_TYPE ? undefined : TYPE;
+      let last = getThreadMidiValue(util.thread);
+      last || (last = this.recorder.getLast());
+      return last?.type === type;
+    }
+    noteForName({ NOTE }) {
+      if (typeof NOTE === "number" || /^\d+$/.test(NOTE)) {
+        return Cast.toNumber(NOTE);
+      }
+      const name = Cast.toString(NOTE);
+      return noteNameToMidiPitch(name) || 0;
+    }
+    nameForNote({ NOTE, ACCIDENTAL }, util) {
+      const useFlats = Cast.toString(ACCIDENTAL) === 'flats';
+      let val = Cast.toNumber(NOTE);
+      if (!val && /^[a-g]/i.test(`${NOTE}`)) {
+        val = noteNameToMidiPitch(Cast.toString(NOTE)) || 0;
+      }
+      return midiPitchToNoteName(val, { useFlats });
+    }
+    makeOutputNote({ NOTE, BEATS, VELOCITY, CHANNEL, DEVICE }) {
+      let dur = typeof BEATS === 'string' && BEATS.includes('/')
+        ? parseFraction(BEATS)
+        : Cast.toNumber(BEATS);
+      // sanity check - don't let a note be more than 1 minute
+      // if anyone ever needs a longer note then they should manually write event string
+      dur = Math.max(0, Math.min(dur, 60));
+      // convert from percent to midi value
+      let velocity = (Cast.toNumber(VELOCITY) / 100) * 127;
+      // clamp value
+      // NOTE - if 0 velocity then nothing will happen because treated as note off
+      velocity = Math.max(0, Math.min(velocity, 127));
+      // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
+      const deviceId = Cast.toString(DEVICE);
+      const device = this.midi.outputs.findIndex(d => d.id === deviceId);
+      /** @type {MidiEvent} */
+      const event = {
+        type: 'noteOn',
+        pitch: this.noteForName({ NOTE }),
+        velocity,
+        channel: Cast.toNumber(CHANNEL) || undefined,
+        device: device === -1 ? undefined : device,
+        dur
+      };
+      return midiToString(event);
+    }
+    makeOutputEvent({ TYPE, VALUE1, VALUE2, CHANNEL, DEVICE }) {
+      /** @type {EventType} */
+      // @ts-ignore
+      let type = Cast.toString(TYPE);
+      // TODO make menu for EVENT_TYPE that doesn't include "any"
+      // default is CC - is that right?
+      // @ts-ignore
+      if (type === ANY_TYPE) type = "cc";
+      // UNDOCUMENTED - allow raw number for command.
+      // note that the command lookup restricts command types, so will exclude sysex messages (which are possible security risk but already blocked by browsers anyways)
+      let spec = eventMapping[type];
+      if (!spec && /(0x)?[a-f0-9]+/i.test(type)) {
+        const rawType = /[a-f]/.test(type)
+          ? parseInt(type, 16)
+          : parseInt(type);
+        type = commandLookup[rawType];
+      }
+
+      // clamp values
+      let value1 = Cast.toNumber(VALUE1);
+      // pitchbend can be a bigger number
+      const maxValue1 = spec?.highResParam ? 16384 : 127;
+      value1 = Math.max(0, Math.min(value1, maxValue1));
+
+      let value2 = Cast.toNumber(VALUE2);
+      value2 = Math.max(0, Math.min(value2, 127));
+
+      // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
+      const deviceId = Cast.toString(DEVICE);
+      const device = this.midi.outputs.findIndex(d => d.id === deviceId);
+      // FUTURE this may make sense to get moved out to helper alongside rawMessageToMidi
+      /** @type {MidiEvent} */
+      const event = {
+        type,
+        value1,
+        value2,
+        channel: Cast.toNumber(CHANNEL) || undefined,
+        device: device === -1 ? undefined : device,
+        ...spec?.param1 && { [spec.param1]: value1 },
+        ...spec?.param2 && { [spec.param2]: value2 },
+        ...spec?.highResParam && parseHighResValue(value1, value2)
+      };
+      return midiToString(event);
+    }
+    normalizeMidiVal({ VALUE, MIN, MAX }) {
+      const min = Cast.toNumber(MIN);
+      const max = Cast.toNumber(MAX);
+      const val = Cast.toNumber(VALUE) / 127;
+      return val * (max - min) + min;
+    }
+    getMidiStartTime() {
+      return this.recorder.recordStart;
+    }
+    getMidiCurrentTime() {
+      return this.recorder._now();
+    }
+    clearEvents(args, util) {
+      this.recorder.clear();
+    }
+    setMidiEventList({ LIST, TIME }, util) {
+      const duration = Cast.toNumber(TIME) || 5;
+      const start = this.recorder._now() - duration;
+      const events = this.recorder.getRange(start);
+      if (LIST) {
+        this._upsertList(LIST, events.map((evt) => evt._str), util.target);
+      }
+    }
+    getActiveNotes(args, util) {
+      const notes = Array.from(this.recorder.getActiveNotes());
+      setThreadActiveNotes(util.thread, { notes });
+      return notes.map((note) => note._str ?? midiToString(note)).join("\n");
+    }
+    getActiveNoteByIndex({ INDEX }, util) {
+      const index = Cast.toNumber(INDEX) || 0;
+      let active = getThreadActiveNotes(util.thread);
+      if (!active) {
+        active = { notes: this.recorder.getActiveNotes() };
+        setThreadActiveNotes(util.thread, active);
+      }
+      const note = (active.notes || [])[index];
+      if (note) {
+        setThreadMidiValue(util.thread, note);
+        return note._str;
+      }
+      return '';
+    }
+    setActiveNoteList({ LIST }, util) {
+      const notes = Array.from(this.recorder.getActiveNotes());
+      setThreadActiveNotes(util.thread, { notes });
+      if (LIST) {
+        this._upsertList(LIST, notes.map((note) => note._str), util.target);
+      }
+    }
+    _upsertList(name, value, target) {
+      const vm = globalThis.Scratch.vm;
+      const stageTarget = vm.runtime.getTargetForStage();
+      let listObj = stageTarget?.lookupVariableByNameAndType(name, "list");
+      listObj || (listObj = target?.lookupVariableByNameAndType(name, "list"));
+      if (listObj) {
+        listObj.value = value;
+      }
+    }
+    numActiveNotes(args, util) {
+      let active = getThreadActiveNotes(util.thread);
+      if (!active) {
+        active = { notes: this.recorder.getActiveNotes() };
+        setThreadActiveNotes(util.thread, active);
+      }
+      return active.notes.length;
+    }
+    eventToJSON({ EVENT }, util) {
+      const raw = Cast.toString(EVENT);
+      // NOTE will be null if could not parse
+      const event = stringToMidi(raw);
+      // QUESTION does this need an error handler?
+      return JSON.stringify(event);
+    }
+    jsonToEvent({ JSON }, util) {
+      const raw = Cast.toString(JSON);
+      let event = null;
+      try {
+        event = {
+          ...JSON.parse(raw)
+        };
+        // rename aliases just in case
+        [['beats', 'dur'], ['offset', 'pos'], ['@', 'time']]
+          .filter(([alias, key]) => (alias in event) && event[key] == undefined)
+          .forEach(([alias, key]) => event[key] = event[alias]);
+      } catch (error) { }
+      return event ? midiToString(event) : ""
+    }
+  };
+  Scratch.extensions.register(new MidiExtension());
+})(Scratch);
\ No newline at end of file

From 7998725250267be7f94e6e3ad23afa3a728aabad Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Fri, 7 Mar 2025 00:34:37 -0500
Subject: [PATCH 36/61] updated midi.js - tweak string/parsing/formatting

use "t=<time>" instead of "@<time>". Allow using "type=note pitch=60" instead of "note 60" if need to be verbose. Some bugfixes
---
 extensions/midi/midi.js | 198 ++++++++++++++++++++++++----------------
 1 file changed, 119 insertions(+), 79 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index dbec4a46c6..c44b0ee08a 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -82,23 +82,24 @@
     const height = octave ? parseInt(octave, 10) : defaultOctave;
     return chroma + ((height + 1) * 12);
   }
-  function parseNumValue(text, defaultValue, opts) {
-    if (!text) return defaultValue;
+  function parseNumValue(text, opts) {
+    if (typeof text === 'number') return text;
+    if (!text) return undefined;
     text = text.trim();
-    const useHex = opts?.useHex ?? /[a-f]/.test(text);
+    const useHex = opts?.useHex ?? /[a-f]/i.test(text);
     const radix = useHex ? 16 : 10;
     const val = parseInt(text, radix);
-    return isNaN(val) ? defaultValue : val;
+    return isNaN(val) ? undefined : val;
   }
   function formatHex(value, pad = 2) {
     return Math.round(value).toString(16).padStart(pad, "0");
   }
 
   const eventMapping = {
-    ["noteOn" /* Note */]: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
-    ["noteOff" /* NoteOff */]: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
+    ["noteOn"]: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
+    ["noteOff"]: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
     ["cc" /* CC */]: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
-    ["polyTouch" /* NoteAftertouch */]: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
+    ["polyTouch"]: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
     ["programChange" /* ProgramChange */]: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
     ["pitchBend" /* PitchBend */]: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
     ["channelPressure" /* ChannelPressure */]: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
@@ -121,6 +122,14 @@
     ...Object.keys(eventMapping).map(key => [key.toLowerCase(), key])
   ]);
   const shorthands = Object.fromEntries(Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand]));
+  const paramLookup = {
+    type: 'type', note: 'pitch', pitch: 'pitch',
+    ch: 'channel', channel: 'channel',
+    dev: 'device', device: 'device',
+    t: 'time', time: 'time', "@": 'time',
+    dur: 'dur', duration: 'dur',
+    pos: 'pos', value: 'value2'
+  };
   /**
    * @param {string} value 
    * @returns {EventType | undefined}
@@ -163,10 +172,13 @@
       return formatDefault(shorthands.programChange, program, undefined, opts);
     },
     channelPressure: ({ value1: value }, opts) => formatDefault(shorthands.channelPressure, value, undefined, opts),
-    pitchBend({ value1 = 0, value2 = 64 }, opts) {
+    pitchBend({ value1, value2 }, opts) {
+      if (value1 == undefined) {
+        [value1, value2] = [0, 64];
+      }
       return `${shorthands.pitchBend} ${formatHighResValue(value1, value2, opts)}`;
     },
-    songPosition({ value1 = 0, value2 = 0 }, opts) {
+    songPosition({ value1 = 0, value2 }, opts) {
       return `${shorthands.songPosition} ${formatHighResValue(value1, value2, opts)}`;
     },
     songSelect: ({ value1 }, opts) => formatDefault(shorthands.songSelect, value1, undefined, opts),
@@ -181,7 +193,8 @@
 
   const PREFIX_CHANNEL = "ch";
   const PREFIX_DEVICE = "dev";
-  const PREFIX_WHEN = "@";
+  // const PREFIX_WHEN = "@";
+  const PREFIX_WHEN = 't=';
   const PREFIX_POS = 'pos=';
   const PREFIX_DURATION = 'beats=';
   /** Used when creating lists - treat ~ as empty no value */
@@ -200,16 +213,22 @@
   function midiToString(event, opts = {}) {
     const { noMinify } = opts;
     let type = shorthands[event.type];
+    const spec = eventMapping[event.type] ?? {};
+    // ensure these are set properly
+    const {
+      value1 = event[spec.param1] ?? event[spec.highResParam],
+      value2 = event[spec.param2]
+    } = event;
     const formatter = formatters[event.type];
     if (!formatter) {
       console.debug(`unknown event type ${event.type}`);
       return "";
     }
-    let msg = formatter(event, opts);
+    let msg = formatter({...event, value1, value2}, opts);
     if (event.channel != undefined || noMinify) {
       msg += formatChannel(event.channel, opts);
     }
-    if (event.device || noMinify) {
+    if (event.device != undefined || noMinify) {
       msg += formatDevice(event.device, opts);
     }
     if (event.time != undefined) {
@@ -231,72 +250,86 @@
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
-    const match = midiStringRegex.exec(text);
+    const fullRe = /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
+    const match = fullRe.exec(text);
     if (!match?.groups) return null;
+    // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
+    // ch/dev/@ (channel, device, time) are special keys that don't need =
+    const keyvalRe = /\s*(?<key>\w+(?=\=)|ch|dev|@)=?(?<val>\S+)\s*/g;
+    /** @type {{[K in keyof typeof paramLookup]?: keyof MidiEvent}} */
+    const extras = Object.fromEntries(
+      [...match.groups.keyvals?.matchAll(keyvalRe)]
+        // paramLookup converts "t=2" into "time=2"
+        .map(({groups: {key, val}}) => [paramLookup[key] || key, val])
+    );
     let {
-      type: shorthand,
-      pitch,
-      data1,
-      data2,
-      channel: rawChannel,
-      device: rawDevice,
-      time,
-      pos,
-      dur
+      type: shorthand = extras.type,
+      pitch = extras.pitch, data1, data2
     } = match.groups;
-    const value1 = data1 ? parseNumValue(data1, undefined, opts) : undefined;
-    const value2 = data2 ? parseNumValue(data2, undefined, opts) : undefined;
-    /** @type {EventType | 'rest'} */
-    let type = normalizeType(shorthand);
 
-    if (!type && shorthand === REST_LITERAL) {
-      type = 'rest';
-    }
-    type || (type = "noteOn" /* Note */);
-    const spec = eventMapping[type];
+    // midi value1 can be specified as pitch or as number
+    const value1 = pitch
+      ? noteNameToMidiPitch(pitch, opts.defaultOctave)
+      : parseNumValue(data1, opts);
+
+    let value2 = parseNumValue(data2, opts);
+
     /** @type {MidiEvent} */
     const event = {
-      type,
-      channel: parseNumValue(rawChannel, undefined, opts),
-      device: parseNumValue(rawDevice, undefined, opts)
+      type: shorthand === REST_LITERAL
+        ? 'rest'
+        : normalizeType(shorthand),
+      ...(value1 != undefined) && {value1},
+      ...(value2 != undefined) && {value2},
+      channel: parseNumValue(extras.ch ?? extras.channel, opts),
+      device: parseNumValue(extras.dev ?? extras.device, opts),
+      ...extras.time && { time: parseTimespan(extras.t ?? extras.time)},
+      // REVIEW is pos even needed? it's for setting output in beats, but setting time would make more sense instead
+      ...extras.pos && { pos: parseFraction(extras.pos)},
+      ...extras.dur && { dur: parseFraction(extras.dur)},
     };
-    if (time) {
-      event.time = parseTimespan(time);
-    }
-    if (pos) {
-      event.pos = parseFraction(pos);
-      // REVIEW is this right?
-      event.time = (event.time || 0) + event.pos;
-    }
-    if (dur) {
-      event.dur = parseFraction(dur);
-    }
-    switch (type) {
-      case "noteOn" /* Note */:
-      case "noteOff" /* NoteOff */:
-      case "polyTouch" /* NoteAftertouch */:
-        const note = pitch ? noteNameToMidiPitch(pitch, opts.defaultOctave) : value1 || null;
-        if (note == null) return null;
-        const velocity = pitch ? value1 : value2;
-        if (event.type !== "polyTouch" /* NoteAftertouch */ && velocity == 0) {
-          event.type = "noteOff" /* NoteOff */;
+
+    // default to note event if has pitch (off if velocity = 0)
+    if (!event.type && value1 >= 0) {
+      event.type = 'noteOn';
+    } else if (!event.type) {
+      // no type set, invalid input
+      return null;
+    }
+    const spec = eventMapping[event.type];
+    switch (event.type) {
+      case "noteOn":
+      case "noteOff":
+        if (value1 == undefined) return null;
+        if (value2 === 0) event.type = 'noteOff';
+        if (value2 == undefined) {
+          event.value2 = event.velocity ?? event.value ?? (event.type === 'noteOn' ? 96 : 0);
+        }
+        break;
+      case "polyTouch":
+        // these types have note pitch
+        if (event.value1 == undefined) return null;
+        if (value2 == undefined) {
+          event.value2 = event.value ?? event.velocity ?? 64;
         }
-        event.value1 = note;
-        event.value2 = velocity ?? 64;
         break;
-      case "cc" /* CC */:
+      case "cc":
+        if (value2 == undefined) {
+          event.value2 = event.value;
+          value2 = event.value2
+        }
         if (value1 == undefined || value2 == undefined) return null;
-        event.value1 = value1;
-        event.value2 = value2;
         break;
       case "programChange" /* ProgramChange */:
       case "channelPressure" /* ChannelPressure */:
       case "songSelect" /* SongSelect */:
-        event.value1 = value1 || 0;
+        // default to 0 for these types
+        event.value1 ||= event.value ?? 0;
         break;
       case "songPosition" /* SongPosition */:
       case "pitchBend" /* PitchBend */:
         if (value1 == undefined) return null;
+        // these two types have a higher precision value
         const { value: highResValue, ...normedValues } = parseHighResValue(value1, value2);
         Object.assign(event, normedValues);
         event[spec.highResParam ?? "value"] = highResValue;
@@ -311,6 +344,7 @@
       case "rest":
       // do nothing
     }
+    // look at eventMap to give 'friendly' names to value1/value2 (ex. "pitch", "velocity")
     if (spec?.param1 && event.value1 != undefined) {
       event[spec.param1] = event.value1;
     }
@@ -402,7 +436,7 @@
       value2: value >> 7
     };
   }
-  function msbLsbToValue(lsb, msb) {
+  function msbLsbToValue(lsb, msb = 0) {
     return (msb << 7) + lsb;
   }
   function parseHighResValue(value1, value2) {
@@ -501,7 +535,7 @@
     };
   }
   function isPitchedEvent(type) {
-    return !!type && (type === "noteOn" /* Note */ || type === "noteOff" /* NoteOff */ || type === "polyTouch" /* NoteAftertouch */);
+    return !!type && (type === "noteOn" || type === "noteOff" || type === "polyTouch");
   }
 
   // Make a full array of notes in full midi range from 0 (C-1) to 127 (G-9)
@@ -513,13 +547,13 @@
   const eventProps = {
     type: { key: "type", text: Scratch.translate("Event Type") },
     pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
-    velocity: { key: "velocity", type: "noteOn" /* Note */, text: Scratch.translate("Velocity") },
+    velocity: { key: "velocity", type: "noteOn", text: Scratch.translate("Velocity") },
     ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
     ccValue: { key: "value", type: "cc" /* CC */, text: Scratch.translate("CC Value") },
     channel: { key: "channel", text: Scratch.translate("Channel") },
     device: { key: "device", text: Scratch.translate("Device") },
     pitchbend: { key: "value", type: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
-    aftertouch: { key: "value", type: "polyTouch" /* NoteAftertouch */, text: Scratch.translate("Aftertouch") },
+    aftertouch: { key: "value", type: "polyTouch", text: Scratch.translate("Aftertouch") },
     time: { key: "time", text: Scratch.translate("Timestamp") }
   };
 
@@ -815,13 +849,13 @@
         this._prune(when);
       }
       switch (evt.type) {
-        case "noteOn" /* Note */:
+        case "noteOn":
           this._onNoteOn(evt);
           break;
-        case "noteOff" /* NoteOff */:
+        case "noteOff":
           this._onNoteOff(doc);
           break;
-        case "polyTouch" /* NoteAftertouch */:
+        case "polyTouch":
           this._onNoteTouch(doc);
           break;
         case "cc" /* CC */:
@@ -905,13 +939,13 @@
       return this.getLast(undefined, undefined, channel);
     }
     getLastNote(pitch, channel) {
-      return this.getLast("noteOn" /* Note */, pitch, channel);
+      return this.getLast("noteOn", pitch, channel);
     }
     getLastCC(cc, channel) {
       return this.getLast("cc" /* CC */, cc, channel);
     }
     getLastAftertouch(pitch, channel) {
-      return this.getLast("polyTouch" /* NoteAftertouch */, pitch, channel);
+      return this.getLast("polyTouch", pitch, channel);
     }
     getLast(type, value1, channel) {
       if (type === value1 === channel === undefined) {
@@ -1063,10 +1097,10 @@
     }
     getInfo() {
       const EVENT_TYPES_ITEMS = [
-        { value: "noteOn" /* Note */, text: Scratch.translate("Note On") },
-        { value: "noteOff" /* NoteOff */, text: Scratch.translate("Note Off") },
+        { value: "noteOn", text: Scratch.translate("Note On") },
+        { value: "noteOff", text: Scratch.translate("Note Off") },
         { value: "cc" /* CC */, text: Scratch.translate("CC") },
-        { value: "polyTouch" /* NoteAftertouch */, text: Scratch.translate("AfterTouch") },
+        { value: "polyTouch", text: Scratch.translate("AfterTouch") },
         { value: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
         { value: "programChange" /* ProgramChange */, text: Scratch.translate("Program Change") },
         { value: "channelPressure" /* ChannelPressure */, text: Scratch.translate("Channel Pressure") }
@@ -1395,16 +1429,16 @@
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "note Eb4 96 pos=0.25 beats=1/4"
+                defaultValue: "note Eb4 96 t=0.5 dur=0.25"
               }
             }
           },
           {
             opcode: "jsonToEvent",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Convert JSON [JSON] to MIDI Event"),
+            text: Scratch.translate("Convert JSON [TEXT] to MIDI Event"),
             arguments: {
-              JSON: {
+              TEXT: {
                 type: Scratch.ArgumentType.STRING,
                 defaultValue: '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}'
               }
@@ -1487,8 +1521,8 @@
             acceptReporters: true,
             items: [
               { value: ANY_TYPE, text: Scratch.translate("Note On/Off") },
-              { value: "noteOn" /* Note */, text: Scratch.translate("Note On") },
-              { value: "noteOff" /* NoteOff */, text: Scratch.translate("Note Off") }
+              { value: "noteOn", text: Scratch.translate("Note On") },
+              { value: "noteOff", text: Scratch.translate("Note Off") }
             ]
           },
           ACCIDENTALS: {
@@ -1862,11 +1896,17 @@
       const raw = Cast.toString(EVENT);
       // NOTE will be null if could not parse
       const event = stringToMidi(raw);
+
+      // REVIEW - remove value1/value2 if already specified by event spec?
+      if (event && ('pitch' in event || 'value' in event)) {
+        delete event.value1;
+        delete event.value2;
+      }
       // QUESTION does this need an error handler?
       return JSON.stringify(event);
     }
-    jsonToEvent({ JSON }, util) {
-      const raw = Cast.toString(JSON);
+    jsonToEvent({ TEXT }, util) {
+      const raw = Cast.toString(TEXT);
       let event = null;
       try {
         event = {

From 2ccd65584b55697b9e9918f0be82999e3eac78df Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 10 Mar 2025 10:02:42 -0400
Subject: [PATCH 37/61] midi - cleanup comments and types

---
 extensions/midi/midi.js | 201 ++++++++++++++++++++++++++--------------
 1 file changed, 132 insertions(+), 69 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index c44b0ee08a..f682fbe04c 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -12,13 +12,15 @@
 
   const EXT_ID = "extmidi";
 
+//#region utils
+
   /** 
    * This section includes logic to map raw data coming from the 'midimessage'
    * event into a friendly object representation of the event
    * 
    * 
    * // definition for the parsed midi event
-   * @typedef {keyof typeof eventMapping} EventType
+   * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset'} EventType
    * @typedef {object} MidiEvent
    * @property {EventType | 'rest'} type
    * @property {number} [value1]
@@ -32,7 +34,7 @@
    * @property {number} [value]
    * @property {number} [pos]
    * @property {number} [dur]
-   * @property {string} [_str]
+   * @property {string} [_str] cached string representation of this event
    * 
    * 
    * @typedef {object} FormatOptions
@@ -44,6 +46,7 @@
    * @property {boolean} [fixedWidth]
    * @property {boolean} [useHex]
    * @property {number} [defaultOctave]
+   * 
    */
 
   /**
@@ -95,33 +98,52 @@
     return Math.round(value).toString(16).padStart(pad, "0");
   }
 
+  /**
+   * IMPORTANT! This mapping is key in translating raw midi messages to/from their object/string representation.
+   * @typedef {object} EventSpec Definition of midi event type and how to convert to/from raw midi
+   * @property {string} shorthand Short name used in string representation
+   * @property {number} command   Actual midi command bytes (1st byte along with channel)
+   * @property {string} description English description of type TODO - translate if ever exposed in UI
+   * @property {'pitch' | 'cc' | 'value'} [param1] - corresponding key for 2nd byte of raw message
+   * @property {'velocity' | 'value'} [param2] - corresponding key for 3rd byte of raw message
+   * @property {'value'} [highResParam] - corresponding key for "high res" param that goes from 0-16384 instead of 127
+   * @property {[data1: number, data2: number]} [defaults] - default values if not otherwise specified
+   */
+
+  /**
+   * @type {Record<EventType, EventSpec>}
+   */
   const eventMapping = {
-    ["noteOn"]: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
-    ["noteOff"]: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
-    ["cc" /* CC */]: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
-    ["polyTouch"]: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
-    ["programChange" /* ProgramChange */]: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
-    ["pitchBend" /* PitchBend */]: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
-    ["channelPressure" /* ChannelPressure */]: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
-    ["songPosition" /* SongPosition */]: { shorthand: "songpos", command: 242, description: "Song Position Pointer (Sys Common)", highResParam: "value" },
-    ["songSelect" /* SongSelect */]: { shorthand: "songsel", command: 243, description: "Song Select (Sys Common)", param1: "value" },
-    ["clock" /* Clock */]: { shorthand: "clock", command: 248, description: "Timing Clock (Sys Realtime)" },
-    ["start" /* Start */]: { shorthand: "start", command: 250, description: "Start (Sys Realtime)" },
-    ["continue" /* Continue */]: { shorthand: "continue", command: 251, description: "Continue (Sys Realtime)" },
-    ["stop" /* Stop */]: { shorthand: "stop", command: 252, description: "Stop (Sys Realtime)" },
-    ["activeSensing" /* ActiveSensing */]: { shorthand: "ping", command: 254, description: "Active Sensing (Sys Realtime)" },
-    ["reset" /* Reset */]: { shorthand: "reset", command: 255, description: "System Reset (Sys Realtime)" }
+    noteOn: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
+    noteOff: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
+    cc: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
+    polyTouch: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
+    programChange: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
+    pitchBend: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
+    channelPressure: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
+    songPosition: { shorthand: "songpos", command: 242, description: "Song Position Pointer (Sys Common)", highResParam: "value" },
+    songSelect: { shorthand: "songsel", command: 243, description: "Song Select (Sys Common)", param1: "value" },
+    clock: { shorthand: "clock", command: 248, description: "Timing Clock (Sys Realtime)" },
+    start: { shorthand: "start", command: 250, description: "Start (Sys Realtime)" },
+    continue: { shorthand: "continue", command: 251, description: "Continue (Sys Realtime)" },
+    stop: { shorthand: "stop", command: 252, description: "Stop (Sys Realtime)" },
+    activeSensing: { shorthand: "ping", command: 254, description: "Active Sensing (Sys Realtime)" },
+    reset: { shorthand: "reset", command: 255, description: "System Reset (Sys Realtime)" }
   };
   /** @type {Map<number, EventType>} */
   // @ts-ignore
   const commandLookup = new Map(Object.entries(eventMapping).map(([key, { command }]) => [command, key]));
   /** @type {Map<string, EventType>} */
-  // @ts-ignore
-  const shorthandLookup = Object.fromEntries([
+    const shorthandLookup = Object.fromEntries([
     ...Object.entries(eventMapping).map(([key, { shorthand }]) => [shorthand, key]),
     ...Object.keys(eventMapping).map(key => [key.toLowerCase(), key])
   ]);
   const shorthands = Object.fromEntries(Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand]));
+
+
+  /** aliases for MidiEvent keys
+   * the allows for more permissive translation of input strings, i.e. ch10 === channel=10
+   * @type {Record<string, keyof MidiEvent>} */
   const paramLookup = {
     type: 'type', note: 'pitch', pitch: 'pitch',
     ch: 'channel', channel: 'channel',
@@ -130,6 +152,16 @@
     dur: 'dur', duration: 'dur',
     pos: 'pos', value: 'value2'
   };
+  
+  // These are how different midi event keys are split. ch and dev are special cases that don't include =, since they're common. Other params use = to allow arbitrary additional properties if needed
+  const PREFIX_CHANNEL = "ch";
+  const PREFIX_DEVICE = "dev";
+  const PREFIX_WHEN = 't=';
+  const PREFIX_POS = 'pos=';
+  const PREFIX_DURATION = 'dur=';
+  /** Used when creating lists - treat ~ as empty no value */
+  const REST_LITERAL = '~';
+
   /**
    * @param {string} value 
    * @returns {EventType | undefined}
@@ -154,7 +186,10 @@
   function formatNoteType(type, note, value, opts = {}) {
     return `${type ? type + " " : ""}${midiPitchToNoteName(note, opts)} ${formatNumValue(value, opts)}`;
   }
-  /** @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>} */
+  /** 
+   * This is a mapping of midi events and their string representation
+   * @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>}
+   */
   const formatters = {
     noteOn({ value1: note, value2: velocity = eventMapping.noteOn.defaults[1] }, opts = {}) {
       return formatNoteType(opts?.noMinify ? shorthands.noteOn : undefined, note, velocity, opts);
@@ -191,21 +226,10 @@
     reset: () => shorthands.reset
   };
 
-  const PREFIX_CHANNEL = "ch";
-  const PREFIX_DEVICE = "dev";
-  // const PREFIX_WHEN = "@";
-  const PREFIX_WHEN = 't=';
-  const PREFIX_POS = 'pos=';
-  const PREFIX_DURATION = 'beats=';
-  /** Used when creating lists - treat ~ as empty no value */
-  const REST_LITERAL = '~';
-
-  // FUTURE - convert everything after data1/data2 to an iterator to parse tokens so they don't need to be in specific order
-  // FUTURE - support unicode note durations https://en.wikipedia.org/wiki/Musical_Symbols_(Unicode_block)
-  const midiStringRegex = /^\s*(?<type>[a-zA-Z]{2,})?\s*(?<pitch>[A-G][#b♯♭_]*-?\d?)?\s*(?<data1>\b-?[0-9a-f]{1,5}\b)?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(ch=?(?<channel>[0-9a-f]{1,2}))?\s*(dev=?(?<device>[0-9a-f]))?\s*((@|time=)\s*(?<time>[\d:.]+))?\s*((pos|offset)=(?<pos>[\d./]+))?\s*((beats|dur)=(?<dur>[\d:./]+))?\s*$/;
 
   /**
-   * 
+   * convert midi event to string.
+   * The opts includes more formatting options than available through the current scratch blocks available.
    * @param {MidiEvent} event 
    * @param {FormatOptions} opts 
    * @returns 
@@ -245,18 +269,20 @@
 
   /**
    * convert a string representation of a note to a midievent
+   * FUTURE - support unicode note durations? https://en.wikipedia.org/wiki/Musical_Symbols_(Unicode_block)
    * @param {string} text 
    * @param {FormatOptions} opts 
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
+    if (typeof text !== 'string') text = `${String(text) ?? ''}`;
     const fullRe = /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
     const match = fullRe.exec(text);
     if (!match?.groups) return null;
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
     // ch/dev/@ (channel, device, time) are special keys that don't need =
     const keyvalRe = /\s*(?<key>\w+(?=\=)|ch|dev|@)=?(?<val>\S+)\s*/g;
-    /** @type {{[K in keyof typeof paramLookup]?: keyof MidiEvent}} */
+    /** @type {{[K in keyof MidiEvent]?: string}} */
     const extras = Object.fromEntries(
       [...match.groups.keyvals?.matchAll(keyvalRe)]
         // paramLookup converts "t=2" into "time=2"
@@ -281,9 +307,9 @@
         : normalizeType(shorthand),
       ...(value1 != undefined) && {value1},
       ...(value2 != undefined) && {value2},
-      channel: parseNumValue(extras.ch ?? extras.channel, opts),
-      device: parseNumValue(extras.dev ?? extras.device, opts),
-      ...extras.time && { time: parseTimespan(extras.t ?? extras.time)},
+      channel: parseNumValue(extras.channel, opts),
+      device: parseNumValue(extras.device, opts),
+      ...extras.time && { time: parseTimespan(extras.time)},
       // REVIEW is pos even needed? it's for setting output in beats, but setting time would make more sense instead
       ...extras.pos && { pos: parseFraction(extras.pos)},
       ...extras.dur && { dur: parseFraction(extras.dur)},
@@ -320,26 +346,26 @@
         }
         if (value1 == undefined || value2 == undefined) return null;
         break;
-      case "programChange" /* ProgramChange */:
-      case "channelPressure" /* ChannelPressure */:
-      case "songSelect" /* SongSelect */:
+      case "programChange":
+      case "channelPressure":
+      case "songSelect":
         // default to 0 for these types
         event.value1 ||= event.value ?? 0;
         break;
-      case "songPosition" /* SongPosition */:
-      case "pitchBend" /* PitchBend */:
+      case "songPosition":
+      case "pitchBend":
         if (value1 == undefined) return null;
         // these two types have a higher precision value
         const { value: highResValue, ...normedValues } = parseHighResValue(value1, value2);
         Object.assign(event, normedValues);
         event[spec.highResParam ?? "value"] = highResValue;
         break;
-      case "clock" /* Clock */:
-      case "start" /* Start */:
-      case "continue" /* Continue */:
-      case "stop" /* Stop */:
-      case "activeSensing" /* ActiveSensing */:
-      case "reset" /* Reset */:
+      case "clock":
+      case "start":
+      case "continue":
+      case "stop":
+      case "activeSensing":
+      case "reset":
         break;
       case "rest":
       // do nothing
@@ -459,7 +485,7 @@
   }
 
   /**
-   * 
+   * parse raw input midi bytes
    * @param {Uint8Array} data 
    * @returns {MidiEvent | null}
    */
@@ -493,7 +519,7 @@
     return event;
   }
   /**
-   * 
+   * convert midi event into bytes expected by MidiOut.send
    * @param {MidiEvent} event
    * @returns {Uint8Array}
    */
@@ -521,7 +547,7 @@
     return new Uint8Array([commandAndChannel, value1, ...(value2 !== undefined ? [value2] : [])]);
   }
   /**
-   * 
+   * read the "pos" / "dur" values of an event as relative time vs. a fixed wall-clock time
    * @param {Pick<MidiEvent, 'time' | 'pos' | 'dur'>} event 
    * @param {number} [offsetMs] time to return relative to. Default is now
    */
@@ -543,21 +569,38 @@
     .flatMap((_, i) => SHARPS.map(c => `${c}${i - 1}`))
     .slice(0, 128);
 
+  /**
+   * represents "any note" or "any device" etc. in menus
+   */
   const ANY_TYPE = "*";
+  /**
+   * Scratch menu items of @see {MidiEvent} properties
+   */
   const eventProps = {
     type: { key: "type", text: Scratch.translate("Event Type") },
     pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
     velocity: { key: "velocity", type: "noteOn", text: Scratch.translate("Velocity") },
     ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
-    ccValue: { key: "value", type: "cc" /* CC */, text: Scratch.translate("CC Value") },
+    ccValue: { key: "value", type: "cc", text: Scratch.translate("CC Value") },
     channel: { key: "channel", text: Scratch.translate("Channel") },
     device: { key: "device", text: Scratch.translate("Device") },
-    pitchbend: { key: "value", type: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
+    pitchbend: { key: "value", type: "pitchBend", text: Scratch.translate("Pitch Bend") },
     aftertouch: { key: "value", type: "polyTouch", text: Scratch.translate("Aftertouch") },
     time: { key: "time", text: Scratch.translate("Timestamp") }
   };
 
-  // src/midi/midi-backend.ts
+//#endregion utils
+
+//#region wrapper
+  /**
+   * This is a singleton wrapper class around the WebMIDI API. It:
+   * 1) Handles requesting API permission and reporting Input/Output devices
+   * 2) Translate raw midi input events into friendlier @see {MidiEvent} objects
+   * 3) Sends out midi events, translating MidiEvents into the raw midi payload
+   * 4) Keeps track of "note on"/"note off" messages to support "panic" stopping midi output
+   * 
+   * It extends the native EventTarget class to dispatch events
+   */
   class MidiBackend extends EventTarget {
     constructor() {
       super();
@@ -576,7 +619,7 @@
         dur: 0.5,
         velocity: 196
       }
-      // TIP! If you use arrow functions on class methos then 'this' is automatically bound correctly, even if using as event listener
+      // TIP! If you use arrow functions on class methods then 'this' is automatically bound correctly, even if using as event listener
       this.refreshDevices = () => {
         for (const input of this.access.inputs.values()) {
           if (!this.inputs.some((d) => d.id === input.id)) {
@@ -799,7 +842,15 @@
     }
   };
 
-  // src/midi/midi-recorder.ts
+  /**
+   * this singleton keeps track of events in order to:
+   * 1) Report the "last" value for a given CC/note
+   * 2) Track "active" notes
+   * 3) Keep short term memory of events to avoid missing events because of scratch's slower event sample rate
+   * 4) Allow recording events for playback/storage
+   * 
+   * It keeps track of midi events, automatically pruning them after a certain time period or # of max entries have been reached (lazy, it doesn't actively poll)
+   */
   class MidiRecorder extends EventTarget {
     constructor() {
       super();
@@ -858,7 +909,7 @@
         case "polyTouch":
           this._onNoteTouch(doc);
           break;
-        case "cc" /* CC */:
+        case "cc":
           Object.assign(this.ccs, {
             [`${evt.cc}_${evt.channel}`]: evt,
             [`${evt.cc}`]: evt
@@ -942,7 +993,7 @@
       return this.getLast("noteOn", pitch, channel);
     }
     getLastCC(cc, channel) {
-      return this.getLast("cc" /* CC */, cc, channel);
+      return this.getLast("cc", cc, channel);
     }
     getLastAftertouch(pitch, channel) {
       return this.getLast("polyTouch", pitch, channel);
@@ -951,7 +1002,7 @@
       if (type === value1 === channel === undefined) {
         return this.buffer[this.buffer.length - 1];
       }
-      if (type === "cc" /* CC */ && value1) {
+      if (type === "cc" && value1) {
         const key = channel != undefined ? `${value1}_${channel}` : `${value1}`;
         const foundCC = this.ccs[key];
         if (foundCC) return foundCC;
@@ -1043,22 +1094,32 @@
     return seconds * tempo / 60;
   }
 
-  //#endregion
+  //#endregion wrapper
 
-  //#region Scratch Extension
+//#region Scratch Extension
 
+  // hardcoded mapping of hats events, b/c I'll never remember the convention otherwise
   const HATS = {
     NOTE: `${EXT_ID}_whenNoteOnOff`,
     NOTEANY: `${EXT_ID}_whenAnyNoteOnOff`,
     MIDI: `${EXT_ID}_whenMidiEvent`
+    // not currently implemented
+    // CC: `${EXT_ID}_whenCC`
   };
-  /** @type {'---'} */
+  /**
+   * Block separator constant
+   * @type {'---'}
+   */
   const SEPARATOR = '---';
   const { Cast } = Scratch;
+
   class MidiExtension {
     constructor() {
       this.midi = new MidiBackend();
       this.recorder = new MidiRecorder();
+      /**
+       * Lazy initialize midi - only upon first executing, and used in other calls to make sure it gets triggered
+       */
       this._ensureInitialize = (evt) => {
         if (this.midi.status === "pending" /* Initial */) {
           this.initialize().catch(() => {
@@ -1089,7 +1150,8 @@
             vm.runtime.startHats(HATS.NOTE);
             vm.runtime.startHats(HATS.NOTEANY);
             break;
-          // case "cc" /* CC */:
+          // FUTURE - support a "whenCC" block if needed
+          // case "cc":
           //   vm.runtime.startHats(HATS.CC);
           //   break;
         }
@@ -1099,11 +1161,11 @@
       const EVENT_TYPES_ITEMS = [
         { value: "noteOn", text: Scratch.translate("Note On") },
         { value: "noteOff", text: Scratch.translate("Note Off") },
-        { value: "cc" /* CC */, text: Scratch.translate("CC") },
+        { value: "cc", text: Scratch.translate("CC") },
         { value: "polyTouch", text: Scratch.translate("AfterTouch") },
-        { value: "pitchBend" /* PitchBend */, text: Scratch.translate("Pitch Bend") },
-        { value: "programChange" /* ProgramChange */, text: Scratch.translate("Program Change") },
-        { value: "channelPressure" /* ChannelPressure */, text: Scratch.translate("Channel Pressure") }
+        { value: "pitchBend", text: Scratch.translate("Pitch Bend") },
+        { value: "programChange", text: Scratch.translate("Program Change") },
+        { value: "channelPressure", text: Scratch.translate("Channel Pressure") }
       ];
 
       return {
@@ -1112,6 +1174,7 @@
         menuIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
         blockIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
         blocks: [
+          // FUTURE - could force requesting permissions and checking midi device status. Usually refreshing is safer option
           // {
           //   opcode: "initialize",
           //   text: Scratch.translate("Initialize force? [FORCE]"),
@@ -1321,7 +1384,6 @@
           {
             opcode: "makeOutputNote",
             blockType: Scratch.BlockType.REPORTER,
-            // FUTURE - event_types has "any" type...should rename to EVENT_TYPES_OPTIONAL and make EVENT_TYPES that doesn't have "any"
             text: Scratch.translate("Note [NOTE] Duration [BEATS] Volume [VELOCITY]% [CHANNEL] [DEVICE]"),
             arguments: {
               NOTE: {
@@ -1350,7 +1412,6 @@
           {
             opcode: "makeOutputEvent",
             blockType: Scratch.BlockType.REPORTER,
-            // FUTURE - event_types has "any" type...should rename to EVENT_TYPES_OPTIONAL and make EVENT_TYPES that doesn't have "any"
             text: Scratch.translate("Event [TYPE] [VALUE1] [VALUE2] [CHANNEL] [DEVICE]"),
             arguments: {
               TYPE: {
@@ -1920,5 +1981,7 @@
       return event ? midiToString(event) : ""
     }
   };
+
+//#endregion
   Scratch.extensions.register(new MidiExtension());
 })(Scratch);
\ No newline at end of file

From 1a285e91c777b5c6fe4b34142dd66e09cdf8440f Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 10 Mar 2025 10:28:31 -0400
Subject: [PATCH 38/61] Update midi.js

---
 extensions/midi/midi.js | 981 +++++++++++++++++++++++++---------------
 1 file changed, 617 insertions(+), 364 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index f682fbe04c..1fb8cac386 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -12,13 +12,13 @@
 
   const EXT_ID = "extmidi";
 
-//#region utils
+  //#region utils
 
-  /** 
+  /**
    * This section includes logic to map raw data coming from the 'midimessage'
    * event into a friendly object representation of the event
-   * 
-   * 
+   *
+   *
    * // definition for the parsed midi event
    * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset'} EventType
    * @typedef {object} MidiEvent
@@ -35,8 +35,8 @@
    * @property {number} [pos]
    * @property {number} [dur]
    * @property {string} [_str] cached string representation of this event
-   * 
-   * 
+   *
+   *
    * @typedef {object} FormatOptions
    * @property {number} [tempo]
    * @property {boolean} [useFlats]
@@ -46,7 +46,7 @@
    * @property {boolean} [fixedWidth]
    * @property {boolean} [useHex]
    * @property {number} [defaultOctave]
-   * 
+   *
    */
 
   /**
@@ -55,13 +55,16 @@
    * https://www.midi.org/specifications/item/table-1-summary-of-midi-message
    *
    * adapted from https://github.com/fheyen/musicvis-lib/blob/905edbdc8280e8ca76a329ffc83a160f3cda674a/src/fileFormats/Midi.js#L41
-   * 
+   *
    * each key (the "EventType" relates to a raw midi "command". The "shorthand" could
    * be used to format midi events to string (future). param1 and param2 determine what property of the object the value1 + value2 bytes mean (i.e. noteOn gets pitch + velocity, cc gets cc# and value)
    */
   const SHARPS = "C C# D D# E F F# G G# A A# B".split(" ");
   const FLATS = "C Db D Eb E F Gb G Ab A Bb B".split(" ");
-  function midiPitchToNoteName(midi, { useFlats = false, fixedWidth = false } = {}) {
+  function midiPitchToNoteName(
+    midi,
+    { useFlats = false, fixedWidth = false } = {}
+  ) {
     if (!isFinite(midi)) return "";
     let chroma = (useFlats ? FLATS : SHARPS)[midi % 12];
     if (fixedWidth) chroma = chroma.padEnd(2, "_");
@@ -70,23 +73,30 @@
   }
   /**
    * convert a note string name (or raw midi number) to midi number value
-   * @param {string} note 
-   * @param {number} [defaultOctave] 
+   * @param {string} note
+   * @param {number} [defaultOctave]
    * @returns {number | null}
    */
   function noteNameToMidiPitch(note, defaultOctave = 4) {
-    const parts = /(?<pitch>[A-G])(?<flat>[b♭]+)?(?<sharp>[#♯]+)?_?(?<octave>-?\d+)?/i.exec(note || '');
+    const parts =
+      /(?<pitch>[A-G])(?<flat>[b♭]+)?(?<sharp>[#♯]+)?_?(?<octave>-?\d+)?/i.exec(
+        note || ""
+      );
     if (!parts?.groups) {
-      const numVal = typeof note === 'string' ? parseInt(note.trim(), 10) : +note;
-      return (numVal >= 0 && numVal <= 127) ? numVal : null;
+      const numVal =
+        typeof note === "string" ? parseInt(note.trim(), 10) : +note;
+      return numVal >= 0 && numVal <= 127 ? numVal : null;
     }
     const { pitch, octave, flat, sharp } = parts.groups;
-    let chroma = SHARPS.indexOf(pitch.toUpperCase()) - (flat?.length || 0) + (sharp?.length || 0);
+    let chroma =
+      SHARPS.indexOf(pitch.toUpperCase()) -
+      (flat?.length || 0) +
+      (sharp?.length || 0);
     const height = octave ? parseInt(octave, 10) : defaultOctave;
-    return chroma + ((height + 1) * 12);
+    return chroma + (height + 1) * 12;
   }
   function parseNumValue(text, opts) {
-    if (typeof text === 'number') return text;
+    if (typeof text === "number") return text;
     if (!text) return undefined;
     text = text.trim();
     const useHex = opts?.useHex ?? /[a-f]/i.test(text);
@@ -114,56 +124,147 @@
    * @type {Record<EventType, EventSpec>}
    */
   const eventMapping = {
-    noteOn: { shorthand: "note", command: 144, description: "Note-on", param1: "pitch", param2: "velocity", defaults: [60, 96] },
-    noteOff: { shorthand: "off", command: 128, description: "Note-off", param1: "pitch", param2: "velocity", defaults: [60, 0] },
-    cc: { shorthand: "cc", command: 176, description: "Continuous controller", param1: "cc", param2: "value", defaults: [0, 0] },
-    polyTouch: { shorthand: "touch", command: 160, description: "Aftertouch", param1: "pitch", param2: "value", defaults: [60, 64] },
-    programChange: { shorthand: "program", command: 192, description: "Patch change", param1: "value" },
-    pitchBend: { shorthand: "bend", command: 224, description: "Pitch bend", highResParam: "value" },
-    channelPressure: { shorthand: "pressure", command: 208, description: "Channel Pressure", param1: "value" },
-    songPosition: { shorthand: "songpos", command: 242, description: "Song Position Pointer (Sys Common)", highResParam: "value" },
-    songSelect: { shorthand: "songsel", command: 243, description: "Song Select (Sys Common)", param1: "value" },
-    clock: { shorthand: "clock", command: 248, description: "Timing Clock (Sys Realtime)" },
-    start: { shorthand: "start", command: 250, description: "Start (Sys Realtime)" },
-    continue: { shorthand: "continue", command: 251, description: "Continue (Sys Realtime)" },
-    stop: { shorthand: "stop", command: 252, description: "Stop (Sys Realtime)" },
-    activeSensing: { shorthand: "ping", command: 254, description: "Active Sensing (Sys Realtime)" },
-    reset: { shorthand: "reset", command: 255, description: "System Reset (Sys Realtime)" }
+    noteOn: {
+      shorthand: "note",
+      command: 144,
+      description: "Note-on",
+      param1: "pitch",
+      param2: "velocity",
+      defaults: [60, 96],
+    },
+    noteOff: {
+      shorthand: "off",
+      command: 128,
+      description: "Note-off",
+      param1: "pitch",
+      param2: "velocity",
+      defaults: [60, 0],
+    },
+    cc: {
+      shorthand: "cc",
+      command: 176,
+      description: "Continuous controller",
+      param1: "cc",
+      param2: "value",
+      defaults: [0, 0],
+    },
+    polyTouch: {
+      shorthand: "touch",
+      command: 160,
+      description: "Aftertouch",
+      param1: "pitch",
+      param2: "value",
+      defaults: [60, 64],
+    },
+    programChange: {
+      shorthand: "program",
+      command: 192,
+      description: "Patch change",
+      param1: "value",
+    },
+    pitchBend: {
+      shorthand: "bend",
+      command: 224,
+      description: "Pitch bend",
+      highResParam: "value",
+    },
+    channelPressure: {
+      shorthand: "pressure",
+      command: 208,
+      description: "Channel Pressure",
+      param1: "value",
+    },
+    songPosition: {
+      shorthand: "songpos",
+      command: 242,
+      description: "Song Position Pointer (Sys Common)",
+      highResParam: "value",
+    },
+    songSelect: {
+      shorthand: "songsel",
+      command: 243,
+      description: "Song Select (Sys Common)",
+      param1: "value",
+    },
+    clock: {
+      shorthand: "clock",
+      command: 248,
+      description: "Timing Clock (Sys Realtime)",
+    },
+    start: {
+      shorthand: "start",
+      command: 250,
+      description: "Start (Sys Realtime)",
+    },
+    continue: {
+      shorthand: "continue",
+      command: 251,
+      description: "Continue (Sys Realtime)",
+    },
+    stop: {
+      shorthand: "stop",
+      command: 252,
+      description: "Stop (Sys Realtime)",
+    },
+    activeSensing: {
+      shorthand: "ping",
+      command: 254,
+      description: "Active Sensing (Sys Realtime)",
+    },
+    reset: {
+      shorthand: "reset",
+      command: 255,
+      description: "System Reset (Sys Realtime)",
+    },
   };
   /** @type {Map<number, EventType>} */
   // @ts-ignore
-  const commandLookup = new Map(Object.entries(eventMapping).map(([key, { command }]) => [command, key]));
+  const commandLookup = new Map(
+    Object.entries(eventMapping).map(([key, { command }]) => [command, key])
+  );
   /** @type {Map<string, EventType>} */
-    const shorthandLookup = Object.fromEntries([
-    ...Object.entries(eventMapping).map(([key, { shorthand }]) => [shorthand, key]),
-    ...Object.keys(eventMapping).map(key => [key.toLowerCase(), key])
+  const shorthandLookup = Object.fromEntries([
+    ...Object.entries(eventMapping).map(([key, { shorthand }]) => [
+      shorthand,
+      key,
+    ]),
+    ...Object.keys(eventMapping).map((key) => [key.toLowerCase(), key]),
   ]);
-  const shorthands = Object.fromEntries(Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand]));
-
+  const shorthands = Object.fromEntries(
+    Object.entries(eventMapping).map(([key, { shorthand }]) => [key, shorthand])
+  );
 
   /** aliases for MidiEvent keys
    * the allows for more permissive translation of input strings, i.e. ch10 === channel=10
    * @type {Record<string, keyof MidiEvent>} */
   const paramLookup = {
-    type: 'type', note: 'pitch', pitch: 'pitch',
-    ch: 'channel', channel: 'channel',
-    dev: 'device', device: 'device',
-    t: 'time', time: 'time', "@": 'time',
-    dur: 'dur', duration: 'dur',
-    pos: 'pos', value: 'value2'
+    type: "type",
+    note: "pitch",
+    pitch: "pitch",
+    ch: "channel",
+    channel: "channel",
+    dev: "device",
+    device: "device",
+    t: "time",
+    time: "time",
+    "@": "time",
+    dur: "dur",
+    duration: "dur",
+    pos: "pos",
+    value: "value2",
   };
-  
+
   // These are how different midi event keys are split. ch and dev are special cases that don't include =, since they're common. Other params use = to allow arbitrary additional properties if needed
   const PREFIX_CHANNEL = "ch";
   const PREFIX_DEVICE = "dev";
-  const PREFIX_WHEN = 't=';
-  const PREFIX_POS = 'pos=';
-  const PREFIX_DURATION = 'dur=';
+  const PREFIX_WHEN = "t=";
+  const PREFIX_POS = "pos=";
+  const PREFIX_DURATION = "dur=";
   /** Used when creating lists - treat ~ as empty no value */
-  const REST_LITERAL = '~';
+  const REST_LITERAL = "~";
 
   /**
-   * @param {string} value 
+   * @param {string} value
    * @returns {EventType | undefined}
    */
   function normalizeType(value) {
@@ -177,7 +278,9 @@
   }
 
   function formatNumValue(value, opts) {
-    const str = opts?.useHex ? formatHex(value) : value.toFixed().padStart(opts?.fixedWidth ? 2 : 3, "0");
+    const str = opts?.useHex
+      ? formatHex(value)
+      : value.toFixed().padStart(opts?.fixedWidth ? 2 : 3, "0");
     return str;
   }
   function formatDefault(type, value, value2, opts) {
@@ -186,18 +289,34 @@
   function formatNoteType(type, note, value, opts = {}) {
     return `${type ? type + " " : ""}${midiPitchToNoteName(note, opts)} ${formatNumValue(value, opts)}`;
   }
-  /** 
+  /**
    * This is a mapping of midi events and their string representation
    * @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>}
    */
   const formatters = {
-    noteOn({ value1: note, value2: velocity = eventMapping.noteOn.defaults[1] }, opts = {}) {
-      return formatNoteType(opts?.noMinify ? shorthands.noteOn : undefined, note, velocity, opts);
+    noteOn(
+      { value1: note, value2: velocity = eventMapping.noteOn.defaults[1] },
+      opts = {}
+    ) {
+      return formatNoteType(
+        opts?.noMinify ? shorthands.noteOn : undefined,
+        note,
+        velocity,
+        opts
+      );
     },
     noteOff({ value1: note }, opts = {}) {
-      return formatNoteType(opts?.noMinify ? shorthands.noteOff : undefined, note, 0, opts);
+      return formatNoteType(
+        opts?.noMinify ? shorthands.noteOff : undefined,
+        note,
+        0,
+        opts
+      );
     },
-    polyTouch({ value1: note, value2: value = eventMapping.polyTouch.defaults[1] }, opts = {}) {
+    polyTouch(
+      { value1: note, value2: value = eventMapping.polyTouch.defaults[1] },
+      opts = {}
+    ) {
       return formatNoteType(shorthands.polyTouch, note, value, opts);
     },
     cc({ value1: cc, value2: value }, opts) {
@@ -206,7 +325,8 @@
     programChange({ value1: program }, opts) {
       return formatDefault(shorthands.programChange, program, undefined, opts);
     },
-    channelPressure: ({ value1: value }, opts) => formatDefault(shorthands.channelPressure, value, undefined, opts),
+    channelPressure: ({ value1: value }, opts) =>
+      formatDefault(shorthands.channelPressure, value, undefined, opts),
     pitchBend({ value1, value2 }, opts) {
       if (value1 == undefined) {
         [value1, value2] = [0, 64];
@@ -216,23 +336,23 @@
     songPosition({ value1 = 0, value2 }, opts) {
       return `${shorthands.songPosition} ${formatHighResValue(value1, value2, opts)}`;
     },
-    songSelect: ({ value1 }, opts) => formatDefault(shorthands.songSelect, value1, undefined, opts),
+    songSelect: ({ value1 }, opts) =>
+      formatDefault(shorthands.songSelect, value1, undefined, opts),
     // tuneRequest: () => shorthands.tuneRequest,
     continue: () => shorthands.continue,
     activeSensing: () => shorthands.activeSensing,
     clock: () => shorthands.clock,
     start: () => shorthands.start,
     stop: () => shorthands.stop,
-    reset: () => shorthands.reset
+    reset: () => shorthands.reset,
   };
 
-
   /**
    * convert midi event to string.
    * The opts includes more formatting options than available through the current scratch blocks available.
-   * @param {MidiEvent} event 
-   * @param {FormatOptions} opts 
-   * @returns 
+   * @param {MidiEvent} event
+   * @param {FormatOptions} opts
+   * @returns
    */
   function midiToString(event, opts = {}) {
     const { noMinify } = opts;
@@ -241,14 +361,14 @@
     // ensure these are set properly
     const {
       value1 = event[spec.param1] ?? event[spec.highResParam],
-      value2 = event[spec.param2]
+      value2 = event[spec.param2],
     } = event;
     const formatter = formatters[event.type];
     if (!formatter) {
       console.debug(`unknown event type ${event.type}`);
       return "";
     }
-    let msg = formatter({...event, value1, value2}, opts);
+    let msg = formatter({ ...event, value1, value2 }, opts);
     if (event.channel != undefined || noMinify) {
       msg += formatChannel(event.channel, opts);
     }
@@ -270,13 +390,14 @@
   /**
    * convert a string representation of a note to a midievent
    * FUTURE - support unicode note durations? https://en.wikipedia.org/wiki/Musical_Symbols_(Unicode_block)
-   * @param {string} text 
-   * @param {FormatOptions} opts 
+   * @param {string} text
+   * @param {FormatOptions} opts
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
-    if (typeof text !== 'string') text = `${String(text) ?? ''}`;
-    const fullRe = /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
+    if (typeof text !== "string") text = `${String(text) ?? ""}`;
+    const fullRe =
+      /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
     const match = fullRe.exec(text);
     if (!match?.groups) return null;
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
@@ -286,11 +407,13 @@
     const extras = Object.fromEntries(
       [...match.groups.keyvals?.matchAll(keyvalRe)]
         // paramLookup converts "t=2" into "time=2"
-        .map(({groups: {key, val}}) => [paramLookup[key] || key, val])
+        .map(({ groups: { key, val } }) => [paramLookup[key] || key, val])
     );
     let {
       type: shorthand = extras.type,
-      pitch = extras.pitch, data1, data2
+      pitch = extras.pitch,
+      data1,
+      data2,
     } = match.groups;
 
     // midi value1 can be specified as pitch or as number
@@ -302,22 +425,20 @@
 
     /** @type {MidiEvent} */
     const event = {
-      type: shorthand === REST_LITERAL
-        ? 'rest'
-        : normalizeType(shorthand),
-      ...(value1 != undefined) && {value1},
-      ...(value2 != undefined) && {value2},
+      type: shorthand === REST_LITERAL ? "rest" : normalizeType(shorthand),
+      ...(value1 != undefined && { value1 }),
+      ...(value2 != undefined && { value2 }),
       channel: parseNumValue(extras.channel, opts),
       device: parseNumValue(extras.device, opts),
-      ...extras.time && { time: parseTimespan(extras.time)},
+      ...(extras.time && { time: parseTimespan(extras.time) }),
       // REVIEW is pos even needed? it's for setting output in beats, but setting time would make more sense instead
-      ...extras.pos && { pos: parseFraction(extras.pos)},
-      ...extras.dur && { dur: parseFraction(extras.dur)},
+      ...(extras.pos && { pos: parseFraction(extras.pos) }),
+      ...(extras.dur && { dur: parseFraction(extras.dur) }),
     };
 
     // default to note event if has pitch (off if velocity = 0)
     if (!event.type && value1 >= 0) {
-      event.type = 'noteOn';
+      event.type = "noteOn";
     } else if (!event.type) {
       // no type set, invalid input
       return null;
@@ -327,9 +448,10 @@
       case "noteOn":
       case "noteOff":
         if (value1 == undefined) return null;
-        if (value2 === 0) event.type = 'noteOff';
+        if (value2 === 0) event.type = "noteOff";
         if (value2 == undefined) {
-          event.value2 = event.velocity ?? event.value ?? (event.type === 'noteOn' ? 96 : 0);
+          event.value2 =
+            event.velocity ?? event.value ?? (event.type === "noteOn" ? 96 : 0);
         }
         break;
       case "polyTouch":
@@ -342,7 +464,7 @@
       case "cc":
         if (value2 == undefined) {
           event.value2 = event.value;
-          value2 = event.value2
+          value2 = event.value2;
         }
         if (value1 == undefined || value2 == undefined) return null;
         break;
@@ -356,7 +478,10 @@
       case "pitchBend":
         if (value1 == undefined) return null;
         // these two types have a higher precision value
-        const { value: highResValue, ...normedValues } = parseHighResValue(value1, value2);
+        const { value: highResValue, ...normedValues } = parseHighResValue(
+          value1,
+          value2
+        );
         Object.assign(event, normedValues);
         event[spec.highResParam ?? "value"] = highResValue;
         break;
@@ -381,14 +506,19 @@
   }
 
   function formatChannel(channel = 0, opts) {
-    const str = opts?.useHex ? formatHex(channel, 1) : channel.toFixed().padStart(2, "0");
+    const str = opts?.useHex
+      ? formatHex(channel, 1)
+      : channel.toFixed().padStart(2, "0");
     return ` ${PREFIX_CHANNEL}${str}`;
   }
   function formatDevice(device = 0, opts) {
     const str = opts?.useHex ? formatHex(device, 1) : device.toFixed();
     return ` ${PREFIX_DEVICE}${str}`;
   }
-  function formatTime({ time = undefined }, { noMinify = false, timestampFormat = "absolute", startTimestamp = 0 }) {
+  function formatTime(
+    { time = undefined },
+    { noMinify = false, timestampFormat = "absolute", startTimestamp = 0 }
+  ) {
     if (timestampFormat === "omit" || time == undefined) {
       return "";
     }
@@ -402,15 +532,14 @@
 
   // TODO FUTURE add in opts flag to use fractions or not
   function formatPosition(value, opts) {
-    return `${PREFIX_POS}${formatFraction(value)}`
+    return `${PREFIX_POS}${formatFraction(value)}`;
   }
 
   // TODO FUTURE add in opts flag to use fractions or not
   function formatDuration(value, opts) {
-    return `${PREFIX_DURATION}${formatFraction(value)}`
+    return `${PREFIX_DURATION}${formatFraction(value)}`;
   }
 
-
   function formatTimespan(seconds, hoursOptional = true) {
     const ms = 1e3 * (seconds % 1);
     let t = Math.floor(seconds);
@@ -421,29 +550,32 @@
     return `${parts.map((p) => p.toFixed(0).padStart(2, "0")).join(":")}.${ms.toFixed().padEnd(3, "0")}`;
   }
   /**
-   * 
-   * @param {string} text 
-   * @returns 
+   *
+   * @param {string} text
+   * @returns
    */
   function parseTimespan(text) {
     if (!text) return 0;
     // split into [hh]:mm:ss.000 parts
-    const parts = text.split(':');
+    const parts = text.split(":");
     // somewhat unnecessarily clever method to sum [hh][mm][ss]
     // by incrementing the scale from [1, 60, 3600].
     // goes right to left because hours and minutes are optional
-    const [value] = parts.reduceRight(([acc, scale], part) => {
-      const val = (parseFloat(part) || 0) * scale;
-      return [acc + val, scale * 60];
-    }, [0, 1]);
+    const [value] = parts.reduceRight(
+      ([acc, scale], part) => {
+        const val = (parseFloat(part) || 0) * scale;
+        return [acc + val, scale * 60];
+      },
+      [0, 1]
+    );
     return value;
   }
   function parseFraction(text) {
-    if (typeof text !== 'string') {
+    if (typeof text !== "string") {
       return +text || 0;
     }
-    const [top, bottom] = text.split('/');
-    return (parseFloat(top) / (parseFloat(bottom) || 1)) || 0;
+    const [top, bottom] = text.split("/");
+    return parseFloat(top) / (parseFloat(bottom) || 1) || 0;
   }
   function formatFraction(value, threshold = 2e-3) {
     for (let d of [4, 3, 10, 8, 1]) {
@@ -453,23 +585,24 @@
       }
     }
     // truncate to milliseconds (0.001)
-    return `${value}`.replace(/(\.\d{3})\d+$/, '$1');
+    return `${value}`.replace(/(\.\d{3})\d+$/, "$1");
   }
 
   function valueToMsbLsb(value) {
     return {
       value1: value & 127,
-      value2: value >> 7
+      value2: value >> 7,
     };
   }
   function msbLsbToValue(lsb, msb = 0) {
     return (msb << 7) + lsb;
   }
   function parseHighResValue(value1, value2) {
-    const value = typeof value2 == undefined ? value1 : msbLsbToValue(value1, value2);
+    const value =
+      typeof value2 == undefined ? value1 : msbLsbToValue(value1, value2);
     return {
       value,
-      ...valueToMsbLsb(value)
+      ...valueToMsbLsb(value),
     };
   }
   function formatHighResValue(value1, value2, opts = {}) {
@@ -486,7 +619,7 @@
 
   /**
    * parse raw input midi bytes
-   * @param {Uint8Array} data 
+   * @param {Uint8Array} data
    * @returns {MidiEvent | null}
    */
   function rawMessageToMidi(data) {
@@ -502,8 +635,8 @@
     const event = {
       type,
       channel: channel + 1,
-      ...value1 != undefined && { value1 },
-      ...value2 != undefined && { value2 }
+      ...(value1 != undefined && { value1 }),
+      ...(value2 != undefined && { value2 }),
     };
     const spec = eventMapping[type];
     if (spec?.param1 && event.value1 != undefined) {
@@ -524,12 +657,7 @@
    * @returns {Uint8Array}
    */
   function midiToRawMessage(event) {
-    let {
-      type,
-      value1,
-      value2,
-      channel = 1
-    } = event;
+    let { type, value1, value2, channel = 1 } = event;
     const spec = eventMapping[type];
     // return empty if not valid event
     if (!spec) return new Uint8Array();
@@ -538,35 +666,44 @@
       value1 = (event[spec.param1] ?? spec.defaults?.[0]) || 0;
     }
     if (spec.param2 && value2 == undefined) {
-      value2 = (event[spec.param2] ?? spec.defaults?.[1]) ?? undefined;
+      value2 = event[spec.param2] ?? spec.defaults?.[1] ?? undefined;
     }
     if (spec.highResParam && event.value != undefined) {
       const highRes = parseHighResValue(event.value);
       [value1, value2] = [highRes.value1, highRes.value2];
     }
-    return new Uint8Array([commandAndChannel, value1, ...(value2 !== undefined ? [value2] : [])]);
+    return new Uint8Array([
+      commandAndChannel,
+      value1,
+      ...(value2 !== undefined ? [value2] : []),
+    ]);
   }
   /**
    * read the "pos" / "dur" values of an event as relative time vs. a fixed wall-clock time
-   * @param {Pick<MidiEvent, 'time' | 'pos' | 'dur'>} event 
+   * @param {Pick<MidiEvent, 'time' | 'pos' | 'dur'>} event
    * @param {number} [offsetMs] time to return relative to. Default is now
    */
   function getMidiOffsetTime(event, offsetMs = window.performance.now()) {
     const { pos = 0, dur } = event;
     return {
-      start: offsetMs + (pos * 1000),
-      ...(dur > 0) && {
-        end: offsetMs + ((pos + dur) * 1000)
-      }
+      start: offsetMs + pos * 1000,
+      ...(dur > 0 && {
+        end: offsetMs + (pos + dur) * 1000,
+      }),
     };
   }
   function isPitchedEvent(type) {
-    return !!type && (type === "noteOn" || type === "noteOff" || type === "polyTouch");
+    return (
+      !!type &&
+      (type === "noteOn" || type === "noteOff" || type === "polyTouch")
+    );
   }
 
   // Make a full array of notes in full midi range from 0 (C-1) to 127 (G-9)
-  const MIDI_NOTES = "_".repeat(11).split('')
-    .flatMap((_, i) => SHARPS.map(c => `${c}${i - 1}`))
+  const MIDI_NOTES = "_"
+    .repeat(11)
+    .split("")
+    .flatMap((_, i) => SHARPS.map((c) => `${c}${i - 1}`))
     .slice(0, 128);
 
   /**
@@ -579,26 +716,38 @@
   const eventProps = {
     type: { key: "type", text: Scratch.translate("Event Type") },
     pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
-    velocity: { key: "velocity", type: "noteOn", text: Scratch.translate("Velocity") },
+    velocity: {
+      key: "velocity",
+      type: "noteOn",
+      text: Scratch.translate("Velocity"),
+    },
     ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
     ccValue: { key: "value", type: "cc", text: Scratch.translate("CC Value") },
     channel: { key: "channel", text: Scratch.translate("Channel") },
     device: { key: "device", text: Scratch.translate("Device") },
-    pitchbend: { key: "value", type: "pitchBend", text: Scratch.translate("Pitch Bend") },
-    aftertouch: { key: "value", type: "polyTouch", text: Scratch.translate("Aftertouch") },
-    time: { key: "time", text: Scratch.translate("Timestamp") }
+    pitchbend: {
+      key: "value",
+      type: "pitchBend",
+      text: Scratch.translate("Pitch Bend"),
+    },
+    aftertouch: {
+      key: "value",
+      type: "polyTouch",
+      text: Scratch.translate("Aftertouch"),
+    },
+    time: { key: "time", text: Scratch.translate("Timestamp") },
   };
 
-//#endregion utils
+  //#endregion utils
 
-//#region wrapper
+  //#region wrapper
   /**
    * This is a singleton wrapper class around the WebMIDI API. It:
    * 1) Handles requesting API permission and reporting Input/Output devices
    * 2) Translate raw midi input events into friendlier @see {MidiEvent} objects
    * 3) Sends out midi events, translating MidiEvents into the raw midi payload
    * 4) Keeps track of "note on"/"note off" messages to support "panic" stopping midi output
-   * 
+   *
    * It extends the native EventTarget class to dispatch events
    */
   class MidiBackend extends EventTarget {
@@ -612,13 +761,13 @@
       this._init = undefined;
       /** @type {MidiEvent} */
       this._defaultOutputEvent = {
-        type: 'noteOn',
+        type: "noteOn",
         channel: 1,
         device: 0,
         pitch: 60,
         dur: 0.5,
-        velocity: 196
-      }
+        velocity: 196,
+      };
       // TIP! If you use arrow functions on class methods then 'this' is automatically bound correctly, even if using as event listener
       this.refreshDevices = () => {
         for (const input of this.access.inputs.values()) {
@@ -644,14 +793,16 @@
           this.refreshDevices();
           return;
         }
-        this._emit("device:status", { index, id, name, type, state: port.state });
+        this._emit("device:status", {
+          index,
+          id,
+          name,
+          type,
+          state: port.state,
+        });
       };
       this._onInputEvent = (event) => {
-        const {
-          target: device,
-          data,
-          timeStamp
-        } = event;
+        const { target: device, data, timeStamp } = event;
         if (!data) return;
         const deviceIndex = this.inputs.indexOf(device);
         const midiEvent = rawMessageToMidi(data);
@@ -670,29 +821,36 @@
       };
     }
     get defaultInput() {
-      return this.inputs.find(d => d.state === 'connected');
+      return this.inputs.find((d) => d.state === "connected");
     }
     get defaultOutput() {
-      return this.outputs.find(d => d.state === 'connected');
+      return this.outputs.find((d) => d.state === "connected");
     }
-    async initialize({ sysex = false, force = false, timeoutMS = 1e3 * 30 } = {}) {
+    async initialize({
+      sysex = false,
+      force = false,
+      timeoutMS = 1e3 * 30,
+    } = {}) {
       if (this._init && !force) {
         return this._init;
       }
       if (!navigator.requestMIDIAccess) {
         return false;
       }
-      return this._init = (async () => {
+      return (this._init = (async () => {
         this.status = "initializing" /* Initializing */;
         this._emit("status", { status: this.status });
         try {
           let timer;
           const whenTimeout = new Promise((resolve, reject) => {
-            timer = setTimeout(() => reject(new DOMException("Timeout waiting for midi access")), timeoutMS);
+            timer = setTimeout(
+              () => reject(new DOMException("Timeout waiting for midi access")),
+              timeoutMS
+            );
           });
           const midiAccess = await Promise.race([
             navigator.requestMIDIAccess({ sysex }),
-            whenTimeout
+            whenTimeout,
           ]);
           clearTimeout(timer);
           this.access = midiAccess;
@@ -710,47 +868,55 @@
         } finally {
           this._emit("status", { status: this.status });
         }
-      })();
+      })());
     }
     /**
-     * 
+     *
      * @param {MidiEvent | string | number} event
      * @param {MidiEvent} [defaults]
      * @param {FormatOptions} [formatOpts]
      */
-    sendOutputEvent(event, defaults = this._defaultOutputEvent, formatOpts = {}) {
+    sendOutputEvent(
+      event,
+      defaults = this._defaultOutputEvent,
+      formatOpts = {}
+    ) {
       /** @type {MidiEvent} */
       let data;
       // midi pitch = noteon now for 1/2 beat
-      if (typeof event === 'number') {
+      if (typeof event === "number") {
         data = {
           ...defaults,
-          pitch: event
+          pitch: event,
         };
-      } else if (typeof event === 'string') {
+      } else if (typeof event === "string") {
         data = {
           ...defaults,
-          ...stringToMidi(event, formatOpts)
+          ...stringToMidi(event, formatOpts),
         };
-      } else if (typeof event === 'object') {
+      } else if (typeof event === "object") {
         data = event;
       } else {
-        throw new TypeError('Invalid data to send to output - must be midievent object, string or number');
+        throw new TypeError(
+          "Invalid data to send to output - must be midievent object, string or number"
+        );
       }
 
       // ignore, just placebo rest event
-      if (data.type === 'rest') {
+      if (data.type === "rest") {
         return false;
       }
 
-      const device = (data.device != undefined && this.outputs[data.device]) || this.defaultOutput;
+      const device =
+        (data.device != undefined && this.outputs[data.device]) ||
+        this.defaultOutput;
       if (!device) {
         // no output. Should this throw error?
         return false;
       }
       // ensure 0 velocity is interpreted as noteOff
-      if (data.type === 'noteOn' && data.velocity === 0) {
-        data.type = 'noteOff';
+      if (data.type === "noteOn" && data.velocity === 0) {
+        data.type = "noteOff";
       }
 
       // TODO be able to specify offset time to calculate from?
@@ -758,13 +924,13 @@
       let raw = midiToRawMessage(data);
       device.send(raw, start);
       // also send off event
-      if (data.type === 'noteOn' && end) {
+      if (data.type === "noteOn" && end) {
         /** @type {MidiEvent} */
         const offEvent = {
           ...data,
-          type: 'noteOff',
+          type: "noteOff",
           value2: 0,
-          velocity: 0
+          velocity: 0,
         };
         raw = midiToRawMessage(offEvent);
         device.send(raw, end);
@@ -779,13 +945,13 @@
      */
     panic() {
       for (let [device, active] of this._activeNotes.entries()) {
-        if (device.state !== 'connected') continue;
+        if (device.state !== "connected") continue;
         for (let key of active) {
-          const [channel, pitch] = key.split('_');
+          const [channel, pitch] = key.split("_");
           const raw = midiToRawMessage({
-            type: 'noteOff',
+            type: "noteOff",
             channel: parseInt(channel, 10),
-            pitch: parseInt(pitch)
+            pitch: parseInt(pitch),
           });
           // console.debug(`Stopping note ${pitch} on ${channel}`);
           device.send(raw);
@@ -796,13 +962,13 @@
     /**
      * Keep track of events sent to midi devices to allow panic stopping them if necessary
      * @private
-     * @param {MidiEvent} event 
+     * @param {MidiEvent} event
      * @param {MIDIOutput} device
      */
     _trackActiveNotes(event, device) {
       // NOTE - same default channel as midiToRawEvent, maybe default should be a magic value?
       const { type, pitch, channel = 1 } = event;
-      if (!(type === 'noteOn' || type === 'noteOff')) {
+      if (!(type === "noteOn" || type === "noteOff")) {
         return;
       }
       const key = `${channel}_${pitch}`;
@@ -810,7 +976,7 @@
         this._activeNotes.set(device, new Set());
       }
       const list = this._activeNotes.get(device);
-      if (type === 'noteOn') {
+      if (type === "noteOn") {
         list.add(key);
       } else {
         list.delete(key);
@@ -827,7 +993,9 @@
       const events = Array.isArray(event) ? event : [event];
       let timer;
       return new Promise((resolve, reject) => {
-        events.forEach((name) => target.addEventListener(name, resolve, { once: true, signal }));
+        events.forEach((name) =>
+          target.addEventListener(name, resolve, { once: true, signal })
+        );
         timer = setTimeout(() => {
           events.forEach((name) => target.removeEventListener(name, resolve));
           reject(new DOMException("Timeout", "TimeoutError"));
@@ -840,7 +1008,7 @@
     off(type, callback) {
       return super.removeEventListener(type, callback);
     }
-  };
+  }
 
   /**
    * this singleton keeps track of events in order to:
@@ -848,7 +1016,7 @@
    * 2) Track "active" notes
    * 3) Keep short term memory of events to avoid missing events because of scratch's slower event sample rate
    * 4) Allow recording events for playback/storage
-   * 
+   *
    * It keeps track of midi events, automatically pruning them after a certain time period or # of max entries have been reached (lazy, it doesn't actively poll)
    */
   class MidiRecorder extends EventTarget {
@@ -867,7 +1035,10 @@
       this.maxEntries = 256 * 256;
     }
     _now() {
-      return (globalThis.performance ? globalThis.performance.now() : Date.now()) / 1000;
+      return (
+        (globalThis.performance ? globalThis.performance.now() : Date.now()) /
+        1000
+      );
     }
     /**
      * REVIEW should record start be a protection against purging?
@@ -885,13 +1056,15 @@
       this.paused = true;
       const { recordStart } = this;
       this.recordStart = 0;
-      return recordStart ? this.buffer.filter((evt) => evt.when >= recordStart) : this.buffer;
+      return recordStart
+        ? this.buffer.filter((evt) => evt.when >= recordStart)
+        : this.buffer;
     }
     /**
      * add note to buffer
-     * @param evt 
+     * @param evt
      * @param when -- note, only used for setting "when" of active notes...evt should already have time value
-     * @returns 
+     * @returns
      */
     add(evt, when = this._now()) {
       const doc = { ...evt, when };
@@ -912,7 +1085,7 @@
         case "cc":
           Object.assign(this.ccs, {
             [`${evt.cc}_${evt.channel}`]: evt,
-            [`${evt.cc}`]: evt
+            [`${evt.cc}`]: evt,
           });
           break;
       }
@@ -954,7 +1127,9 @@
     getActiveNote(pitch, channel) {
       if (pitch == undefined) {
         const list = this.getActiveNotes(channel);
-        return list.length == 0 ? undefined : list.reduce((a, b) => a.when > b.when ? a : b);
+        return list.length == 0
+          ? undefined
+          : list.reduce((a, b) => (a.when > b.when ? a : b));
       }
       if (channel == undefined) {
         return this.active.get(pitch);
@@ -966,8 +1141,9 @@
       if (channel == undefined) {
         return [...this.active.values()];
       }
-      return [...this.activeByChannel.values()].filter((c) => c.channel == channel);
-      ;
+      return [...this.activeByChannel.values()].filter(
+        (c) => c.channel == channel
+      );
     }
     clear(newStartTime = 0) {
       this.lastNotes = {};
@@ -999,7 +1175,7 @@
       return this.getLast("polyTouch", pitch, channel);
     }
     getLast(type, value1, channel) {
-      if (type === value1 === channel === undefined) {
+      if (((type === value1) === channel) === undefined) {
         return this.buffer[this.buffer.length - 1];
       }
       if (type === "cc" && value1) {
@@ -1013,7 +1189,9 @@
         if (channel != undefined && evt.channel != channel) continue;
         if (type) {
           const eType = evt.type;
-          const isType = Array.isArray(type) ? type.includes(eType) : type === eType;
+          const isType = Array.isArray(type)
+            ? type.includes(eType)
+            : type === eType;
           if (!isType) continue;
         }
         return evt;
@@ -1033,17 +1211,19 @@
       if (this.buffer.length > this.maxEntries) {
         this.buffer = this.buffer.slice(-1 * this.maxEntries);
       }
-      const firstNonStaleEvent = this.buffer.findIndex((e) => e.when >= threshold);
+      const firstNonStaleEvent = this.buffer.findIndex(
+        (e) => e.when >= threshold
+      );
       if (firstNonStaleEvent === -1) {
         this.buffer = [];
       } else {
         this.buffer = this.buffer.slice(firstNonStaleEvent);
       }
     }
-  };
+  }
   // polyfill for findLastIndex for 5% of browsers without it
   const findLastIndex = (arr, cb) => {
-    if (typeof arr.findLastIndex === 'function') {
+    if (typeof arr.findLastIndex === "function") {
       return arr.findLastIndex(cb);
     }
     let i = arr.length - 1;
@@ -1051,7 +1231,7 @@
       i -= 1;
     }
     return i;
-  }
+  };
 
   function channelKeyForEvent(value = 0, channel = 0) {
     return msbLsbToValue(value, channel);
@@ -1060,8 +1240,8 @@
   // src/midi/midi-thread.ts
   const TARGET_MIDI_KEY = "_midi";
   /**
-   * 
-   * @param {import("scratch-vm").Thread} thread 
+   *
+   * @param {import("scratch-vm").Thread} thread
    * @returns {MidiEvent | undefined}
    */
   function getThreadMidiValue(thread) {
@@ -1088,21 +1268,21 @@
     return 60;
   }
   function beatsToSeconds(beats = 1, tempo = getTempo()) {
-    return beats * 60 / tempo;
+    return (beats * 60) / tempo;
   }
   function secondsToBeats(seconds = 1, tempo = getTempo()) {
-    return seconds * tempo / 60;
+    return (seconds * tempo) / 60;
   }
 
   //#endregion wrapper
 
-//#region Scratch Extension
+  //#region Scratch Extension
 
   // hardcoded mapping of hats events, b/c I'll never remember the convention otherwise
   const HATS = {
     NOTE: `${EXT_ID}_whenNoteOnOff`,
     NOTEANY: `${EXT_ID}_whenAnyNoteOnOff`,
-    MIDI: `${EXT_ID}_whenMidiEvent`
+    MIDI: `${EXT_ID}_whenMidiEvent`,
     // not currently implemented
     // CC: `${EXT_ID}_whenCC`
   };
@@ -1110,7 +1290,7 @@
    * Block separator constant
    * @type {'---'}
    */
-  const SEPARATOR = '---';
+  const SEPARATOR = "---";
   const { Cast } = Scratch;
 
   class MidiExtension {
@@ -1122,8 +1302,7 @@
        */
       this._ensureInitialize = (evt) => {
         if (this.midi.status === "pending" /* Initial */) {
-          this.initialize().catch(() => {
-          });
+          this.initialize().catch(() => {});
         }
       };
       this._addListeners();
@@ -1165,14 +1344,19 @@
         { value: "polyTouch", text: Scratch.translate("AfterTouch") },
         { value: "pitchBend", text: Scratch.translate("Pitch Bend") },
         { value: "programChange", text: Scratch.translate("Program Change") },
-        { value: "channelPressure", text: Scratch.translate("Channel Pressure") }
+        {
+          value: "channelPressure",
+          text: Scratch.translate("Channel Pressure"),
+        },
       ];
 
       return {
         id: EXT_ID,
         name: Scratch.translate("Midi"),
-        menuIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
-        blockIconURI: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
+        menuIconURI:
+          "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
+        blockIconURI:
+          "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
         blocks: [
           // FUTURE - could force requesting permissions and checking midi device status. Usually refreshing is safer option
           // {
@@ -1193,31 +1377,33 @@
             arguments: {
               DEVICE_TYPE: {
                 type: Scratch.ArgumentType.STRING,
-                menu: 'DEVICE_TYPES',
-                defaultValue: 'input'
-              }
-            }
+                menu: "DEVICE_TYPES",
+                defaultValue: "input",
+              },
+            },
           },
           {
             opcode: "getDeviceInfo",
-            text: Scratch.translate("[DEVICE_PROP] of [DEVICE_TYPE] device at [INDEX]"),
+            text: Scratch.translate(
+              "[DEVICE_PROP] of [DEVICE_TYPE] device at [INDEX]"
+            ),
             blockType: Scratch.BlockType.REPORTER,
             arguments: {
               DEVICE_PROP: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "DEVICE_PROPS",
-                defaultValue: "name"
+                defaultValue: "name",
               },
               DEVICE_TYPE: {
                 type: Scratch.ArgumentType.STRING,
-                menu: 'DEVICE_TYPES',
-                defaultValue: 'input'
+                menu: "DEVICE_TYPES",
+                defaultValue: "input",
               },
               INDEX: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
-              }
-            }
+                defaultValue: 0,
+              },
+            },
           },
           SEPARATOR,
           {
@@ -1229,14 +1415,14 @@
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               PRESS: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_EVENT_TYPE",
-                defaultValue: ANY_TYPE
-              }
-            }
+                defaultValue: ANY_TYPE,
+              },
+            },
           },
           {
             opcode: "whenAnyNoteOnOff",
@@ -1248,9 +1434,9 @@
               PRESS: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_EVENT_TYPE",
-                defaultValue: ANY_TYPE
-              }
-            }
+                defaultValue: ANY_TYPE,
+              },
+            },
           },
           {
             opcode: "whenMidiEvent",
@@ -1262,16 +1448,16 @@
               TYPE: {
                 menu: "EVENT_TYPES_OPTIONAL",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: ANY_TYPE
-              }
-            }
+                defaultValue: ANY_TYPE,
+              },
+            },
           },
           {
             opcode: "lastEvent",
             blockType: Scratch.BlockType.REPORTER,
             text: Scratch.translate("Input Event"),
             disableMonitor: true,
-            allowDropAnywhere: true
+            allowDropAnywhere: true,
           },
           {
             opcode: "getEventProp",
@@ -1280,14 +1466,14 @@
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "note C4 82 ch1 dev0 @1000"
+                defaultValue: "note C4 82 ch1 dev0 @1000",
               },
               PROP: {
                 type: Scratch.ArgumentType.STRING,
                 defaultValue: "type",
-                menu: "PROPS"
-              }
-            }
+                menu: "PROPS",
+              },
+            },
           },
           {
             opcode: "isNoteActive",
@@ -1296,14 +1482,14 @@
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               CHANNEL: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "CHANNELS",
-                defaultValue: "0"
-              }
-            }
+                defaultValue: "0",
+              },
+            },
           },
           {
             opcode: "isEventOfType",
@@ -1313,20 +1499,20 @@
               TYPE: {
                 menu: "EVENT_TYPES",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "noteOn"
-              }
-            }
+                defaultValue: "noteOn",
+              },
+            },
           },
           SEPARATOR,
           {
             opcode: "getActiveNotes",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Active Notes")
+            text: Scratch.translate("Active Notes"),
           },
           {
             opcode: "numActiveNotes",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("length of active notes")
+            text: Scratch.translate("length of active notes"),
           },
           {
             opcode: "getActiveNoteByIndex",
@@ -1335,9 +1521,9 @@
             arguments: {
               INDEX: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
-              }
-            }
+                defaultValue: 0,
+              },
+            },
           },
           {
             opcode: "setActiveNoteList",
@@ -1346,9 +1532,9 @@
             arguments: {
               LIST: {
                 type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              }
-            }
+                menu: "lists",
+              },
+            },
           },
           SEPARATOR,
           {
@@ -1358,90 +1544,96 @@
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               BEATS: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0.25
-              }
-            }
+                defaultValue: 0.25,
+              },
+            },
           },
           {
             opcode: "sendOutputEvent",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate("schedule [EVENT] for [POS] beats from now"),
+            text: Scratch.translate(
+              "schedule [EVENT] for [POS] beats from now"
+            ),
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "Eb4 beats=1/4"
+                defaultValue: "Eb4 beats=1/4",
               },
               POS: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
-              }
-            }
+                defaultValue: 0,
+              },
+            },
           },
           {
             opcode: "makeOutputNote",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Note [NOTE] Duration [BEATS] Volume [VELOCITY]% [CHANNEL] [DEVICE]"),
+            text: Scratch.translate(
+              "Note [NOTE] Duration [BEATS] Volume [VELOCITY]% [CHANNEL] [DEVICE]"
+            ),
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               BEATS: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0.25
+                defaultValue: 0.25,
               },
               VELOCITY: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 96
+                defaultValue: 96,
               },
               CHANNEL: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "CHANNELS",
-                defaultValue: "1"
+                defaultValue: "1",
               },
               DEVICE: {
                 type: Scratch.ArgumentType.STRING,
-                menu: "OUTPUT_DEVICES"
-              }
-            }
+                menu: "OUTPUT_DEVICES",
+              },
+            },
           },
           {
             opcode: "makeOutputEvent",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Event [TYPE] [VALUE1] [VALUE2] [CHANNEL] [DEVICE]"),
+            text: Scratch.translate(
+              "Event [TYPE] [VALUE1] [VALUE2] [CHANNEL] [DEVICE]"
+            ),
             arguments: {
               TYPE: {
                 menu: "EVENT_TYPES",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: 'cc'
+                defaultValue: "cc",
               },
               VALUE1: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
+                defaultValue: 0,
               },
               VALUE2: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0
+                defaultValue: 0,
               },
               CHANNEL: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "CHANNELS",
-                defaultValue: "1"
+                defaultValue: "1",
               },
               DEVICE: {
                 type: Scratch.ArgumentType.STRING,
-                menu: "OUTPUT_DEVICES"
-              }
-            }
+                menu: "OUTPUT_DEVICES",
+              },
+            },
           },
           {
             opcode: "stopAllNotes",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate("stop all notes on output devices")
+            text: Scratch.translate("stop all notes on output devices"),
           },
           SEPARATOR,
 
@@ -1453,9 +1645,9 @@
               NOTE: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_NAMES",
-                defaultValue: "C4"
-              }
-            }
+                defaultValue: "C4",
+              },
+            },
           },
           {
             opcode: "nameForNote",
@@ -1464,24 +1656,26 @@
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,
-                defaultValue: 60
+                defaultValue: 60,
               },
               ACCIDENTAL: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "ACCIDENTALS",
-                defaultValue: 'sharps'
-              }
-            }
+                defaultValue: "sharps",
+              },
+            },
           },
           {
             opcode: "normalizeMidiVal",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Scale MIDI Value [VALUE] to min=[MIN] max=[MAX]"),
+            text: Scratch.translate(
+              "Scale MIDI Value [VALUE] to min=[MIN] max=[MAX]"
+            ),
             arguments: {
               VALUE: { type: Scratch.ArgumentType.NUMBER, defaultValue: 0 },
               MIN: { type: Scratch.ArgumentType.NUMBER, defaultValue: -1 },
-              MAX: { type: Scratch.ArgumentType.NUMBER, defaultValue: 1 }
-            }
+              MAX: { type: Scratch.ArgumentType.NUMBER, defaultValue: 1 },
+            },
           },
           {
             opcode: "eventToJSON",
@@ -1490,9 +1684,9 @@
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "note Eb4 96 t=0.5 dur=0.25"
-              }
-            }
+                defaultValue: "note Eb4 96 t=0.5 dur=0.25",
+              },
+            },
           },
           {
             opcode: "jsonToEvent",
@@ -1501,20 +1695,21 @@
             arguments: {
               TEXT: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}'
-              }
-            }
+                defaultValue:
+                  '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}',
+              },
+            },
           },
           SEPARATOR,
           {
             opcode: "getMidiStartTime",
             text: Scratch.translate("MIDI Start Time"),
-            blockType: Scratch.BlockType.REPORTER
+            blockType: Scratch.BlockType.REPORTER,
           },
           {
             opcode: "getMidiCurrentTime",
             text: Scratch.translate("MIDI Current Time"),
-            blockType: Scratch.BlockType.REPORTER
+            blockType: Scratch.BlockType.REPORTER,
           },
           {
             opcode: "clearEvents",
@@ -1522,93 +1717,109 @@
             blockType: Scratch.BlockType.COMMAND,
             arguments: {
               TIME: {
-                type: Scratch.ArgumentType.NUMBER
-              }
-            }
+                type: Scratch.ArgumentType.NUMBER,
+              },
+            },
           },
           {
             opcode: "setMidiEventList",
-            text: Scratch.translate("Set list [LIST] to events in last [TIME] seconds"),
+            text: Scratch.translate(
+              "Set list [LIST] to events in last [TIME] seconds"
+            ),
             blockType: Scratch.BlockType.COMMAND,
             arguments: {
               LIST: {
                 type: Scratch.ArgumentType.STRING,
-                menu: "lists"
+                menu: "lists",
               },
               TIME: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 5
-              }
-            }
-          }
+                defaultValue: 5,
+              },
+            },
+          },
         ],
         menus: {
           EVENT_TYPES: {
             acceptReporters: true,
-            items: EVENT_TYPES_ITEMS
+            items: EVENT_TYPES_ITEMS,
           },
           EVENT_TYPES_OPTIONAL: {
             acceptReporters: true,
             items: [
               ...EVENT_TYPES_ITEMS,
-              { value: ANY_TYPE, text: Scratch.translate("Any") }
-            ]
+              { value: ANY_TYPE, text: Scratch.translate("Any") },
+            ],
           },
           INPUT_DEVICES: {
             acceptReporters: true,
-            items: "inputDevicesMenu"
+            items: "inputDevicesMenu",
           },
           OUTPUT_DEVICES: {
             acceptReporters: true,
-            items: "outputDevicesMenu"
+            items: "outputDevicesMenu",
           },
           DEVICE_TYPES: {
             acceptReporters: true,
             items: [
-              { value: 'input', text: Scratch.translate("input") },
-              { value: 'output', text: Scratch.translate("output") },
-            ]
+              { value: "input", text: Scratch.translate("input") },
+              { value: "output", text: Scratch.translate("output") },
+            ],
           },
           DEVICE_PROP: {
             acceptReporters: true,
             items: [
               { value: "id", text: Scratch.translate("Device ID") },
-              { value: "manufacturer", text: Scratch.translate("Manufacturer") },
+              {
+                value: "manufacturer",
+                text: Scratch.translate("Manufacturer"),
+              },
               { value: "name", text: Scratch.translate("Device Name") },
-              { value: "state", text: Scratch.translate("State") }
-            ]
+              { value: "state", text: Scratch.translate("State") },
+            ],
           },
           NOTE_EVENT_TYPE: {
             acceptReporters: true,
             items: [
               { value: ANY_TYPE, text: Scratch.translate("Note On/Off") },
               { value: "noteOn", text: Scratch.translate("Note On") },
-              { value: "noteOff", text: Scratch.translate("Note Off") }
-            ]
+              { value: "noteOff", text: Scratch.translate("Note Off") },
+            ],
           },
           ACCIDENTALS: {
             acceptReporters: true,
             items: [
               { value: "sharps", text: `♯ ${Scratch.translate("Sharps")}` },
-              { value: "flats", text: `♭ ${Scratch.translate("Flats")}` }
-            ]
+              { value: "flats", text: `♭ ${Scratch.translate("Flats")}` },
+            ],
           },
           NOTE_NAMES: {
             acceptReporters: true,
             // the result of these don't need translation - they're just "C4" or "G#6"
-            items: [...MIDI_NOTES.entries()]
-              .map(([index, text]) => ({ value: `${index}`, text }))
+            items: [...MIDI_NOTES.entries()].map(([index, text]) => ({
+              value: `${index}`,
+              text,
+            })),
           },
           CHANNELS: {
             acceptReporters: true,
             items: [
               { value: "0", text: Scratch.translate("any channel") },
-              ..."0".repeat(15).split("").map((_, i) => ({ value: `${i + 1}`, text: `channel ${i + 1}` }))
-            ]
+              ..."0"
+                .repeat(15)
+                .split("")
+                .map((_, i) => ({
+                  value: `${i + 1}`,
+                  text: `channel ${i + 1}`,
+                })),
+            ],
           },
           PROPS: {
             acceptReporters: true,
-            items: Object.entries(eventProps).map(([value, { text }]) => ({ value, text }))
+            items: Object.entries(eventProps).map(([value, { text }]) => ({
+              value,
+              text,
+            })),
           },
           DEVICE_PROPS: {
             acceptReporters: true,
@@ -1616,15 +1827,18 @@
               { value: "id", text: Scratch.translate("Id") },
               { value: "name", text: Scratch.translate("Name") },
               { value: "state", text: Scratch.translate("State") },
-              { value: "manufacturer", text: Scratch.translate("Manufacturer") }
-            ]
+              {
+                value: "manufacturer",
+                text: Scratch.translate("Manufacturer"),
+              },
+            ],
           },
           // taken from /Lily/ListTools.js
           lists: {
             acceptReporters: true,
             items: "_getLists",
           },
-        }
+        },
       };
     }
     // taken from /Lily/ListTools.js
@@ -1649,12 +1863,18 @@
       await this.midi.initialize({ sysex, force });
     }
     _isAnyArg(val) {
-      return val == undefined || val == "" || val == ANY_TYPE || typeof val === "string" && /^\*|any$/i.test(val);
+      return (
+        val == undefined ||
+        val == "" ||
+        val == ANY_TYPE ||
+        (typeof val === "string" && /^\*|any$/i.test(val))
+      );
     }
     numDevices({ DEVICE_TYPE }) {
       this._ensureInitialize();
       const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
-      const deviceList = deviceType === 'output' ? this.midi.outputs : this.midi.inputs;
+      const deviceList =
+        deviceType === "output" ? this.midi.outputs : this.midi.inputs;
 
       return deviceList.length;
     }
@@ -1665,28 +1885,42 @@
     getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
       const index = Cast.toNumber(INDEX);
       const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
-      const deviceList = deviceType === 'input' ? this.midi.inputs : this.midi.outputs;
+      const deviceList =
+        deviceType === "input" ? this.midi.inputs : this.midi.outputs;
       const device = deviceList[index];
       if (!device) return "";
       return device[DEVICE_PROP];
     }
     inputDevicesMenu() {
-      const inputList = this.midi.inputs.map((d) => ({ text: d.name || d.id, value: d.id }));
-      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(inputList);
+      const inputList = this.midi.inputs.map((d) => ({
+        text: d.name || d.id,
+        value: d.id,
+      }));
+      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(
+        inputList
+      );
     }
     outputDevicesMenu() {
-      const outputList = this.midi.outputs.map((d) => ({ text: d.name || d.id, value: d.id }));
-      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(outputList);
+      const outputList = this.midi.outputs.map((d) => ({
+        text: d.name || d.id,
+        value: d.id,
+      }));
+      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(
+        outputList
+      );
     }
     whenNoteOnOff({ NOTE, PRESS }, util) {
       const isAny = this._isAnyArg(PRESS);
-      let type = isAny ? ['noteOn', 'noteOff'] : [normalizeType(Scratch.Cast.toString(PRESS))];
+      let type = isAny
+        ? ["noteOn", "noteOff"]
+        : [normalizeType(Scratch.Cast.toString(PRESS))];
 
       const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
       const last = this.recorder.getLast();
 
       // filter if only note on or note off
-      if (last &&
+      if (
+        last &&
         type.includes(last.type) &&
         (pitch === undefined || last.pitch === pitch)
       ) {
@@ -1698,7 +1932,9 @@
     }
     whenAnyNoteOnOff({ PRESS }, util) {
       const isAny = this._isAnyArg(PRESS);
-      let type = isAny ? ['noteOn', 'noteOff'] : [normalizeType(Scratch.Cast.toString(PRESS))];
+      let type = isAny
+        ? ["noteOn", "noteOff"]
+        : [normalizeType(Scratch.Cast.toString(PRESS))];
 
       const last = this.recorder.getLast();
       // filter if only note on or note off
@@ -1711,7 +1947,9 @@
     }
     whenMidiEvent({ TYPE }, util) {
       const isAny = this._isAnyArg(TYPE);
-      const type = isAny ? undefined : normalizeType(Scratch.Cast.toString(TYPE));
+      const type = isAny
+        ? undefined
+        : normalizeType(Scratch.Cast.toString(TYPE));
       const last = this.recorder.getLast();
       if (last && (isAny || last.type === type)) {
         setThreadMidiValue(util.thread, last);
@@ -1720,7 +1958,7 @@
       return false;
     }
     /**
-     * 
+     *
      * @param {MidiEvent} event
      * @returns {MidiEvent}
      */
@@ -1738,25 +1976,27 @@
     }
     playNoteForBeats({ NOTE, BEATS }, util) {
       const pitch = noteNameToMidiPitch(Cast.toString(NOTE)) || undefined;
-      const beats = typeof BEATS === 'string' && BEATS.includes('/')
-        ? parseFraction(BEATS)
-        : Cast.toNumber(BEATS);
+      const beats =
+        typeof BEATS === "string" && BEATS.includes("/")
+          ? parseFraction(BEATS)
+          : Cast.toNumber(BEATS);
 
       const event = this._eventBeatsToSeconds({
-        type: 'noteOn',
-        ...(pitch != undefined) && { pitch },
-        dur: beats
+        type: "noteOn",
+        ...(pitch != undefined && { pitch }),
+        dur: beats,
       });
       this.midi.sendOutputEvent(event);
     }
     sendOutputEvent({ EVENT, POS }, util) {
       const text = Cast.toString(EVENT);
-      const pos = typeof POS === 'string' && POS.includes('/')
-        ? parseFraction(POS)
-        : Cast.toNumber(POS);
+      const pos =
+        typeof POS === "string" && POS.includes("/")
+          ? parseFraction(POS)
+          : Cast.toNumber(POS);
       const event = this._eventBeatsToSeconds({
         // default value is 0, so if event has something set (like "C#3 pos=1/4 beats=1") then let it take precedence, otherwise override
-        ...(pos > 0) && { pos },
+        ...(pos > 0 && { pos }),
         ...stringToMidi(text),
       });
 
@@ -1771,9 +2011,7 @@
       if (!EVENT) return "";
       const last = getThreadMidiValue(util.thread);
       // use cached thread value if available instead of re-parsing
-      const evt = last?._str === EVENT
-        ? last
-        : stringToMidi(EVENT);
+      const evt = last?._str === EVENT ? last : stringToMidi(EVENT);
 
       return evt?.[key] ?? "";
     }
@@ -1788,7 +2026,9 @@
       if (pitch == undefined) {
         const notes = this.recorder.getActiveNotes(channel);
         setThreadActiveNotes(util.thread, { channel, notes });
-        return notes.length == 0 ? undefined : notes.reduce((a, b) => a.when > b.when ? a : b);
+        return notes.length == 0
+          ? undefined
+          : notes.reduce((a, b) => (a.when > b.when ? a : b));
       }
       const note = this.recorder.getActiveNote(pitch, channel || undefined);
       if (note) {
@@ -1810,7 +2050,7 @@
       return noteNameToMidiPitch(name) || 0;
     }
     nameForNote({ NOTE, ACCIDENTAL }, util) {
-      const useFlats = Cast.toString(ACCIDENTAL) === 'flats';
+      const useFlats = Cast.toString(ACCIDENTAL) === "flats";
       let val = Cast.toNumber(NOTE);
       if (!val && /^[a-g]/i.test(`${NOTE}`)) {
         val = noteNameToMidiPitch(Cast.toString(NOTE)) || 0;
@@ -1818,9 +2058,10 @@
       return midiPitchToNoteName(val, { useFlats });
     }
     makeOutputNote({ NOTE, BEATS, VELOCITY, CHANNEL, DEVICE }) {
-      let dur = typeof BEATS === 'string' && BEATS.includes('/')
-        ? parseFraction(BEATS)
-        : Cast.toNumber(BEATS);
+      let dur =
+        typeof BEATS === "string" && BEATS.includes("/")
+          ? parseFraction(BEATS)
+          : Cast.toNumber(BEATS);
       // sanity check - don't let a note be more than 1 minute
       // if anyone ever needs a longer note then they should manually write event string
       dur = Math.max(0, Math.min(dur, 60));
@@ -1831,15 +2072,15 @@
       velocity = Math.max(0, Math.min(velocity, 127));
       // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
       const deviceId = Cast.toString(DEVICE);
-      const device = this.midi.outputs.findIndex(d => d.id === deviceId);
+      const device = this.midi.outputs.findIndex((d) => d.id === deviceId);
       /** @type {MidiEvent} */
       const event = {
-        type: 'noteOn',
+        type: "noteOn",
         pitch: this.noteForName({ NOTE }),
         velocity,
         channel: Cast.toNumber(CHANNEL) || undefined,
         device: device === -1 ? undefined : device,
-        dur
+        dur,
       };
       return midiToString(event);
     }
@@ -1872,7 +2113,7 @@
 
       // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
       const deviceId = Cast.toString(DEVICE);
-      const device = this.midi.outputs.findIndex(d => d.id === deviceId);
+      const device = this.midi.outputs.findIndex((d) => d.id === deviceId);
       // FUTURE this may make sense to get moved out to helper alongside rawMessageToMidi
       /** @type {MidiEvent} */
       const event = {
@@ -1881,9 +2122,9 @@
         value2,
         channel: Cast.toNumber(CHANNEL) || undefined,
         device: device === -1 ? undefined : device,
-        ...spec?.param1 && { [spec.param1]: value1 },
-        ...spec?.param2 && { [spec.param2]: value2 },
-        ...spec?.highResParam && parseHighResValue(value1, value2)
+        ...(spec?.param1 && { [spec.param1]: value1 }),
+        ...(spec?.param2 && { [spec.param2]: value2 }),
+        ...(spec?.highResParam && parseHighResValue(value1, value2)),
       };
       return midiToString(event);
     }
@@ -1907,7 +2148,11 @@
       const start = this.recorder._now() - duration;
       const events = this.recorder.getRange(start);
       if (LIST) {
-        this._upsertList(LIST, events.map((evt) => evt._str), util.target);
+        this._upsertList(
+          LIST,
+          events.map((evt) => evt._str),
+          util.target
+        );
       }
     }
     getActiveNotes(args, util) {
@@ -1927,13 +2172,17 @@
         setThreadMidiValue(util.thread, note);
         return note._str;
       }
-      return '';
+      return "";
     }
     setActiveNoteList({ LIST }, util) {
       const notes = Array.from(this.recorder.getActiveNotes());
       setThreadActiveNotes(util.thread, { notes });
       if (LIST) {
-        this._upsertList(LIST, notes.map((note) => note._str), util.target);
+        this._upsertList(
+          LIST,
+          notes.map((note) => note._str),
+          util.target
+        );
       }
     }
     _upsertList(name, value, target) {
@@ -1959,7 +2208,7 @@
       const event = stringToMidi(raw);
 
       // REVIEW - remove value1/value2 if already specified by event spec?
-      if (event && ('pitch' in event || 'value' in event)) {
+      if (event && ("pitch" in event || "value" in event)) {
         delete event.value1;
         delete event.value2;
       }
@@ -1971,17 +2220,21 @@
       let event = null;
       try {
         event = {
-          ...JSON.parse(raw)
+          ...JSON.parse(raw),
         };
         // rename aliases just in case
-        [['beats', 'dur'], ['offset', 'pos'], ['@', 'time']]
-          .filter(([alias, key]) => (alias in event) && event[key] == undefined)
-          .forEach(([alias, key]) => event[key] = event[alias]);
-      } catch (error) { }
-      return event ? midiToString(event) : ""
+        [
+          ["beats", "dur"],
+          ["offset", "pos"],
+          ["@", "time"],
+        ]
+          .filter(([alias, key]) => alias in event && event[key] == undefined)
+          .forEach(([alias, key]) => (event[key] = event[alias]));
+      } catch (error) {}
+      return event ? midiToString(event) : "";
     }
-  };
+  }
 
-//#endregion
+  //#endregion
   Scratch.extensions.register(new MidiExtension());
-})(Scratch);
\ No newline at end of file
+})(Scratch);

From 7085252b3bcc4aad55ae64c207c3d7c360fed47f Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 10 Mar 2025 11:22:22 -0400
Subject: [PATCH 39/61] midi.js - linting and ensure all inputs use
 Scratch.Cast

---
 extensions/midi/midi.js | 96 +++++++++++++++++++++++------------------
 1 file changed, 54 insertions(+), 42 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 1fb8cac386..8523b5bf7e 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -356,7 +356,6 @@
    */
   function midiToString(event, opts = {}) {
     const { noMinify } = opts;
-    let type = shorthands[event.type];
     const spec = eventMapping[event.type] ?? {};
     // ensure these are set properly
     const {
@@ -395,17 +394,17 @@
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
-    if (typeof text !== "string") text = `${String(text) ?? ""}`;
+    if (typeof text !== "string") text = Cast.toString(text);
     const fullRe =
       /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
     const match = fullRe.exec(text);
     if (!match?.groups) return null;
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
     // ch/dev/@ (channel, device, time) are special keys that don't need =
-    const keyvalRe = /\s*(?<key>\w+(?=\=)|ch|dev|@)=?(?<val>\S+)\s*/g;
+    const keyvalRe = /\s*(?<key>\w+(?==)|ch|dev|@)=?(?<val>\S+)\s*/g;
     /** @type {{[K in keyof MidiEvent]?: string}} */
     const extras = Object.fromEntries(
-      [...match.groups.keyvals?.matchAll(keyvalRe)]
+      Array.from(match.groups.keyvals?.matchAll(keyvalRe) || [])
         // paramLookup converts "t=2" into "time=2"
         .map(({ groups: { key, val } }) => [paramLookup[key] || key, val])
     );
@@ -444,6 +443,7 @@
       return null;
     }
     const spec = eventMapping[event.type];
+    let parsedHighRes = undefined;
     switch (event.type) {
       case "noteOn":
       case "noteOff":
@@ -478,12 +478,15 @@
       case "pitchBend":
         if (value1 == undefined) return null;
         // these two types have a higher precision value
-        const { value: highResValue, ...normedValues } = parseHighResValue(
+        parsedHighRes = parseHighResValue(
           value1,
           value2
         );
-        Object.assign(event, normedValues);
-        event[spec.highResParam ?? "value"] = highResValue;
+        Object.assign(event, {
+          [spec.highResParam ?? "value"]: parsedHighRes.value,
+          value1: parsedHighRes.value1,
+          value2: parsedHighRes.value2
+        });
         break;
       case "clock":
       case "start":
@@ -599,7 +602,7 @@
   }
   function parseHighResValue(value1, value2) {
     const value =
-      typeof value2 == undefined ? value1 : msbLsbToValue(value1, value2);
+      (value2 == undefined) ? value1 : msbLsbToValue(value1, value2);
     return {
       value,
       ...valueToMsbLsb(value),
@@ -692,12 +695,12 @@
       }),
     };
   }
-  function isPitchedEvent(type) {
-    return (
-      !!type &&
-      (type === "noteOn" || type === "noteOff" || type === "polyTouch")
-    );
-  }
+  // function isPitchedEvent(type) {
+  //   return (
+  //     !!type &&
+  //     (type === "noteOn" || type === "noteOff" || type === "polyTouch")
+  //   );
+  // }
 
   // Make a full array of notes in full midi range from 0 (C-1) to 127 (G-9)
   const MIDI_NOTES = "_"
@@ -826,7 +829,7 @@
     get defaultOutput() {
       return this.outputs.find((d) => d.state === "connected");
     }
-    async initialize({
+    initialize({
       sysex = false,
       force = false,
       timeoutMS = 1e3 * 30,
@@ -1175,7 +1178,8 @@
       return this.getLast("polyTouch", pitch, channel);
     }
     getLast(type, value1, channel) {
-      if (((type === value1) === channel) === undefined) {
+      // shortcut - just get last event if no filter
+      if (type == undefined && value1 == undefined && channel == undefined) {
         return this.buffer[this.buffer.length - 1];
       }
       if (type === "cc" && value1) {
@@ -1207,7 +1211,6 @@
     _prune(when = this._now()) {
       this.recordStart || (this.recordStart = when);
       const threshold = when - this.bufferSeconds;
-      const n = this.buffer.length;
       if (this.buffer.length > this.maxEntries) {
         this.buffer = this.buffer.slice(-1 * this.maxEntries);
       }
@@ -1270,9 +1273,9 @@
   function beatsToSeconds(beats = 1, tempo = getTempo()) {
     return (beats * 60) / tempo;
   }
-  function secondsToBeats(seconds = 1, tempo = getTempo()) {
-    return (seconds * tempo) / 60;
-  }
+  // function secondsToBeats(seconds = 1, tempo = getTempo()) {
+  //   return (seconds * tempo) / 60;
+  // }
 
   //#endregion wrapper
 
@@ -1401,7 +1404,7 @@
               },
               INDEX: {
                 type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0,
+                defaultValue: 1,
               },
             },
           },
@@ -1862,12 +1865,15 @@
       const force = Cast.toBoolean(FORCE);
       await this.midi.initialize({ sysex, force });
     }
+    /**
+     * Checks if input value is whitespace or '*' or 'any'.
+     * @param {unknown} val 
+     * @returns {val is typeof ANY_TYPE}
+     */
     _isAnyArg(val) {
       return (
-        val == undefined ||
-        val == "" ||
-        val == ANY_TYPE ||
-        (typeof val === "string" && /^\*|any$/i.test(val))
+        val === ANY_TYPE ||
+        /^(\*|any|\s*)$/i.test(Cast.toString(val))
       );
     }
     numDevices({ DEVICE_TYPE }) {
@@ -1883,13 +1889,14 @@
       return this.midi.outputs.length;
     }
     getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
-      const index = Cast.toNumber(INDEX);
       const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
       const deviceList =
         deviceType === "input" ? this.midi.inputs : this.midi.outputs;
-      const device = deviceList[index];
+      const index = Cast.toListIndex(INDEX, deviceList.length, false);
+      const device = typeof index === 'number' ? deviceList[index - 1] : undefined;
       if (!device) return "";
-      return device[DEVICE_PROP];
+      const prop = Cast.toString(DEVICE_PROP);
+      return device[DEVICE_PROP] ?? "";
     }
     inputDevicesMenu() {
       const inputList = this.midi.inputs.map((d) => ({
@@ -1913,7 +1920,7 @@
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
         ? ["noteOn", "noteOff"]
-        : [normalizeType(Scratch.Cast.toString(PRESS))];
+        : [normalizeType(Cast.toString(PRESS))];
 
       const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
       const last = this.recorder.getLast();
@@ -1934,7 +1941,7 @@
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
         ? ["noteOn", "noteOff"]
-        : [normalizeType(Scratch.Cast.toString(PRESS))];
+        : [normalizeType(Cast.toString(PRESS))];
 
       const last = this.recorder.getLast();
       // filter if only note on or note off
@@ -1949,7 +1956,7 @@
       const isAny = this._isAnyArg(TYPE);
       const type = isAny
         ? undefined
-        : normalizeType(Scratch.Cast.toString(TYPE));
+        : normalizeType(Cast.toString(TYPE));
       const last = this.recorder.getLast();
       if (last && (isAny || last.type === type)) {
         setThreadMidiValue(util.thread, last);
@@ -2007,7 +2014,7 @@
     }
     getEventProp({ EVENT, PROP }, util) {
       const propName = Cast.toString(PROP);
-      const { key = "value", type } = eventProps[propName] ?? {};
+      const { key = "value" } = eventProps[propName] ?? {};
       if (!EVENT) return "";
       const last = getThreadMidiValue(util.thread);
       // use cached thread value if available instead of re-parsing
@@ -2015,7 +2022,7 @@
 
       return evt?.[key] ?? "";
     }
-    lastEvent(args, util) {
+    lastEvent(_args, util) {
       let last = getThreadMidiValue(util.thread);
       last || (last = this.recorder.getLast());
       return last ? midiToString(last) : "";
@@ -2037,7 +2044,7 @@
       return !!note;
     }
     isEventOfType({ TYPE }, util) {
-      const type = TYPE === ANY_TYPE ? undefined : TYPE;
+      const type = this._isAnyArg(TYPE) ? undefined : Cast.toString(TYPE);
       let last = getThreadMidiValue(util.thread);
       last || (last = this.recorder.getLast());
       return last?.type === type;
@@ -2050,7 +2057,7 @@
       return noteNameToMidiPitch(name) || 0;
     }
     nameForNote({ NOTE, ACCIDENTAL }, util) {
-      const useFlats = Cast.toString(ACCIDENTAL) === "flats";
+      const useFlats = Cast.toString(ACCIDENTAL).toLowerCase() === "flats";
       let val = Cast.toNumber(NOTE);
       if (!val && /^[a-g]/i.test(`${NOTE}`)) {
         val = noteNameToMidiPitch(Cast.toString(NOTE)) || 0;
@@ -2088,13 +2095,12 @@
       /** @type {EventType} */
       // @ts-ignore
       let type = Cast.toString(TYPE);
-      // TODO make menu for EVENT_TYPE that doesn't include "any"
       // default is CC - is that right?
       // @ts-ignore
-      if (type === ANY_TYPE) type = "cc";
+      if (this._isAnyArg(type)) type = "cc";
+      let spec = eventMapping[type];
       // UNDOCUMENTED - allow raw number for command.
       // note that the command lookup restricts command types, so will exclude sysex messages (which are possible security risk but already blocked by browsers anyways)
-      let spec = eventMapping[type];
       if (!spec && /(0x)?[a-f0-9]+/i.test(type)) {
         const rawType = /[a-f]/.test(type)
           ? parseInt(type, 16)
@@ -2149,7 +2155,7 @@
       const events = this.recorder.getRange(start);
       if (LIST) {
         this._upsertList(
-          LIST,
+          Cast.toString(LIST),
           events.map((evt) => evt._str),
           util.target
         );
@@ -2161,13 +2167,19 @@
       return notes.map((note) => note._str ?? midiToString(note)).join("\n");
     }
     getActiveNoteByIndex({ INDEX }, util) {
-      const index = Cast.toNumber(INDEX) || 0;
       let active = getThreadActiveNotes(util.thread);
       if (!active) {
         active = { notes: this.recorder.getActiveNotes() };
         setThreadActiveNotes(util.thread, active);
       }
-      const note = (active.notes || [])[index];
+      let index = Cast.toListIndex(INDEX, active.length, true);
+      if (!active.notes || index === 'INVALID') {
+        return "";
+      }
+      if (index === 'ALL') {
+        index = 1;
+      }
+      const note = active.notes[index - 1];
       if (note) {
         setThreadMidiValue(util.thread, note);
         return note._str;
@@ -2179,7 +2191,7 @@
       setThreadActiveNotes(util.thread, { notes });
       if (LIST) {
         this._upsertList(
-          LIST,
+          Cast.toString(LIST),
           notes.map((note) => note._str),
           util.target
         );

From 9ff419faafffcaaea4ac731094f4fc99ef715962 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 10 Mar 2025 11:24:19 -0400
Subject: [PATCH 40/61] Update midi.js

---
 extensions/midi/midi.js | 36 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 8523b5bf7e..409829fa54 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -478,14 +478,11 @@
       case "pitchBend":
         if (value1 == undefined) return null;
         // these two types have a higher precision value
-        parsedHighRes = parseHighResValue(
-          value1,
-          value2
-        );
+        parsedHighRes = parseHighResValue(value1, value2);
         Object.assign(event, {
           [spec.highResParam ?? "value"]: parsedHighRes.value,
           value1: parsedHighRes.value1,
-          value2: parsedHighRes.value2
+          value2: parsedHighRes.value2,
         });
         break;
       case "clock":
@@ -601,8 +598,7 @@
     return (msb << 7) + lsb;
   }
   function parseHighResValue(value1, value2) {
-    const value =
-      (value2 == undefined) ? value1 : msbLsbToValue(value1, value2);
+    const value = value2 == undefined ? value1 : msbLsbToValue(value1, value2);
     return {
       value,
       ...valueToMsbLsb(value),
@@ -829,11 +825,7 @@
     get defaultOutput() {
       return this.outputs.find((d) => d.state === "connected");
     }
-    initialize({
-      sysex = false,
-      force = false,
-      timeoutMS = 1e3 * 30,
-    } = {}) {
+    initialize({ sysex = false, force = false, timeoutMS = 1e3 * 30 } = {}) {
       if (this._init && !force) {
         return this._init;
       }
@@ -1867,14 +1859,11 @@
     }
     /**
      * Checks if input value is whitespace or '*' or 'any'.
-     * @param {unknown} val 
+     * @param {unknown} val
      * @returns {val is typeof ANY_TYPE}
      */
     _isAnyArg(val) {
-      return (
-        val === ANY_TYPE ||
-        /^(\*|any|\s*)$/i.test(Cast.toString(val))
-      );
+      return val === ANY_TYPE || /^(\*|any|\s*)$/i.test(Cast.toString(val));
     }
     numDevices({ DEVICE_TYPE }) {
       this._ensureInitialize();
@@ -1893,10 +1882,11 @@
       const deviceList =
         deviceType === "input" ? this.midi.inputs : this.midi.outputs;
       const index = Cast.toListIndex(INDEX, deviceList.length, false);
-      const device = typeof index === 'number' ? deviceList[index - 1] : undefined;
+      const device =
+        typeof index === "number" ? deviceList[index - 1] : undefined;
       if (!device) return "";
       const prop = Cast.toString(DEVICE_PROP);
-      return device[DEVICE_PROP] ?? "";
+      return device[prop] ?? "";
     }
     inputDevicesMenu() {
       const inputList = this.midi.inputs.map((d) => ({
@@ -1954,9 +1944,7 @@
     }
     whenMidiEvent({ TYPE }, util) {
       const isAny = this._isAnyArg(TYPE);
-      const type = isAny
-        ? undefined
-        : normalizeType(Cast.toString(TYPE));
+      const type = isAny ? undefined : normalizeType(Cast.toString(TYPE));
       const last = this.recorder.getLast();
       if (last && (isAny || last.type === type)) {
         setThreadMidiValue(util.thread, last);
@@ -2173,10 +2161,10 @@
         setThreadActiveNotes(util.thread, active);
       }
       let index = Cast.toListIndex(INDEX, active.length, true);
-      if (!active.notes || index === 'INVALID') {
+      if (!active.notes || index === "INVALID") {
         return "";
       }
-      if (index === 'ALL') {
+      if (index === "ALL") {
         index = 1;
       }
       const note = active.notes[index - 1];

From cc44e9bd9c0068359a8d0e53357f2f75b873d1dd Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 11:30:34 -0400
Subject: [PATCH 41/61] midi - add "whenDeviceEvent" hat for detecting device
 connect/disconnect

---
 extensions/midi/midi.js | 46 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 409829fa54..b7e75bd191 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -782,6 +782,10 @@
           }
         }
       };
+      /**
+       *
+       * @param {MIDIPortEventMap['statechange']} event
+       */
       this._onDeviceStateChange = (event) => {
         const { port } = event;
         if (!port) return;
@@ -1275,6 +1279,7 @@
 
   // hardcoded mapping of hats events, b/c I'll never remember the convention otherwise
   const HATS = {
+    DEVICE: `${EXT_ID}_whenDeviceEvent`,
     NOTE: `${EXT_ID}_whenNoteOnOff`,
     NOTEANY: `${EXT_ID}_whenAnyNoteOnOff`,
     MIDI: `${EXT_ID}_whenMidiEvent`,
@@ -1310,6 +1315,13 @@
      */
     _addListeners() {
       const vm = globalThis.Scratch.vm;
+      this.midi.on("device:status", (domEvent) => {
+        const changeEvent = domEvent.detail;
+        vm.runtime.startHats(HATS.DEVICE, {
+          DEVICE_TYPE: changeEvent.type,
+          STATE: changeEvent.state,
+        });
+      });
       this.midi.on("midi", (domEvent) => {
         const midiEvent = domEvent.detail;
         this.recorder.add(midiEvent);
@@ -1365,6 +1377,25 @@
           //     }
           //   }
           // },
+          {
+            opcode: "whenDeviceEvent",
+            text: Scratch.translate("when [DEVICE_TYPE] device [STATE]"),
+            blockType: Scratch.BlockType.EVENT,
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            arguments: {
+              DEVICE_TYPE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "DEVICE_TYPES",
+                defaultValue: "input",
+              },
+              STATE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "DEVICE_STATES",
+                defaultValue: "connected",
+              },
+            },
+          },
           {
             opcode: "numDevices",
             text: Scratch.translate("number of [DEVICE_TYPE] devices"),
@@ -1755,7 +1786,7 @@
             items: "outputDevicesMenu",
           },
           DEVICE_TYPES: {
-            acceptReporters: true,
+            acceptReporters: false,
             items: [
               { value: "input", text: Scratch.translate("input") },
               { value: "output", text: Scratch.translate("output") },
@@ -1773,6 +1804,16 @@
               { value: "state", text: Scratch.translate("State") },
             ],
           },
+          DEVICE_STATES: {
+            acceptReporters: false,
+            items: [
+              { value: "connected", text: Scratch.translate("connected") },
+              {
+                value: "disconnected",
+                text: Scratch.translate("disconnected"),
+              },
+            ],
+          },
           NOTE_EVENT_TYPE: {
             acceptReporters: true,
             items: [
@@ -1906,6 +1947,9 @@
         outputList
       );
     }
+    // handled automatically b/c blockType = EVENT instead of HAT
+    // whenDeviceEvent({ DEVICE_TYPE, STATE }, util) {
+    // }
     whenNoteOnOff({ NOTE, PRESS }, util) {
       const isAny = this._isAnyArg(PRESS);
       let type = isAny

From e6e553c29c874de8393cff75f5e951b89065d757 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 11:30:49 -0400
Subject: [PATCH 42/61] add midi to extensions list

---
 extensions/extensions.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/extensions/extensions.json b/extensions/extensions.json
index d8ed71e33d..43d6c3a2c9 100644
--- a/extensions/extensions.json
+++ b/extensions/extensions.json
@@ -48,6 +48,7 @@
   "ar",
   "encoding",
   "Lily/SoundExpanded",
+  "midi/midi",
   "Lily/TempVariables2",
   "Lily/MoreTimers",
   "clouddata-ping",

From 88184f0695b7c9337f91fd900d12118e5d4a456c Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 14:34:26 -0400
Subject: [PATCH 43/61] bugfix in string parsing and minor formatting

---
 extensions/midi/midi.js | 51 +++++++++++++++++++++--------------------
 1 file changed, 26 insertions(+), 25 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index b7e75bd191..2977399a15 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -22,30 +22,31 @@
    * // definition for the parsed midi event
    * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset'} EventType
    * @typedef {object} MidiEvent
-   * @property {EventType | 'rest'} type
-   * @property {number} [value1]
-   * @property {number} [value2]
-   * @property {number} [channel]
-   * @property {number} [device]
-   * @property {number} [time]
-   * @property {number} [pitch]
-   * @property {number} [velocity]
-   * @property {number} [cc]
-   * @property {number} [value]
-   * @property {number} [pos]
-   * @property {number} [dur]
+   * @property {EventType | 'rest'} type type of midi command (note on, program change, tc). Default is 'noteOn'
+   * @property {number} [value1] (0-127) raw data1 byte value
+   * @property {number} [value2] (0-127) raw data2 byte value
+   * @property {number} [channel] (1-16) channel of event. default is 1
+   * @property {number} [device] (1-N) index of midi input/output device
+   * @property {number} [time] time of event in seconds
+   * @property {number} [pitch] note pitch (0-127). C4=60
+   * @property {number} [velocity] note velocity (0-127). If this is 0 then treated as a note off event
+   * @property {number} [cc] continuous controller number (0-127)
+   * @property {number} [value] cc / pitchBend/programChange value (0-127 except for songPosition / pitchbend)
+   * @property {number} [pos] time in beats - gets converted to time using current tempo
+   * @property {number} [dur] (note type only) duration in seconds- send corresponding note off event automatically
+   * @property {number} [beats] gets converted to dur using current tempo
    * @property {string} [_str] cached string representation of this event
    *
    *
    * @typedef {object} FormatOptions
-   * @property {number} [tempo]
-   * @property {boolean} [useFlats]
-   * @property {boolean} [noMinify]
-   * @property {'omit' | 'timestamp' | 'absolute'} [timestampFormat]
-   * @property {number} [startTimestamp]
-   * @property {boolean} [fixedWidth]
-   * @property {boolean} [useHex]
-   * @property {number} [defaultOctave]
+   * @property {number} [tempo] override tempo used in converting beats/pos. default is stage tempo
+   * @property {boolean} [useFlats] show notes as flats instead of sharps
+   * @property {boolean} [noMinify] include all data even if defaults
+   * @property {'omit' | 'timestamp' | 'absolute'} [timestampFormat] for future use
+   * @property {number} [startTimestamp] for future use
+   * @property {boolean} [fixedWidth] include padding to make values line up
+   * @property {boolean} [useHex] use hex for number values instead of base 10
+   * @property {number} [defaultOctave] default octave if not otherwise specfied. default 4
    *
    */
 
@@ -396,7 +397,7 @@
   function stringToMidi(text, opts = {}) {
     if (typeof text !== "string") text = Cast.toString(text);
     const fullRe =
-      /^\s*(?<type>[a-zA-Z]{2,})?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.+)\s*$/;
+      /^\s*(?<type>[a-zA-Z]{2,}|~)?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.*)\s*$/;
     const match = fullRe.exec(text);
     if (!match?.groups) return null;
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
@@ -517,7 +518,7 @@
   }
   function formatTime(
     { time = undefined },
-    { noMinify = false, timestampFormat = "absolute", startTimestamp = 0 }
+    { timestampFormat = "absolute", startTimestamp = 0 }
   ) {
     if (timestampFormat === "omit" || time == undefined) {
       return "";
@@ -531,12 +532,12 @@
   }
 
   // TODO FUTURE add in opts flag to use fractions or not
-  function formatPosition(value, opts) {
+  function formatPosition(value, _opts) {
     return `${PREFIX_POS}${formatFraction(value)}`;
   }
 
   // TODO FUTURE add in opts flag to use fractions or not
-  function formatDuration(value, opts) {
+  function formatDuration(value, _opts) {
     return `${PREFIX_DURATION}${formatFraction(value)}`;
   }
 
@@ -1566,7 +1567,7 @@
           {
             opcode: "playNoteForBeats",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate("play midi note [NOTE] for [BEATS] beats"),
+            text: Scratch.translate("play note [NOTE] for [BEATS] beats"),
             arguments: {
               NOTE: {
                 type: Scratch.ArgumentType.NOTE,

From 6a0db5c262ea3ed4ae44acf4e8ebb202f254eaff Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 14:35:20 -0400
Subject: [PATCH 44/61] midi - change params for sendOutputEvent

---
 extensions/midi/midi.js | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 2977399a15..548b7e7f6c 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -1582,17 +1582,15 @@
           {
             opcode: "sendOutputEvent",
             blockType: Scratch.BlockType.COMMAND,
-            text: Scratch.translate(
-              "schedule [EVENT] for [POS] beats from now"
-            ),
+            text: Scratch.translate("Send [EVENT] to [DEVICE]"),
             arguments: {
               EVENT: {
                 type: Scratch.ArgumentType.STRING,
                 defaultValue: "Eb4 beats=1/4",
               },
-              POS: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0,
+              DEVICE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "OUTPUT_DEVICES",
               },
             },
           },
@@ -2028,17 +2026,16 @@
       });
       this.midi.sendOutputEvent(event);
     }
-    sendOutputEvent({ EVENT, POS }, util) {
+    sendOutputEvent({ EVENT, DEVICE }, util) {
       const text = Cast.toString(EVENT);
-      const pos =
-        typeof POS === "string" && POS.includes("/")
-          ? parseFraction(POS)
-          : Cast.toNumber(POS);
-      const event = this._eventBeatsToSeconds({
-        // default value is 0, so if event has something set (like "C#3 pos=1/4 beats=1") then let it take precedence, otherwise override
-        ...(pos > 0 && { pos }),
-        ...stringToMidi(text),
-      });
+      const event = stringToMidi(text);
+
+      const deviceId = Cast.toString(DEVICE);
+      if (deviceId && event.device == undefined) {
+        const device =
+          deviceId && this.midi.outputs.findIndex((d) => d.id === deviceId);
+        event.device = device === -1 ? undefined : device;
+      }
 
       this.midi.sendOutputEvent(event);
     }

From 389bedd97199b7106de2b6ee77ca8c42be38aed4 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 14:38:14 -0400
Subject: [PATCH 45/61] midi - treat "pos" and "beats" as beats unit, "time"
 and "dur" as seconds

---
 extensions/midi/midi.js | 45 ++++++++++++++++-------------------------
 1 file changed, 17 insertions(+), 28 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 548b7e7f6c..3340a457d7 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -252,6 +252,7 @@
     dur: "dur",
     duration: "dur",
     pos: "pos",
+    beats: "beats",
     value: "value2",
   };
 
@@ -403,7 +404,7 @@
     // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
     // ch/dev/@ (channel, device, time) are special keys that don't need =
     const keyvalRe = /\s*(?<key>\w+(?==)|ch|dev|@)=?(?<val>\S+)\s*/g;
-    /** @type {{[K in keyof MidiEvent]?: string}} */
+    /** @type {{[K in keyof MidiEvent | 'beats']?: string}} */
     const extras = Object.fromEntries(
       Array.from(match.groups.keyvals?.matchAll(keyvalRe) || [])
         // paramLookup converts "t=2" into "time=2"
@@ -431,11 +432,20 @@
       channel: parseNumValue(extras.channel, opts),
       device: parseNumValue(extras.device, opts),
       ...(extras.time && { time: parseTimespan(extras.time) }),
-      // REVIEW is pos even needed? it's for setting output in beats, but setting time would make more sense instead
-      ...(extras.pos && { pos: parseFraction(extras.pos) }),
       ...(extras.dur && { dur: parseFraction(extras.dur) }),
+      ...(extras.pos && { pos: parseFraction(extras.pos) }),
+      ...(extras.beats && { beats: parseFraction(extras.beats) }),
     };
 
+    if (event.beats && event.dur == undefined) {
+      // NOTE - looks up tempo in vm stage
+      event.dur = beatsToSeconds(event.beats, opts.tempo);
+    }
+    if (event.pos && event.time == undefined) {
+      // NOTE - looks up tempo in vm stage
+      event.time = beatsToSeconds(event.pos, opts.tempo);
+    }
+
     // default to note event if has pitch (off if velocity = 0)
     if (!event.type && value1 >= 0) {
       event.type = "noteOn";
@@ -684,11 +694,11 @@
    * @param {number} [offsetMs] time to return relative to. Default is now
    */
   function getMidiOffsetTime(event, offsetMs = window.performance.now()) {
-    const { pos = 0, dur } = event;
+    const { time = 0, dur } = event;
     return {
-      start: offsetMs + pos * 1000,
+      start: offsetMs + time * 1000,
       ...(dur > 0 && {
-        end: offsetMs + (pos + dur) * 1000,
+        end: offsetMs + (time + dur) * 1000,
       }),
     };
   }
@@ -1995,23 +2005,6 @@
       }
       return false;
     }
-    /**
-     *
-     * @param {MidiEvent} event
-     * @returns {MidiEvent}
-     */
-    _eventBeatsToSeconds(event) {
-      const tempo = getTempo();
-      const { dur, pos } = event;
-      const out = { ...event };
-      if (dur != undefined) {
-        out.dur = beatsToSeconds(parseFraction(dur), tempo);
-      }
-      if (pos != undefined) {
-        out.pos = beatsToSeconds(parseFraction(pos), tempo);
-      }
-      return out;
-    }
     playNoteForBeats({ NOTE, BEATS }, util) {
       const pitch = noteNameToMidiPitch(Cast.toString(NOTE)) || undefined;
       const beats =
@@ -2019,11 +2012,7 @@
           ? parseFraction(BEATS)
           : Cast.toNumber(BEATS);
 
-      const event = this._eventBeatsToSeconds({
-        type: "noteOn",
-        ...(pitch != undefined && { pitch }),
-        dur: beats,
-      });
+      const event = stringToMidi(`${text}`);
       this.midi.sendOutputEvent(event);
     }
     sendOutputEvent({ EVENT, DEVICE }, util) {

From a21e70286c18c8dc2210d4564e72271df55a526d Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 11 Mar 2025 14:38:55 -0400
Subject: [PATCH 46/61] allow string event input into "play note for beats"
 command

---
 extensions/midi/midi.js | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 3340a457d7..2f40f55150 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -2006,12 +2006,15 @@
       return false;
     }
     playNoteForBeats({ NOTE, BEATS }, util) {
-      const pitch = noteNameToMidiPitch(Cast.toString(NOTE)) || undefined;
-      const beats =
-        typeof BEATS === "string" && BEATS.includes("/")
-          ? parseFraction(BEATS)
-          : Cast.toNumber(BEATS);
+      let text = Cast.toString(NOTE);
+      const beats = Cast.toString(BEATS);
+
+      // just append to text and let stringToMidi handle
+      if (beats) {
+        text += ` beats=${beats}`;
+      }
 
+      // default event type is note, so any valid input will be treated as note by default
       const event = stringToMidi(`${text}`);
       this.midi.sendOutputEvent(event);
     }

From cbe780d2d7b0afa5253ceaa88d171671448087dc Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 13 Mar 2025 00:38:38 -0400
Subject: [PATCH 47/61] reformatting as per comments

---
 extensions/midi/midi.js | 236 ++++++++++++++++++++++++++--------------
 1 file changed, 155 insertions(+), 81 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 2f40f55150..629ae8fde7 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -74,6 +74,8 @@
   }
   /**
    * convert a note string name (or raw midi number) to midi number value
+   * Examples of valid inputs: C4 C_4 C#7 Db6 F# F♯♯ B♭0 60 32
+   * Returns null if not a valid pitch string or midi note number
    * @param {string} note
    * @param {number} [defaultOctave]
    * @returns {number | null}
@@ -396,7 +398,7 @@
    * @returns {MidiEvent}
    */
   function stringToMidi(text, opts = {}) {
-    if (typeof text !== "string") text = Cast.toString(text);
+    if (typeof text !== "string") text = Scratch.Cast.toString(text);
     const fullRe =
       /^\s*(?<type>[a-zA-Z]{2,}|~)?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.*)\s*$/;
     const match = fullRe.exec(text);
@@ -716,10 +718,6 @@
     .flatMap((_, i) => SHARPS.map((c) => `${c}${i - 1}`))
     .slice(0, 128);
 
-  /**
-   * represents "any note" or "any device" etc. in menus
-   */
-  const ANY_TYPE = "*";
   /**
    * Scratch menu items of @see {MidiEvent} properties
    */
@@ -1302,7 +1300,6 @@
    * @type {'---'}
    */
   const SEPARATOR = "---";
-  const { Cast } = Scratch;
 
   class MidiExtension {
     constructor() {
@@ -1356,12 +1353,30 @@
     }
     getInfo() {
       const EVENT_TYPES_ITEMS = [
-        { value: "noteOn", text: Scratch.translate("Note On") },
-        { value: "noteOff", text: Scratch.translate("Note Off") },
-        { value: "cc", text: Scratch.translate("CC") },
-        { value: "polyTouch", text: Scratch.translate("AfterTouch") },
-        { value: "pitchBend", text: Scratch.translate("Pitch Bend") },
-        { value: "programChange", text: Scratch.translate("Program Change") },
+        {
+          value: "noteOn",
+          text: Scratch.translate("Note On"),
+        },
+        {
+          value: "noteOff",
+          text: Scratch.translate("Note Off"),
+        },
+        {
+          value: "cc",
+          text: Scratch.translate("CC"),
+        },
+        {
+          value: "polyTouch",
+          text: Scratch.translate("AfterTouch"),
+        },
+        {
+          value: "pitchBend",
+          text: Scratch.translate("Pitch Bend"),
+        },
+        {
+          value: "programChange",
+          text: Scratch.translate("Program Change"),
+        },
         {
           value: "channelPressure",
           text: Scratch.translate("Channel Pressure"),
@@ -1457,7 +1472,7 @@
               PRESS: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_EVENT_TYPE",
-                defaultValue: ANY_TYPE,
+                defaultValue: "ANY",
               },
             },
           },
@@ -1471,7 +1486,7 @@
               PRESS: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "NOTE_EVENT_TYPE",
-                defaultValue: ANY_TYPE,
+                defaultValue: "ANY",
               },
             },
           },
@@ -1485,7 +1500,7 @@
               TYPE: {
                 menu: "EVENT_TYPES_OPTIONAL",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: ANY_TYPE,
+                defaultValue: "ANY",
               },
             },
           },
@@ -1783,7 +1798,10 @@
             acceptReporters: true,
             items: [
               ...EVENT_TYPES_ITEMS,
-              { value: ANY_TYPE, text: Scratch.translate("Any") },
+              {
+                value: "ANY",
+                text: Scratch.translate("Any"),
+              },
             ],
           },
           INPUT_DEVICES: {
@@ -1797,26 +1815,44 @@
           DEVICE_TYPES: {
             acceptReporters: false,
             items: [
-              { value: "input", text: Scratch.translate("input") },
-              { value: "output", text: Scratch.translate("output") },
+              {
+                value: "input",
+                text: Scratch.translate("input"),
+              },
+              {
+                value: "output",
+                text: Scratch.translate("output"),
+              },
             ],
           },
           DEVICE_PROP: {
             acceptReporters: true,
             items: [
-              { value: "id", text: Scratch.translate("Device ID") },
+              {
+                value: "id",
+                text: Scratch.translate("Device ID"),
+              },
               {
                 value: "manufacturer",
                 text: Scratch.translate("Manufacturer"),
               },
-              { value: "name", text: Scratch.translate("Device Name") },
-              { value: "state", text: Scratch.translate("State") },
+              {
+                value: "name",
+                text: Scratch.translate("Device Name"),
+              },
+              {
+                value: "state",
+                text: Scratch.translate("State"),
+              },
             ],
           },
           DEVICE_STATES: {
             acceptReporters: false,
             items: [
-              { value: "connected", text: Scratch.translate("connected") },
+              {
+                value: "connected",
+                text: Scratch.translate("connected"),
+              },
               {
                 value: "disconnected",
                 text: Scratch.translate("disconnected"),
@@ -1826,16 +1862,31 @@
           NOTE_EVENT_TYPE: {
             acceptReporters: true,
             items: [
-              { value: ANY_TYPE, text: Scratch.translate("Note On/Off") },
-              { value: "noteOn", text: Scratch.translate("Note On") },
-              { value: "noteOff", text: Scratch.translate("Note Off") },
+              {
+                value: "ANY",
+                text: Scratch.translate("Note On/Off"),
+              },
+              {
+                value: "noteOn",
+                text: Scratch.translate("Note On"),
+              },
+              {
+                value: "noteOff",
+                text: Scratch.translate("Note Off"),
+              },
             ],
           },
           ACCIDENTALS: {
             acceptReporters: true,
             items: [
-              { value: "sharps", text: `♯ ${Scratch.translate("Sharps")}` },
-              { value: "flats", text: `♭ ${Scratch.translate("Flats")}` },
+              {
+                value: "sharps",
+                text: `♯ ${Scratch.translate("Sharps")}`,
+              },
+              {
+                value: "flats",
+                text: `♭ ${Scratch.translate("Flats")}`,
+              },
             ],
           },
           NOTE_NAMES: {
@@ -1849,7 +1900,10 @@
           CHANNELS: {
             acceptReporters: true,
             items: [
-              { value: "0", text: Scratch.translate("any channel") },
+              {
+                value: "0",
+                text: Scratch.translate("any channel"),
+              },
               ..."0"
                 .repeat(15)
                 .split("")
@@ -1869,9 +1923,18 @@
           DEVICE_PROPS: {
             acceptReporters: true,
             items: [
-              { value: "id", text: Scratch.translate("Id") },
-              { value: "name", text: Scratch.translate("Name") },
-              { value: "state", text: Scratch.translate("State") },
+              {
+                value: "id",
+                text: Scratch.translate("Id"),
+              },
+              {
+                value: "name",
+                text: Scratch.translate("Name"),
+              },
+              {
+                value: "state",
+                text: Scratch.translate("State"),
+              },
               {
                 value: "manufacturer",
                 text: Scratch.translate("Manufacturer"),
@@ -1904,20 +1967,23 @@
       }
     }
     async initialize({ sysex = false, FORCE = false } = {}, util) {
-      const force = Cast.toBoolean(FORCE);
+      const force = Scratch.Cast.toBoolean(FORCE);
       await this.midi.initialize({ sysex, force });
     }
     /**
      * Checks if input value is whitespace or '*' or 'any'.
      * @param {unknown} val
-     * @returns {val is typeof ANY_TYPE}
+     * @returns {val is "ANY"}
      */
     _isAnyArg(val) {
-      return val === ANY_TYPE || /^(\*|any|\s*)$/i.test(Cast.toString(val));
+      return (
+        val === "ANY" || /^(\*|any|\s*)$/i.test(Scratch.Cast.toString(val))
+      );
+    }
     }
     numDevices({ DEVICE_TYPE }) {
       this._ensureInitialize();
-      const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
+      const deviceType = Scratch.Cast.toString(DEVICE_TYPE).toLowerCase();
       const deviceList =
         deviceType === "output" ? this.midi.outputs : this.midi.inputs;
 
@@ -1928,14 +1994,14 @@
       return this.midi.outputs.length;
     }
     getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
-      const deviceType = Cast.toString(DEVICE_TYPE).toLowerCase();
+      const deviceType = Scratch.Cast.toString(DEVICE_TYPE).toLowerCase();
       const deviceList =
         deviceType === "input" ? this.midi.inputs : this.midi.outputs;
-      const index = Cast.toListIndex(INDEX, deviceList.length, false);
+      const index = Scratch.Cast.toListIndex(INDEX, deviceList.length, false);
       const device =
         typeof index === "number" ? deviceList[index - 1] : undefined;
       if (!device) return "";
-      const prop = Cast.toString(DEVICE_PROP);
+      const prop = Scratch.Cast.toString(DEVICE_PROP);
       return device[prop] ?? "";
     }
     inputDevicesMenu() {
@@ -1943,7 +2009,7 @@
         text: d.name || d.id,
         value: d.id,
       }));
-      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(
+      return [{ text: Scratch.translate("any"), value: "ANY" }].concat(
         inputList
       );
     }
@@ -1952,7 +2018,7 @@
         text: d.name || d.id,
         value: d.id,
       }));
-      return [{ text: Scratch.translate("any"), value: ANY_TYPE }].concat(
+      return [{ text: Scratch.translate("any"), value: "ANY" }].concat(
         outputList
       );
     }
@@ -1963,9 +2029,11 @@
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
         ? ["noteOn", "noteOff"]
-        : [normalizeType(Cast.toString(PRESS))];
+        : [normalizeType(Scratch.Cast.toString(PRESS))];
 
-      const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
+      const pitch = this._isAnyArg(NOTE)
+        ? undefined
+        : Scratch.Cast.toNumber(NOTE);
       const last = this.recorder.getLast();
 
       // filter if only note on or note off
@@ -1984,7 +2052,7 @@
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
         ? ["noteOn", "noteOff"]
-        : [normalizeType(Cast.toString(PRESS))];
+        : [normalizeType(Scratch.Cast.toString(PRESS))];
 
       const last = this.recorder.getLast();
       // filter if only note on or note off
@@ -1997,7 +2065,9 @@
     }
     whenMidiEvent({ TYPE }, util) {
       const isAny = this._isAnyArg(TYPE);
-      const type = isAny ? undefined : normalizeType(Cast.toString(TYPE));
+      const type = isAny
+        ? undefined
+        : normalizeType(Scratch.Cast.toString(TYPE));
       const last = this.recorder.getLast();
       if (last && (isAny || last.type === type)) {
         setThreadMidiValue(util.thread, last);
@@ -2006,8 +2076,8 @@
       return false;
     }
     playNoteForBeats({ NOTE, BEATS }, util) {
-      let text = Cast.toString(NOTE);
-      const beats = Cast.toString(BEATS);
+      let text = Scratch.Cast.toString(NOTE);
+      const beats = Scratch.Cast.toString(BEATS);
 
       // just append to text and let stringToMidi handle
       if (beats) {
@@ -2019,7 +2089,7 @@
       this.midi.sendOutputEvent(event);
     }
     sendOutputEvent({ EVENT, DEVICE }, util) {
-      const text = Cast.toString(EVENT);
+      const text = Scratch.Cast.toString(EVENT);
       const event = stringToMidi(text);
 
       const deviceId = Cast.toString(DEVICE);
@@ -2035,7 +2105,7 @@
       this.midi.panic();
     }
     getEventProp({ EVENT, PROP }, util) {
-      const propName = Cast.toString(PROP);
+      const propName = Scratch.Cast.toString(PROP);
       const { key = "value" } = eventProps[propName] ?? {};
       if (!EVENT) return "";
       const last = getThreadMidiValue(util.thread);
@@ -2050,8 +2120,10 @@
       return last ? midiToString(last) : "";
     }
     isNoteActive({ NOTE, CHANNEL }, util) {
-      const pitch = this._isAnyArg(NOTE) ? undefined : Cast.toNumber(NOTE);
-      const channel = Cast.toNumber(CHANNEL) || undefined;
+      const pitch = this._isAnyArg(NOTE)
+        ? undefined
+        : Scratch.Cast.toNumber(NOTE);
+      const channel = Scratch.Cast.toNumber(CHANNEL) || undefined;
       if (pitch == undefined) {
         const notes = this.recorder.getActiveNotes(channel);
         setThreadActiveNotes(util.thread, { channel, notes });
@@ -2066,57 +2138,59 @@
       return !!note;
     }
     isEventOfType({ TYPE }, util) {
-      const type = this._isAnyArg(TYPE) ? undefined : Cast.toString(TYPE);
+      const type = this._isAnyArg(TYPE)
+        ? undefined
+        : Scratch.Cast.toString(TYPE);
       let last = getThreadMidiValue(util.thread);
       last || (last = this.recorder.getLast());
       return last?.type === type;
     }
     noteForName({ NOTE }) {
       if (typeof NOTE === "number" || /^\d+$/.test(NOTE)) {
-        return Cast.toNumber(NOTE);
+        return Scratch.Cast.toNumber(NOTE);
       }
-      const name = Cast.toString(NOTE);
+      const name = Scratch.Cast.toString(NOTE);
       return noteNameToMidiPitch(name) || 0;
     }
     nameForNote({ NOTE, ACCIDENTAL }, util) {
-      const useFlats = Cast.toString(ACCIDENTAL).toLowerCase() === "flats";
-      let val = Cast.toNumber(NOTE);
+      const useFlats =
+        Scratch.Cast.toString(ACCIDENTAL).toLowerCase() === "flats";
+      let val = Scratch.Cast.toNumber(NOTE);
       if (!val && /^[a-g]/i.test(`${NOTE}`)) {
-        val = noteNameToMidiPitch(Cast.toString(NOTE)) || 0;
+        val = noteNameToMidiPitch(Scratch.Cast.toString(NOTE)) || 0;
       }
       return midiPitchToNoteName(val, { useFlats });
     }
     makeOutputNote({ NOTE, BEATS, VELOCITY, CHANNEL, DEVICE }) {
-      let dur =
+      let beats =
         typeof BEATS === "string" && BEATS.includes("/")
           ? parseFraction(BEATS)
-          : Cast.toNumber(BEATS);
-      // sanity check - don't let a note be more than 1 minute
-      // if anyone ever needs a longer note then they should manually write event string
-      dur = Math.max(0, Math.min(dur, 60));
+          : Scratch.Cast.toNumber(BEATS);
+      /** sanity check - clamp beats as per scratch music extension limits
+       * @see {@link https://github.com/TurboWarp/scratch-vm/blob/develop/src/extensions/scratch3_music/index.js#L706}
+       */
+      beats = Math.max(0, Math.min(beats, 100));
       // convert from percent to midi value
-      let velocity = (Cast.toNumber(VELOCITY) / 100) * 127;
+      let velocity = (Scratch.Cast.toNumber(VELOCITY) / 100) * 127;
       // clamp value
       // NOTE - if 0 velocity then nothing will happen because treated as note off
       velocity = Math.max(0, Math.min(velocity, 127));
-      // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
-      const deviceId = Cast.toString(DEVICE);
-      const device = this.midi.outputs.findIndex((d) => d.id === deviceId);
+      const device = this._getDeviceIndex(DEVICE, "output");
       /** @type {MidiEvent} */
       const event = {
         type: "noteOn",
         pitch: this.noteForName({ NOTE }),
         velocity,
-        channel: Cast.toNumber(CHANNEL) || undefined,
-        device: device === -1 ? undefined : device,
-        dur,
+        channel: Scratch.Cast.toNumber(CHANNEL) || undefined,
+        device,
+        beats,
       };
       return midiToString(event);
     }
     makeOutputEvent({ TYPE, VALUE1, VALUE2, CHANNEL, DEVICE }) {
       /** @type {EventType} */
       // @ts-ignore
-      let type = Cast.toString(TYPE);
+      let type = Scratch.Cast.toString(TYPE);
       // default is CC - is that right?
       // @ts-ignore
       if (this._isAnyArg(type)) type = "cc";
@@ -2131,12 +2205,12 @@
       }
 
       // clamp values
-      let value1 = Cast.toNumber(VALUE1);
+      let value1 = Scratch.Cast.toNumber(VALUE1);
       // pitchbend can be a bigger number
       const maxValue1 = spec?.highResParam ? 16384 : 127;
       value1 = Math.max(0, Math.min(value1, maxValue1));
 
-      let value2 = Cast.toNumber(VALUE2);
+      let value2 = Scratch.Cast.toNumber(VALUE2);
       value2 = Math.max(0, Math.min(value2, 127));
 
       // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
@@ -2148,8 +2222,8 @@
         type,
         value1,
         value2,
-        channel: Cast.toNumber(CHANNEL) || undefined,
         device: device === -1 ? undefined : device,
+        channel: Scratch.Cast.toNumber(CHANNEL) || undefined,
         ...(spec?.param1 && { [spec.param1]: value1 }),
         ...(spec?.param2 && { [spec.param2]: value2 }),
         ...(spec?.highResParam && parseHighResValue(value1, value2)),
@@ -2157,9 +2231,9 @@
       return midiToString(event);
     }
     normalizeMidiVal({ VALUE, MIN, MAX }) {
-      const min = Cast.toNumber(MIN);
-      const max = Cast.toNumber(MAX);
-      const val = Cast.toNumber(VALUE) / 127;
+      const min = Scratch.Cast.toNumber(MIN);
+      const max = Scratch.Cast.toNumber(MAX);
+      const val = Scratch.Cast.toNumber(VALUE) / 127;
       return val * (max - min) + min;
     }
     getMidiStartTime() {
@@ -2172,12 +2246,12 @@
       this.recorder.clear();
     }
     setMidiEventList({ LIST, TIME }, util) {
-      const duration = Cast.toNumber(TIME) || 5;
+      const duration = Scratch.Cast.toNumber(TIME) || 5;
       const start = this.recorder._now() - duration;
       const events = this.recorder.getRange(start);
       if (LIST) {
         this._upsertList(
-          Cast.toString(LIST),
+          Scratch.Cast.toString(LIST),
           events.map((evt) => evt._str),
           util.target
         );
@@ -2194,7 +2268,7 @@
         active = { notes: this.recorder.getActiveNotes() };
         setThreadActiveNotes(util.thread, active);
       }
-      let index = Cast.toListIndex(INDEX, active.length, true);
+      let index = Scratch.Cast.toListIndex(INDEX, active.length, true);
       if (!active.notes || index === "INVALID") {
         return "";
       }
@@ -2213,7 +2287,7 @@
       setThreadActiveNotes(util.thread, { notes });
       if (LIST) {
         this._upsertList(
-          Cast.toString(LIST),
+          Scratch.Cast.toString(LIST),
           notes.map((note) => note._str),
           util.target
         );
@@ -2237,7 +2311,7 @@
       return active.notes.length;
     }
     eventToJSON({ EVENT }, util) {
-      const raw = Cast.toString(EVENT);
+      const raw = Scratch.Cast.toString(EVENT);
       // NOTE will be null if could not parse
       const event = stringToMidi(raw);
 
@@ -2250,7 +2324,7 @@
       return JSON.stringify(event);
     }
     jsonToEvent({ TEXT }, util) {
-      const raw = Cast.toString(TEXT);
+      const raw = Scratch.Cast.toString(TEXT);
       let event = null;
       try {
         event = {

From ef717aa2801c49fa66c17e3fbda3546aadd781f2 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 13 Mar 2025 00:43:09 -0400
Subject: [PATCH 48/61] ensure device index starts at 1

---
 extensions/midi/midi.js | 51 ++++++++++++++++++++++++++---------------
 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 629ae8fde7..539df3e45d 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -800,13 +800,13 @@
         if (!port) return;
         const { type, id, name } = port;
         const deviceList = type === "input" ? this.inputs : this.outputs;
-        const index = deviceList.findIndex((dev) => dev.id === id);
-        if (index === -1) {
+        const rawIndex = deviceList.findIndex((dev) => dev.id === id);
+        if (rawIndex === -1) {
           this.refreshDevices();
           return;
         }
         this._emit("device:status", {
-          index,
+          index: rawIndex + 1,
           id,
           name,
           type,
@@ -816,7 +816,7 @@
       this._onInputEvent = (event) => {
         const { target: device, data, timeStamp } = event;
         if (!data) return;
-        const deviceIndex = this.inputs.indexOf(device);
+        const rawIndex = this.inputs.indexOf(device);
         const midiEvent = rawMessageToMidi(data);
         if (!midiEvent) {
           console.warn("Unable to parse message", data);
@@ -824,8 +824,8 @@
           return;
         } else {
           midiEvent.time = timeStamp / 1000;
-          if (deviceIndex !== -1) {
-            midiEvent.device = deviceIndex;
+          if (rawIndex !== -1) {
+            midiEvent.device = rawIndex + 1;
           }
           midiEvent._str = midiToString(midiEvent, { noMinify: true });
           this._emit("midi", midiEvent);
@@ -915,11 +915,14 @@
         return false;
       }
 
-      const device =
-        (data.device != undefined && this.outputs[data.device]) ||
-        this.defaultOutput;
+      let device;
+      // passed in index starts at 1
+      if (data.device != undefined && data.device > 0) {
+        device = this.outputs[data.device - 1];
+      }
+      device ||= this.defaultOutput;
       if (!device) {
-        // no output. Should this throw error?
+        // no output device so do nothing
         return false;
       }
       // ensure 0 velocity is interpreted as noteOff
@@ -1980,6 +1983,22 @@
         val === "ANY" || /^(\*|any|\s*)$/i.test(Scratch.Cast.toString(val))
       );
     }
+    _getDeviceIndex(DEVICE, deviceType) {
+      const deviceId = Scratch.Cast.toString(DEVICE);
+      const deviceList =
+        deviceType === "output" ? this.midi.outputs : this.midi.inputs;
+
+      const rawIndex = this.midi.outputs.findIndex((d) => d.id === deviceId);
+      if (rawIndex !== -1) {
+        // arrays start at 1
+        return rawIndex + 1;
+      }
+      // check if index passed in and use directly
+      const index = Scratch.Cast.toNumber(deviceId);
+      if (index >= 1 && index <= deviceList.length) {
+        return index;
+      }
+      return undefined;
     }
     numDevices({ DEVICE_TYPE }) {
       this._ensureInitialize();
@@ -2092,11 +2111,8 @@
       const text = Scratch.Cast.toString(EVENT);
       const event = stringToMidi(text);
 
-      const deviceId = Cast.toString(DEVICE);
-      if (deviceId && event.device == undefined) {
-        const device =
-          deviceId && this.midi.outputs.findIndex((d) => d.id === deviceId);
-        event.device = device === -1 ? undefined : device;
+      if (DEVICE) {
+        event.device = this._getDeviceIndex(DEVICE, "output");
       }
 
       this.midi.sendOutputEvent(event);
@@ -2214,16 +2230,15 @@
       value2 = Math.max(0, Math.min(value2, 127));
 
       // REVIEW - should OUTPUT_DEVICES be changed to output device index instead of id?
-      const deviceId = Cast.toString(DEVICE);
-      const device = this.midi.outputs.findIndex((d) => d.id === deviceId);
+      const device = this._getDeviceIndex(DEVICE, "output");
       // FUTURE this may make sense to get moved out to helper alongside rawMessageToMidi
       /** @type {MidiEvent} */
       const event = {
         type,
         value1,
         value2,
-        device: device === -1 ? undefined : device,
         channel: Scratch.Cast.toNumber(CHANNEL) || undefined,
+        device,
         ...(spec?.param1 && { [spec.param1]: value1 }),
         ...(spec?.param2 && { [spec.param2]: value2 }),
         ...(spec?.highResParam && parseHighResValue(value1, value2)),

From 24d98e0a38d0546e9bae7ad0c6e5dbba4e12196d Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 17 Mar 2025 23:40:05 -0400
Subject: [PATCH 49/61] Merge in MIDI Parser extension by CHCAT1320

---
 extensions/midi/midi.js | 93 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 92 insertions(+), 1 deletion(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 539df3e45d..72c52d9ec9 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -1,6 +1,8 @@
 // Name: MIDI
 // ID: extmidi
 // Description: An extension to use the WebMidi API for midi input/output.
+// By: lselden
+// By: CHCAT1320
 // License: MPL-2.0
 
 (function (Scratch) {
@@ -12,6 +14,77 @@
 
   const EXT_ID = "extmidi";
 
+  //#region midi files
+  const Midi = (function initMidi() {
+    const exports = {};
+    const module = { exports };
+
+    /* eslint-disable */
+    // prettier-ignore
+
+    //  tonejs/midi
+    // TODO FIXME - include full link to original code + licensing here - see newgroundsIO.js for one such example
+    !function(t,e){if("object"==typeof exports&&"object"==typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var r=e();for(var n in r)("object"==typeof exports?exports:t)[n]=r[n]}}("undefined"!=typeof self?self:this,(function(){return(()=>{var t={507:(t,e,r)=>{"use strict";function n(t){var e=[];return i(t,e),e}function i(t,e){for(var r=0;r<t.length;r++){var n=t[r];Array.isArray(n)?i(n,e):e.push(n)}}r.r(e),r.d(e,{flatten:()=>n})},289:(t,e,r)=>{e.parseMidi=r(666),e.writeMidi=r(865)},666:t=>{function e(t){for(var e,n=new r(t),i=[];!n.eof();){var a=o();i.push(a)}return i;function o(){var t={};t.deltaTime=n.readVarInt();var r=n.readUInt8();if(240==(240&r)){if(255!==r){if(240==r)return t.type="sysEx",a=n.readVarInt(),t.data=n.readBytes(a),t;if(247==r)return t.type="endSysEx",a=n.readVarInt(),t.data=n.readBytes(a),t;throw"Unrecognised MIDI event type byte: "+r}t.meta=!0;var i=n.readUInt8(),a=n.readVarInt();switch(i){case 0:if(t.type="sequenceNumber",2!==a)throw"Expected length for sequenceNumber event is 2, got "+a;return t.number=n.readUInt16(),t;case 1:return t.type="text",t.text=n.readString(a),t;case 2:return t.type="copyrightNotice",t.text=n.readString(a),t;case 3:return t.type="trackName",t.text=n.readString(a),t;case 4:return t.type="instrumentName",t.text=n.readString(a),t;case 5:return t.type="lyrics",t.text=n.readString(a),t;case 6:return t.type="marker",t.text=n.readString(a),t;case 7:return t.type="cuePoint",t.text=n.readString(a),t;case 32:if(t.type="channelPrefix",1!=a)throw"Expected length for channelPrefix event is 1, got "+a;return t.channel=n.readUInt8(),t;case 33:if(t.type="portPrefix",1!=a)throw"Expected length for portPrefix event is 1, got "+a;return t.port=n.readUInt8(),t;case 47:if(t.type="endOfTrack",0!=a)throw"Expected length for endOfTrack event is 0, got "+a;return t;case 81:if(t.type="setTempo",3!=a)throw"Expected length for setTempo event is 3, got "+a;return t.microsecondsPerBeat=n.readUInt24(),t;case 84:if(t.type="smpteOffset",5!=a)throw"Expected length for smpteOffset event is 5, got "+a;var o=n.readUInt8();return t.frameRate={0:24,32:25,64:29,96:30}[96&o],t.hour=31&o,t.min=n.readUInt8(),t.sec=n.readUInt8(),t.frame=n.readUInt8(),t.subFrame=n.readUInt8(),t;case 88:if(t.type="timeSignature",4!=a)throw"Expected length for timeSignature event is 4, got "+a;return t.numerator=n.readUInt8(),t.denominator=1<<n.readUInt8(),t.metronome=n.readUInt8(),t.thirtyseconds=n.readUInt8(),t;case 89:if(t.type="keySignature",2!=a)throw"Expected length for keySignature event is 2, got "+a;return t.key=n.readInt8(),t.scale=n.readUInt8(),t;case 127:return t.type="sequencerSpecific",t.data=n.readBytes(a),t;default:return t.type="unknownMeta",t.data=n.readBytes(a),t.metatypeByte=i,t}}else{var s;if(0==(128&r)){if(null===e)throw"Running status byte encountered before status byte";s=r,r=e,t.running=!0}else s=n.readUInt8(),e=r;var c=r>>4;switch(t.channel=15&r,c){case 8:return t.type="noteOff",t.noteNumber=s,t.velocity=n.readUInt8(),t;case 9:var u=n.readUInt8();return t.type=0===u?"noteOff":"noteOn",t.noteNumber=s,t.velocity=u,0===u&&(t.byte9=!0),t;case 10:return t.type="noteAftertouch",t.noteNumber=s,t.amount=n.readUInt8(),t;case 11:return t.type="controller",t.controllerType=s,t.value=n.readUInt8(),t;case 12:return t.type="programChange",t.programNumber=s,t;case 13:return t.type="channelAftertouch",t.amount=s,t;case 14:return t.type="pitchBend",t.value=s+(n.readUInt8()<<7)-8192,t;default:throw"Unrecognised MIDI event type: "+c}}}}function r(t){this.buffer=t,this.bufferLen=this.buffer.length,this.pos=0}r.prototype.eof=function(){return this.pos>=this.bufferLen},r.prototype.readUInt8=function(){var t=this.buffer[this.pos];return this.pos+=1,t},r.prototype.readInt8=function(){var t=this.readUInt8();return 128&t?t-256:t},r.prototype.readUInt16=function(){return(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readInt16=function(){var t=this.readUInt16();return 32768&t?t-65536:t},r.prototype.readUInt24=function(){return(this.readUInt8()<<16)+(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readInt24=function(){var t=this.readUInt24();return 8388608&t?t-16777216:t},r.prototype.readUInt32=function(){return(this.readUInt8()<<24)+(this.readUInt8()<<16)+(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readBytes=function(t){var e=this.buffer.slice(this.pos,this.pos+t);return this.pos+=t,e},r.prototype.readString=function(t){var e=this.readBytes(t);return String.fromCharCode.apply(null,e)},r.prototype.readVarInt=function(){for(var t=0;!this.eof();){var e=this.readUInt8();if(!(128&e))return t+e;t+=127&e,t<<=7}return t},r.prototype.readChunk=function(){var t=this.readString(4),e=this.readUInt32();return{id:t,length:e,data:this.readBytes(e)}},t.exports=function(t){var n=new r(t),i=n.readChunk();if("MThd"!=i.id)throw"Bad MIDI file.  Expected 'MHdr', got: '"+i.id+"'";for(var a=function(t){var e=new r(t),n={format:e.readUInt16(),numTracks:e.readUInt16()},i=e.readUInt16();return 32768&i?(n.framesPerSecond=256-(i>>8),n.ticksPerFrame=255&i):n.ticksPerBeat=i,n}(i.data),o=[],s=0;!n.eof()&&s<a.numTracks;s++){var c=n.readChunk();if("MTrk"!=c.id)throw"Bad MIDI file.  Expected 'MTrk', got: '"+c.id+"'";var u=e(c.data);o.push(u)}return{header:a,tracks:o}}},865:t=>{function e(t,e,i){var a,o=new n,s=e.length,c=null;for(a=0;a<s;a++)!1!==i.running&&(i.running||e[a].running)||(c=null),c=r(o,e[a],c,i.useByte9ForNoteOff);t.writeChunk("MTrk",o.buffer)}function r(t,e,r,n){var i=e.type,a=e.deltaTime,o=e.text||"",s=e.data||[],c=null;switch(t.writeVarInt(a),i){case"sequenceNumber":t.writeUInt8(255),t.writeUInt8(0),t.writeVarInt(2),t.writeUInt16(e.number);break;case"text":t.writeUInt8(255),t.writeUInt8(1),t.writeVarInt(o.length),t.writeString(o);break;case"copyrightNotice":t.writeUInt8(255),t.writeUInt8(2),t.writeVarInt(o.length),t.writeString(o);break;case"trackName":t.writeUInt8(255),t.writeUInt8(3),t.writeVarInt(o.length),t.writeString(o);break;case"instrumentName":t.writeUInt8(255),t.writeUInt8(4),t.writeVarInt(o.length),t.writeString(o);break;case"lyrics":t.writeUInt8(255),t.writeUInt8(5),t.writeVarInt(o.length),t.writeString(o);break;case"marker":t.writeUInt8(255),t.writeUInt8(6),t.writeVarInt(o.length),t.writeString(o);break;case"cuePoint":t.writeUInt8(255),t.writeUInt8(7),t.writeVarInt(o.length),t.writeString(o);break;case"channelPrefix":t.writeUInt8(255),t.writeUInt8(32),t.writeVarInt(1),t.writeUInt8(e.channel);break;case"portPrefix":t.writeUInt8(255),t.writeUInt8(33),t.writeVarInt(1),t.writeUInt8(e.port);break;case"endOfTrack":t.writeUInt8(255),t.writeUInt8(47),t.writeVarInt(0);break;case"setTempo":t.writeUInt8(255),t.writeUInt8(81),t.writeVarInt(3),t.writeUInt24(e.microsecondsPerBeat);break;case"smpteOffset":t.writeUInt8(255),t.writeUInt8(84),t.writeVarInt(5);var u=31&e.hour|{24:0,25:32,29:64,30:96}[e.frameRate];t.writeUInt8(u),t.writeUInt8(e.min),t.writeUInt8(e.sec),t.writeUInt8(e.frame),t.writeUInt8(e.subFrame);break;case"timeSignature":t.writeUInt8(255),t.writeUInt8(88),t.writeVarInt(4),t.writeUInt8(e.numerator);var h=255&Math.floor(Math.log(e.denominator)/Math.LN2);t.writeUInt8(h),t.writeUInt8(e.metronome),t.writeUInt8(e.thirtyseconds||8);break;case"keySignature":t.writeUInt8(255),t.writeUInt8(89),t.writeVarInt(2),t.writeInt8(e.key),t.writeUInt8(e.scale);break;case"sequencerSpecific":t.writeUInt8(255),t.writeUInt8(127),t.writeVarInt(s.length),t.writeBytes(s);break;case"unknownMeta":null!=e.metatypeByte&&(t.writeUInt8(255),t.writeUInt8(e.metatypeByte),t.writeVarInt(s.length),t.writeBytes(s));break;case"sysEx":t.writeUInt8(240),t.writeVarInt(s.length),t.writeBytes(s);break;case"endSysEx":t.writeUInt8(247),t.writeVarInt(s.length),t.writeBytes(s);break;case"noteOff":(c=(!1!==n&&e.byte9||n&&0==e.velocity?144:128)|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.velocity);break;case"noteOn":(c=144|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.velocity);break;case"noteAftertouch":(c=160|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.amount);break;case"controller":(c=176|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.controllerType),t.writeUInt8(e.value);break;case"programChange":(c=192|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.programNumber);break;case"channelAftertouch":(c=208|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.amount);break;case"pitchBend":(c=224|e.channel)!==r&&t.writeUInt8(c);var f=8192+e.value,p=127&f,l=f>>7&127;t.writeUInt8(p),t.writeUInt8(l);break;default:throw"Unrecognized event type: "+i}return c}function n(){this.buffer=[]}n.prototype.writeUInt8=function(t){this.buffer.push(255&t)},n.prototype.writeInt8=n.prototype.writeUInt8,n.prototype.writeUInt16=function(t){var e=t>>8&255,r=255&t;this.writeUInt8(e),this.writeUInt8(r)},n.prototype.writeInt16=n.prototype.writeUInt16,n.prototype.writeUInt24=function(t){var e=t>>16&255,r=t>>8&255,n=255&t;this.writeUInt8(e),this.writeUInt8(r),this.writeUInt8(n)},n.prototype.writeInt24=n.prototype.writeUInt24,n.prototype.writeUInt32=function(t){var e=t>>24&255,r=t>>16&255,n=t>>8&255,i=255&t;this.writeUInt8(e),this.writeUInt8(r),this.writeUInt8(n),this.writeUInt8(i)},n.prototype.writeInt32=n.prototype.writeUInt32,n.prototype.writeBytes=function(t){this.buffer=this.buffer.concat(Array.prototype.slice.call(t,0))},n.prototype.writeString=function(t){var e,r=t.length,n=[];for(e=0;e<r;e++)n.push(t.codePointAt(e));this.writeBytes(n)},n.prototype.writeVarInt=function(t){if(t<0)throw"Cannot write negative variable-length integer";if(t<=127)this.writeUInt8(t);else{var e=t,r=[];for(r.push(127&e),e>>=7;e;){var n=127&e|128;r.push(n),e>>=7}this.writeBytes(r.reverse())}},n.prototype.writeChunk=function(t,e){this.writeString(t),this.writeUInt32(e.length),this.writeBytes(e)},t.exports=function(t,r){if("object"!=typeof t)throw"Invalid MIDI data";r=r||{};var i,a=t.header||{},o=t.tracks||[],s=o.length,c=new n;for(function(t,e,r){var i=null==e.format?1:e.format,a=128;e.timeDivision?a=e.timeDivision:e.ticksPerFrame&&e.framesPerSecond?a=-(255&e.framesPerSecond)<<8|255&e.ticksPerFrame:e.ticksPerBeat&&(a=32767&e.ticksPerBeat);var o=new n;o.writeUInt16(i),o.writeUInt16(r),o.writeUInt16(a),t.writeChunk("MThd",o.buffer)}(c,a,s),i=0;i<s;i++)e(c,o[i],r);return c.buffer}},805:(t,e)=>{"use strict";function r(t,e,r){void 0===r&&(r="ticks");var n=0,i=t.length,a=i;if(i>0&&t[i-1][r]<=e)return i-1;for(;n<a;){var o=Math.floor(n+(a-n)/2),s=t[o],c=t[o+1];if(s[r]===e){for(var u=o;u<t.length;u++)t[u][r]===e&&(o=u);return o}if(s[r]<e&&c[r]>e)return o;s[r]>e?a=o:s[r]<e&&(n=o+1)}return-1}Object.defineProperty(e,"__esModule",{value:!0}),e.insert=e.search=void 0,e.search=r,e.insert=function(t,e,n){if(void 0===n&&(n="ticks"),t.length){var i=r(t,e[n],n);t.splice(i+1,0,e)}else t.push(e)}},543:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.ControlChange=e.controlChangeIds=e.controlChangeNames=void 0,e.controlChangeNames={1:"modulationWheel",2:"breath",4:"footController",5:"portamentoTime",7:"volume",8:"balance",10:"pan",64:"sustain",65:"portamentoTime",66:"sostenuto",67:"softPedal",68:"legatoFootswitch",84:"portamentoControl"},e.controlChangeIds=Object.keys(e.controlChangeNames).reduce((function(t,r){return t[e.controlChangeNames[r]]=r,t}),{});var r=new WeakMap,n=new WeakMap,i=function(){function t(t,e){r.set(this,e),n.set(this,t.controllerType),this.ticks=t.absoluteTime,this.value=t.value}return Object.defineProperty(t.prototype,"number",{get:function(){return n.get(this)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"name",{get:function(){return e.controlChangeNames[this.number]?e.controlChangeNames[this.number]:null},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"time",{get:function(){return r.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=r.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{number:this.number,ticks:this.ticks,time:this.time,value:this.value}},t}();e.ControlChange=i},906:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.createControlChanges=void 0;var n=r(543);e.createControlChanges=function(){return new Proxy({},{get:function(t,e){return t[e]?t[e]:n.controlChangeIds.hasOwnProperty(e)?t[n.controlChangeIds[e]]:void 0},set:function(t,e,r){return n.controlChangeIds.hasOwnProperty(e)?t[n.controlChangeIds[e]]=r:t[e]=r,!0}})}},54:function(t,e,r){"use strict";var n=this&&this.__spreadArray||function(t,e,r){if(r||2===arguments.length)for(var n,i=0,a=e.length;i<a;i++)!n&&i in e||(n||(n=Array.prototype.slice.call(e,0,i)),n[i]=e[i]);return t.concat(n||Array.prototype.slice.call(e))};Object.defineProperty(e,"__esModule",{value:!0}),e.encode=void 0;var i=r(289),a=r(535),o=r(507);function s(t,e){return{absoluteTime:t.ticks,channel:e,controllerType:t.number,deltaTime:0,type:"controller",value:Math.floor(127*t.value)}}function c(t){return{absoluteTime:0,channel:t.channel,deltaTime:0,programNumber:t.instrument.number,type:"programChange"}}e.encode=function(t){var e={header:{format:1,numTracks:t.tracks.length+1,ticksPerBeat:t.header.ppq},tracks:n([n(n(n(n([{absoluteTime:0,deltaTime:0,meta:!0,text:t.header.name,type:"trackName"}],t.header.keySignatures.map((function(t){return function(t){var e=a.keySignatureKeys.indexOf(t.key);return{absoluteTime:t.ticks,deltaTime:0,key:e+7,meta:!0,scale:"major"===t.scale?0:1,type:"keySignature"}}(t)})),!0),t.header.meta.map((function(t){return{absoluteTime:(e=t).ticks,deltaTime:0,meta:!0,text:e.text,type:e.type};var e})),!0),t.header.tempos.map((function(t){return function(t){return{absoluteTime:t.ticks,deltaTime:0,meta:!0,microsecondsPerBeat:Math.floor(6e7/t.bpm),type:"setTempo"}}(t)})),!0),t.header.timeSignatures.map((function(t){return function(t){return{absoluteTime:t.ticks,deltaTime:0,denominator:t.timeSignature[1],meta:!0,metronome:24,numerator:t.timeSignature[0],thirtyseconds:8,type:"timeSignature"}}(t)})),!0)],t.tracks.map((function(t){return n(n(n([(e=t.name,{absoluteTime:0,deltaTime:0,meta:!0,text:e,type:"trackName"}),c(t)],function(t){return(0,o.flatten)(t.notes.map((function(e){return function(t,e){return[{absoluteTime:t.ticks,channel:e,deltaTime:0,noteNumber:t.midi,type:"noteOn",velocity:Math.floor(127*t.velocity)},{absoluteTime:t.ticks+t.durationTicks,channel:e,deltaTime:0,noteNumber:t.midi,type:"noteOff",velocity:Math.floor(127*t.noteOffVelocity)}]}(e,t.channel)})))}(t),!0),function(t){for(var e=[],r=0;r<127;r++)t.controlChanges.hasOwnProperty(r)&&t.controlChanges[r].forEach((function(r){e.push(s(r,t.channel))}));return e}(t),!0),function(t){var e=[];return t.pitchBends.forEach((function(r){e.push(function(t,e){return{absoluteTime:t.ticks,channel:e,deltaTime:0,type:"pitchBend",value:t.value}}(r,t.channel))})),e}(t),!0);var e})),!0)};return e.tracks=e.tracks.map((function(t){t=t.sort((function(t,e){return t.absoluteTime-e.absoluteTime}));var e=0;return t.forEach((function(t){t.deltaTime=t.absoluteTime-e,e=t.absoluteTime,delete t.absoluteTime})),t.push({deltaTime:0,meta:!0,type:"endOfTrack"}),t})),new Uint8Array((0,i.writeMidi)(e))}},535:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Header=e.keySignatureKeys=void 0;var n=r(805),i=new WeakMap;e.keySignatureKeys=["Cb","Gb","Db","Ab","Eb","Bb","F","C","G","D","A","E","B","F#","C#"];var a=function(){function t(t){var r=this;if(this.tempos=[],this.timeSignatures=[],this.keySignatures=[],this.meta=[],this.name="",i.set(this,480),t){i.set(this,t.header.ticksPerBeat),t.tracks.forEach((function(t){t.forEach((function(t){t.meta&&("timeSignature"===t.type?r.timeSignatures.push({ticks:t.absoluteTime,timeSignature:[t.numerator,t.denominator]}):"setTempo"===t.type?r.tempos.push({bpm:6e7/t.microsecondsPerBeat,ticks:t.absoluteTime}):"keySignature"===t.type&&r.keySignatures.push({key:e.keySignatureKeys[t.key+7],scale:0===t.scale?"major":"minor",ticks:t.absoluteTime}))}))}));var n=0;t.tracks[0].forEach((function(t){n+=t.deltaTime,t.meta&&("trackName"===t.type?r.name=t.text:"text"!==t.type&&"cuePoint"!==t.type&&"marker"!==t.type&&"lyrics"!==t.type||r.meta.push({text:t.text,ticks:n,type:t.type}))})),this.update()}}return t.prototype.update=function(){var t=this,e=0,r=0;this.tempos.sort((function(t,e){return t.ticks-e.ticks})),this.tempos.forEach((function(n,i){var a=i>0?t.tempos[i-1].bpm:t.tempos[0].bpm,o=n.ticks/t.ppq-r,s=60/a*o;n.time=s+e,e=n.time,r+=o})),this.timeSignatures.sort((function(t,e){return t.ticks-e.ticks})),this.timeSignatures.forEach((function(e,r){var n=r>0?t.timeSignatures[r-1]:t.timeSignatures[0],i=(e.ticks-n.ticks)/t.ppq/n.timeSignature[0]/(n.timeSignature[1]/4);n.measures=n.measures||0,e.measures=i+n.measures}))},t.prototype.ticksToSeconds=function(t){var e=(0,n.search)(this.tempos,t);if(-1!==e){var r=this.tempos[e],i=r.time,a=(t-r.ticks)/this.ppq;return i+60/r.bpm*a}return t/this.ppq*.5},t.prototype.ticksToMeasures=function(t){var e=(0,n.search)(this.timeSignatures,t);if(-1!==e){var r=this.timeSignatures[e],i=(t-r.ticks)/this.ppq;return r.measures+i/(r.timeSignature[0]/r.timeSignature[1])/4}return t/this.ppq/4},Object.defineProperty(t.prototype,"ppq",{get:function(){return i.get(this)},enumerable:!1,configurable:!0}),t.prototype.secondsToTicks=function(t){var e=(0,n.search)(this.tempos,t,"time");if(-1!==e){var r=this.tempos[e],i=(t-r.time)/(60/r.bpm);return Math.round(r.ticks+i*this.ppq)}var a=t/.5;return Math.round(a*this.ppq)},t.prototype.toJSON=function(){return{keySignatures:this.keySignatures,meta:this.meta,name:this.name,ppq:this.ppq,tempos:this.tempos.map((function(t){return{bpm:t.bpm,ticks:t.ticks}})),timeSignatures:this.timeSignatures}},t.prototype.fromJSON=function(t){this.name=t.name,this.tempos=t.tempos.map((function(t){return Object.assign({},t)})),this.timeSignatures=t.timeSignatures.map((function(t){return Object.assign({},t)})),this.keySignatures=t.keySignatures.map((function(t){return Object.assign({},t)})),this.meta=t.meta.map((function(t){return Object.assign({},t)})),i.set(this,t.ppq),this.update()},t.prototype.setTempo=function(t){this.tempos=[{bpm:t,ticks:0}],this.update()},t}();e.Header=a},362:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Instrument=void 0;var n=r(438),i=new WeakMap,a=function(){function t(t,e){if(this.number=0,i.set(this,e),this.number=0,t){var r=t.find((function(t){return"programChange"===t.type}));r&&(this.number=r.programNumber)}}return Object.defineProperty(t.prototype,"name",{get:function(){return this.percussion?n.DrumKitByPatchID[this.number]:n.instrumentByPatchID[this.number]},set:function(t){var e=n.instrumentByPatchID.indexOf(t);-1!==e&&(this.number=e)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"family",{get:function(){return this.percussion?"drums":n.InstrumentFamilyByID[Math.floor(this.number/8)]},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"percussion",{get:function(){return 9===i.get(this).channel},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{family:this.family,number:this.number,name:this.name}},t.prototype.fromJSON=function(t){this.number=t.number},t}();e.Instrument=a},438:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.DrumKitByPatchID=e.InstrumentFamilyByID=e.instrumentByPatchID=void 0,e.instrumentByPatchID=["acoustic grand piano","bright acoustic piano","electric grand piano","honky-tonk piano","electric piano 1","electric piano 2","harpsichord","clavi","celesta","glockenspiel","music box","vibraphone","marimba","xylophone","tubular bells","dulcimer","drawbar organ","percussive organ","rock organ","church organ","reed organ","accordion","harmonica","tango accordion","acoustic guitar (nylon)","acoustic guitar (steel)","electric guitar (jazz)","electric guitar (clean)","electric guitar (muted)","overdriven guitar","distortion guitar","guitar harmonics","acoustic bass","electric bass (finger)","electric bass (pick)","fretless bass","slap bass 1","slap bass 2","synth bass 1","synth bass 2","violin","viola","cello","contrabass","tremolo strings","pizzicato strings","orchestral harp","timpani","string ensemble 1","string ensemble 2","synthstrings 1","synthstrings 2","choir aahs","voice oohs","synth voice","orchestra hit","trumpet","trombone","tuba","muted trumpet","french horn","brass section","synthbrass 1","synthbrass 2","soprano sax","alto sax","tenor sax","baritone sax","oboe","english horn","bassoon","clarinet","piccolo","flute","recorder","pan flute","blown bottle","shakuhachi","whistle","ocarina","lead 1 (square)","lead 2 (sawtooth)","lead 3 (calliope)","lead 4 (chiff)","lead 5 (charang)","lead 6 (voice)","lead 7 (fifths)","lead 8 (bass + lead)","pad 1 (new age)","pad 2 (warm)","pad 3 (polysynth)","pad 4 (choir)","pad 5 (bowed)","pad 6 (metallic)","pad 7 (halo)","pad 8 (sweep)","fx 1 (rain)","fx 2 (soundtrack)","fx 3 (crystal)","fx 4 (atmosphere)","fx 5 (brightness)","fx 6 (goblins)","fx 7 (echoes)","fx 8 (sci-fi)","sitar","banjo","shamisen","koto","kalimba","bag pipe","fiddle","shanai","tinkle bell","agogo","steel drums","woodblock","taiko drum","melodic tom","synth drum","reverse cymbal","guitar fret noise","breath noise","seashore","bird tweet","telephone ring","helicopter","applause","gunshot"],e.InstrumentFamilyByID=["piano","chromatic percussion","organ","guitar","bass","strings","ensemble","brass","reed","pipe","synth lead","synth pad","synth effects","world","percussive","sound effects"],e.DrumKitByPatchID={0:"standard kit",8:"room kit",16:"power kit",24:"electronic kit",25:"tr-808 kit",32:"jazz kit",40:"brush kit",48:"orchestra kit",56:"sound fx kit"}},233:function(t,e,r){"use strict";var n=this&&this.__awaiter||function(t,e,r,n){return new(r||(r=Promise))((function(i,a){function o(t){try{c(n.next(t))}catch(t){a(t)}}function s(t){try{c(n.throw(t))}catch(t){a(t)}}function c(t){var e;t.done?i(t.value):(e=t.value,e instanceof r?e:new r((function(t){t(e)}))).then(o,s)}c((n=n.apply(t,e||[])).next())}))},i=this&&this.__generator||function(t,e){var r,n,i,a,o={label:0,sent:function(){if(1&i[0])throw i[1];return i[1]},trys:[],ops:[]};return a={next:s(0),throw:s(1),return:s(2)},"function"==typeof Symbol&&(a[Symbol.iterator]=function(){return this}),a;function s(a){return function(s){return function(a){if(r)throw new TypeError("Generator is already executing.");for(;o;)try{if(r=1,n&&(i=2&a[0]?n.return:a[0]?n.throw||((i=n.return)&&i.call(n),0):n.next)&&!(i=i.call(n,a[1])).done)return i;switch(n=0,i&&(a=[2&a[0],i.value]),a[0]){case 0:case 1:i=a;break;case 4:return o.label++,{value:a[1],done:!1};case 5:o.label++,n=a[1],a=[0];continue;case 7:a=o.ops.pop(),o.trys.pop();continue;default:if(!((i=(i=o.trys).length>0&&i[i.length-1])||6!==a[0]&&2!==a[0])){o=0;continue}if(3===a[0]&&(!i||a[1]>i[0]&&a[1]<i[3])){o.label=a[1];break}if(6===a[0]&&o.label<i[1]){o.label=i[1],i=a;break}if(i&&o.label<i[2]){o.label=i[2],o.ops.push(a);break}i[2]&&o.ops.pop(),o.trys.pop();continue}a=e.call(t,o)}catch(t){a=[6,t],n=0}finally{r=i=0}if(5&a[0])throw a[1];return{value:a[0]?a[1]:void 0,done:!0}}([a,s])}}};Object.defineProperty(e,"__esModule",{value:!0}),e.Header=e.Track=e.Midi=void 0;var a=r(289),o=r(535),s=r(334),c=r(54),u=function(){function t(t){var e=this,r=null;if(t){var n=t instanceof ArrayBuffer?new Uint8Array(t):t;(r=(0,a.parseMidi)(n)).tracks.forEach((function(t){var e=0;t.forEach((function(t){e+=t.deltaTime,t.absoluteTime=e}))})),r.tracks=function(t){for(var e=[],r=0;r<t.length;r++)for(var n=e.length,i=new Map,a=Array(16).fill(0),o=0,s=t[r];o<s.length;o++){var c=s[o],u=n,h=c.channel;if(void 0!==h){"programChange"===c.type&&(a[h]=c.programNumber);var f=a[h],p="".concat(f," ").concat(h);i.has(p)?u=i.get(p):(u=n+i.size,i.set(p,u))}e[u]||e.push([]),e[u].push(c)}return e}(r.tracks)}this.header=new o.Header(r),this.tracks=[],t&&(this.tracks=r.tracks.map((function(t){return new s.Track(t,e.header)})),1===r.header.format&&0===this.tracks[0].duration&&this.tracks.shift())}return t.fromUrl=function(e){return n(this,void 0,void 0,(function(){var r;return i(this,(function(n){switch(n.label){case 0:return[4,fetch(e)];case 1:return(r=n.sent()).ok?[4,r.arrayBuffer()]:[3,3];case 2:return[2,new t(n.sent())];case 3:throw new Error("Could not load '".concat(e,"'"))}}))}))},Object.defineProperty(t.prototype,"name",{get:function(){return this.header.name},set:function(t){this.header.name=t},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"duration",{get:function(){var t=this.tracks.map((function(t){return t.duration}));return Math.max.apply(Math,t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"durationTicks",{get:function(){var t=this.tracks.map((function(t){return t.durationTicks}));return Math.max.apply(Math,t)},enumerable:!1,configurable:!0}),t.prototype.addTrack=function(){var t=new s.Track(void 0,this.header);return this.tracks.push(t),t},t.prototype.toArray=function(){return(0,c.encode)(this)},t.prototype.toJSON=function(){return{header:this.header.toJSON(),tracks:this.tracks.map((function(t){return t.toJSON()}))}},t.prototype.fromJSON=function(t){var e=this;this.header=new o.Header,this.header.fromJSON(t.header),this.tracks=t.tracks.map((function(t){var r=new s.Track(void 0,e.header);return r.fromJSON(t),r}))},t.prototype.clone=function(){var e=new t;return e.fromJSON(this.toJSON()),e},t}();e.Midi=u;var h=r(334);Object.defineProperty(e,"Track",{enumerable:!0,get:function(){return h.Track}});var f=r(535);Object.defineProperty(e,"Header",{enumerable:!0,get:function(){return f.Header}})},518:(t,e)=>{"use strict";function r(t){return["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"][t%12]}Object.defineProperty(e,"__esModule",{value:!0}),e.Note=void 0;var n,i,a=(n=/^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,i={cbb:-2,cb:-1,c:0,"c#":1,cx:2,dbb:0,db:1,d:2,"d#":3,dx:4,ebb:2,eb:3,e:4,"e#":5,ex:6,fbb:3,fb:4,f:5,"f#":6,fx:7,gbb:5,gb:6,g:7,"g#":8,gx:9,abb:7,ab:8,a:9,"a#":10,ax:11,bbb:9,bb:10,b:11,"b#":12,bx:13},function(t){var e=n.exec(t),r=e[1],a=e[2];return i[r.toLowerCase()]+12*(parseInt(a,10)+1)}),o=new WeakMap,s=function(){function t(t,e,r){o.set(this,r),this.midi=t.midi,this.velocity=t.velocity,this.noteOffVelocity=e.velocity,this.ticks=t.ticks,this.durationTicks=e.ticks-t.ticks}return Object.defineProperty(t.prototype,"name",{get:function(){return t=this.midi,e=Math.floor(t/12)-1,r(t)+e.toString();var t,e},set:function(t){this.midi=a(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"octave",{get:function(){return Math.floor(this.midi/12)-1},set:function(t){var e=t-this.octave;this.midi+=12*e},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"pitch",{get:function(){return r(this.midi)},set:function(t){this.midi=12*(this.octave+1)+["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"].indexOf(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"duration",{get:function(){var t=o.get(this);return t.ticksToSeconds(this.ticks+this.durationTicks)-t.ticksToSeconds(this.ticks)},set:function(t){var e=o.get(this).secondsToTicks(this.time+t);this.durationTicks=e-this.ticks},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"time",{get:function(){return o.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=o.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"bars",{get:function(){return o.get(this).ticksToMeasures(this.ticks)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{duration:this.duration,durationTicks:this.durationTicks,midi:this.midi,name:this.name,ticks:this.ticks,time:this.time,velocity:this.velocity}},t}();e.Note=s},882:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.PitchBend=void 0;var r=new WeakMap,n=function(){function t(t,e){r.set(this,e),this.ticks=t.absoluteTime,this.value=t.value}return Object.defineProperty(t.prototype,"time",{get:function(){return r.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=r.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{ticks:this.ticks,time:this.time,value:this.value}},t}();e.PitchBend=n},334:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Track=void 0;var n=r(805),i=r(543),a=r(906),o=r(882),s=r(362),c=r(518),u=new WeakMap,h=function(){function t(t,e){var r=this;if(this.name="",this.notes=[],this.controlChanges=(0,a.createControlChanges)(),this.pitchBends=[],u.set(this,e),t){var n=t.find((function(t){return"trackName"===t.type}));this.name=n?n.text:""}if(this.instrument=new s.Instrument(t,this),this.channel=0,t){for(var i=t.filter((function(t){return"noteOn"===t.type})),o=t.filter((function(t){return"noteOff"===t.type})),c=function(){var t=i.shift();h.channel=t.channel;var e=o.findIndex((function(e){return e.noteNumber===t.noteNumber&&e.absoluteTime>=t.absoluteTime}));if(-1!==e){var r=o.splice(e,1)[0];h.addNote({durationTicks:r.absoluteTime-t.absoluteTime,midi:t.noteNumber,noteOffVelocity:r.velocity/127,ticks:t.absoluteTime,velocity:t.velocity/127})}},h=this;i.length;)c();t.filter((function(t){return"controller"===t.type})).forEach((function(t){r.addCC({number:t.controllerType,ticks:t.absoluteTime,value:t.value/127})})),t.filter((function(t){return"pitchBend"===t.type})).forEach((function(t){r.addPitchBend({ticks:t.absoluteTime,value:t.value/Math.pow(2,13)})}));var f=t.find((function(t){return"endOfTrack"===t.type}));this.endOfTrackTicks=void 0!==f?f.absoluteTime:void 0}}return t.prototype.addNote=function(t){var e=u.get(this),r=new c.Note({midi:0,ticks:0,velocity:1},{ticks:0,velocity:0},e);return Object.assign(r,t),(0,n.insert)(this.notes,r,"ticks"),this},t.prototype.addCC=function(t){var e=u.get(this),r=new i.ControlChange({controllerType:t.number},e);return delete t.number,Object.assign(r,t),Array.isArray(this.controlChanges[r.number])||(this.controlChanges[r.number]=[]),(0,n.insert)(this.controlChanges[r.number],r,"ticks"),this},t.prototype.addPitchBend=function(t){var e=u.get(this),r=new o.PitchBend({},e);return Object.assign(r,t),(0,n.insert)(this.pitchBends,r,"ticks"),this},Object.defineProperty(t.prototype,"duration",{get:function(){if(!this.notes.length)return 0;for(var t=this.notes[this.notes.length-1].time+this.notes[this.notes.length-1].duration,e=0;e<this.notes.length-1;e++){var r=this.notes[e].time+this.notes[e].duration;t<r&&(t=r)}return t},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"durationTicks",{get:function(){if(!this.notes.length)return 0;for(var t=this.notes[this.notes.length-1].ticks+this.notes[this.notes.length-1].durationTicks,e=0;e<this.notes.length-1;e++){var r=this.notes[e].ticks+this.notes[e].durationTicks;t<r&&(t=r)}return t},enumerable:!1,configurable:!0}),t.prototype.fromJSON=function(t){var e=this;for(var r in this.name=t.name,this.channel=t.channel,this.instrument=new s.Instrument(void 0,this),this.instrument.fromJSON(t.instrument),void 0!==t.endOfTrackTicks&&(this.endOfTrackTicks=t.endOfTrackTicks),t.controlChanges)t.controlChanges[r]&&t.controlChanges[r].forEach((function(t){e.addCC({number:t.number,ticks:t.ticks,value:t.value})}));t.notes.forEach((function(t){e.addNote({durationTicks:t.durationTicks,midi:t.midi,ticks:t.ticks,velocity:t.velocity})}))},t.prototype.toJSON=function(){for(var t={},e=0;e<127;e++)this.controlChanges.hasOwnProperty(e)&&(t[e]=this.controlChanges[e].map((function(t){return t.toJSON()})));var r={channel:this.channel,controlChanges:t,pitchBends:this.pitchBends.map((function(t){return t.toJSON()})),instrument:this.instrument.toJSON(),name:this.name,notes:this.notes.map((function(t){return t.toJSON()}))};return void 0!==this.endOfTrackTicks&&(r.endOfTrackTicks=this.endOfTrackTicks),r},t}();e.Track=h}},e={};function r(n){var i=e[n];if(void 0!==i)return i.exports;var a=e[n]={exports:{}};return t[n].call(a.exports,a,a.exports,r),a.exports}return r.d=(t,e)=>{for(var n in e)r.o(e,n)&&!r.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:e[n]})},r.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},r(233)})()}));
+    //# sourceMappingURL=Midi.js.map
+    /* eslint-enable */
+
+    return module.exports.Midi;
+  })();
+
+  function parseMidiDataUrl(args) {
+    // this.errorMessage = "";
+    if (!Midi) {
+      return "MIDI library failed to load";
+    }
+
+    const dataUrl = args.DATA_URL.trim();
+    if (!dataUrl) {
+      return "MIDI Data URL is empty";
+    }
+
+    try {
+      // Parse Data URL
+      const base64Data = dataUrl.split(",")[1];
+      if (!base64Data) {
+        throw new Error("Invalid Data URL format");
+      }
+
+      // Decode Base64 data to ArrayBuffer
+      const binaryString = atob(base64Data);
+      const len = binaryString.length;
+      const buffer = new ArrayBuffer(len);
+      const view = new Uint8Array(buffer);
+      for (let i = 0; i < len; i++) {
+        view[i] = binaryString.charCodeAt(i);
+      }
+
+      // Parse MIDI file
+      const midi = new Midi(buffer);
+
+      // Store note information
+      const notesData = [];
+      midi.tracks.forEach((track, trackIndex) => {
+        track.notes.forEach((note) => {
+          notesData.push({
+            track: trackIndex,
+            midiNumber: note.midi,
+            noteName: note.name,
+            startTime: note.time,
+            duration: note.duration,
+            velocity: note.velocity,
+          });
+        });
+      });
+
+      notesData.sort((a, b) => a.startTime - b.startTime);
+      return JSON.stringify(notesData, null, 2);
+    } catch (error) {
+      return "Error parsing MIDI file: " + error.message;
+    }
+  }
+
+  //#endregion
+
   //#region utils
 
   /**
@@ -1393,6 +1466,9 @@
           "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
         blockIconURI:
           "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
+          color1: "#4C97FF",
+          color2: "#337BCC",
+          color3: "#2C6CA3",  
         blocks: [
           // FUTURE - could force requesting permissions and checking midi device status. Usually refreshing is safer option
           // {
@@ -1689,7 +1765,18 @@
             text: Scratch.translate("stop all notes on output devices"),
           },
           SEPARATOR,
-
+          {
+            opcode: "parseMidiDataUrl",
+            blockType: Scratch.BlockType.REPORTER,
+            text: "Parse MIDI Data URL [DATA_URL]",
+            arguments: {
+              DATA_URL: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "",
+              },
+            },
+          },
+          SEPARATOR,
           {
             opcode: "noteForName",
             blockType: Scratch.BlockType.REPORTER,
@@ -2356,6 +2443,10 @@
       } catch (error) {}
       return event ? midiToString(event) : "";
     }
+    /** MIDI FILE FUNCTIONS **/
+    parseMidiDataUrl(args) {
+      return parseMidiDataUrl(args);
+    }
   }
 
   //#endregion

From 1bc7e6aa7d315dc1483eea763aedb6b8e88695af Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Mon, 17 Mar 2025 23:53:08 -0400
Subject: [PATCH 50/61] minor refactor - rearrange code

---
 extensions/midi/midi.js | 179 +++++++++++++++++++---------------------
 1 file changed, 84 insertions(+), 95 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 72c52d9ec9..57c6b330d7 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -1377,88 +1377,40 @@
    */
   const SEPARATOR = "---";
 
+  /** Menu list. Reused in two menus, so defined here rather than below */
+  const EVENT_TYPES_ITEMS = [
+    {
+      value: "noteOn",
+      text: Scratch.translate("Note On"),
+    },
+    {
+      value: "noteOff",
+      text: Scratch.translate("Note Off"),
+    },
+    {
+      value: "cc",
+      text: Scratch.translate("CC"),
+    },
+    {
+      value: "polyTouch",
+      text: Scratch.translate("AfterTouch"),
+    },
+    {
+      value: "pitchBend",
+      text: Scratch.translate("Pitch Bend"),
+    },
+    {
+      value: "programChange",
+      text: Scratch.translate("Program Change"),
+    },
+    {
+      value: "channelPressure",
+      text: Scratch.translate("Channel Pressure"),
+    },
+  ];
+
   class MidiExtension {
-    constructor() {
-      this.midi = new MidiBackend();
-      this.recorder = new MidiRecorder();
-      /**
-       * Lazy initialize midi - only upon first executing, and used in other calls to make sure it gets triggered
-       */
-      this._ensureInitialize = (evt) => {
-        if (this.midi.status === "pending" /* Initial */) {
-          this.initialize().catch(() => {});
-        }
-      };
-      this._addListeners();
-      // globalThis.midiExt = this;
-      const vm = Scratch.vm;
-      vm.runtime.once("BEFORE_EXECUTE", this._ensureInitialize);
-    }
-    /**
-     * This helper actually glues together the extension with the MidiBackend / recorder. In particular it triggers HATS when incoming midi events occur
-     */
-    _addListeners() {
-      const vm = globalThis.Scratch.vm;
-      this.midi.on("device:status", (domEvent) => {
-        const changeEvent = domEvent.detail;
-        vm.runtime.startHats(HATS.DEVICE, {
-          DEVICE_TYPE: changeEvent.type,
-          STATE: changeEvent.state,
-        });
-      });
-      this.midi.on("midi", (domEvent) => {
-        const midiEvent = domEvent.detail;
-        this.recorder.add(midiEvent);
-        const threads = vm.runtime.startHats(HATS.MIDI);
-        // set the thread local variable to the passed in midi event for use with the "input event" reporter
-        for (let thread of threads) {
-          setThreadMidiValue(thread, midiEvent);
-        }
-        switch (midiEvent.type) {
-          case "noteOn":
-          case "noteOff":
-            vm.runtime.startHats(HATS.NOTE);
-            vm.runtime.startHats(HATS.NOTEANY);
-            break;
-          // FUTURE - support a "whenCC" block if needed
-          // case "cc":
-          //   vm.runtime.startHats(HATS.CC);
-          //   break;
-        }
-      });
-    }
     getInfo() {
-      const EVENT_TYPES_ITEMS = [
-        {
-          value: "noteOn",
-          text: Scratch.translate("Note On"),
-        },
-        {
-          value: "noteOff",
-          text: Scratch.translate("Note Off"),
-        },
-        {
-          value: "cc",
-          text: Scratch.translate("CC"),
-        },
-        {
-          value: "polyTouch",
-          text: Scratch.translate("AfterTouch"),
-        },
-        {
-          value: "pitchBend",
-          text: Scratch.translate("Pitch Bend"),
-        },
-        {
-          value: "programChange",
-          text: Scratch.translate("Program Change"),
-        },
-        {
-          value: "channelPressure",
-          text: Scratch.translate("Channel Pressure"),
-        },
-      ];
-
       return {
         id: EXT_ID,
         name: Scratch.translate("Midi"),
@@ -1466,22 +1418,10 @@
           "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjMDAwIj48L3BhdGg+PC9zdmc+",
         blockIconURI:
           "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjEuNzc1IDcuNTE3SDI0djguOTY2aC0yLjIyNXptLTguNTYyIDBoNi41MDZjLjY2IDAgMS4wNDUuNTcgMS4wNDUgMS4yNDd2Ni42MDdjMCAuODQtLjM1IDEuMTEyLTEuMTEyIDEuMTEyaC02LjQzOXYtNS42OTZoMi4yMjV2My41MDVoMy4xMzVWOS41NGgtNS4zNnptLTMuMjM1IDBoMi4xOXY4Ljk2NmgtMi4xOXpNMCA3LjUxN2g3Ljg1NGMuNjYgMCAxLjA0NS41NyAxLjA0NSAxLjI0N3Y3LjcySDYuNzA4VjkuNzc0SDUuNDI3djYuNzA4SDMuNDM4VjkuNzc1SDIuMTkxdjYuNzA4SDBaIiBmaWxsPSIjRkZGIj48L3BhdGg+PC9zdmc+",
-          color1: "#4C97FF",
-          color2: "#337BCC",
-          color3: "#2C6CA3",  
+        color1: "#4C97FF",
+        color2: "#337BCC",
+        color3: "#2C6CA3",
         blocks: [
-          // FUTURE - could force requesting permissions and checking midi device status. Usually refreshing is safer option
-          // {
-          //   opcode: "initialize",
-          //   text: Scratch.translate("Initialize force? [FORCE]"),
-          //   blockType: Scratch.BlockType.COMMAND,
-          //   arguments: {
-          //     FORCE: {
-          //       type: Scratch.ArgumentType.NUMBER,
-          //       defaultValue: 1
-          //     }
-          //   }
-          // },
           {
             opcode: "whenDeviceEvent",
             text: Scratch.translate("when [DEVICE_TYPE] device [STATE]"),
@@ -2039,6 +1979,55 @@
         },
       };
     }
+    constructor() {
+      this.midi = new MidiBackend();
+      this.recorder = new MidiRecorder();
+      /**
+       * Lazy initialize midi - only upon first executing, and used in other calls to make sure it gets triggered
+       */
+      this._ensureInitialize = (evt) => {
+        if (this.midi.status === "pending" /* Initial */) {
+          this.initialize().catch(() => {});
+        }
+      };
+      this._addListeners();
+      // globalThis.midiExt = this;
+      const vm = Scratch.vm;
+      vm.runtime.once("BEFORE_EXECUTE", this._ensureInitialize);
+    }
+    /**
+     * This helper actually glues together the extension with the MidiBackend / recorder. In particular it triggers HATS when incoming midi events occur
+     */
+    _addListeners() {
+      const vm = globalThis.Scratch.vm;
+      this.midi.on("device:status", (domEvent) => {
+        const changeEvent = domEvent.detail;
+        vm.runtime.startHats(HATS.DEVICE, {
+          DEVICE_TYPE: changeEvent.type,
+          STATE: changeEvent.state,
+        });
+      });
+      this.midi.on("midi", (domEvent) => {
+        const midiEvent = domEvent.detail;
+        this.recorder.add(midiEvent);
+        const threads = vm.runtime.startHats(HATS.MIDI);
+        // set the thread local variable to the passed in midi event for use with the "input event" reporter
+        for (let thread of threads) {
+          setThreadMidiValue(thread, midiEvent);
+        }
+        switch (midiEvent.type) {
+          case "noteOn":
+          case "noteOff":
+            vm.runtime.startHats(HATS.NOTE);
+            vm.runtime.startHats(HATS.NOTEANY);
+            break;
+          // FUTURE - support a "whenCC" block if needed
+          // case "cc":
+          //   vm.runtime.startHats(HATS.CC);
+          //   break;
+        }
+      });
+    }
     // taken from /Lily/ListTools.js
     _getLists() {
       if (typeof Blockly === "undefined") {

From b8f694e943a3f4d190f94a9d5e0c0ceebc1252f8 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 18 Mar 2025 00:59:10 -0400
Subject: [PATCH 51/61] change parseMidiDataUrl to use same keys

Existing code uses "dur" for "duration", and "pitch" for "noteName"
---
 extensions/midi/midi.js | 42 ++++++++++++++++++++---------------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 57c6b330d7..107bf46577 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -31,13 +31,7 @@
     return module.exports.Midi;
   })();
 
-  function parseMidiDataUrl(args) {
-    // this.errorMessage = "";
-    if (!Midi) {
-      return "MIDI library failed to load";
-    }
-
-    const dataUrl = args.DATA_URL.trim();
+  function parseMidiDataUrl(dataUrl) {
     if (!dataUrl) {
       return "MIDI Data URL is empty";
     }
@@ -62,22 +56,23 @@
       const midi = new Midi(buffer);
 
       // Store note information
-      const notesData = [];
-      midi.tracks.forEach((track, trackIndex) => {
-        track.notes.forEach((note) => {
-          notesData.push({
-            track: trackIndex,
-            midiNumber: note.midi,
-            noteName: note.name,
-            startTime: note.time,
-            duration: note.duration,
-            velocity: note.velocity,
-          });
+      /** @type {MidiEvent[]} */
+      const notesData = midi.tracks.flatMap((track, trackIndex) => {
+        return track.notes.map((note) => {
+          return {
+            type: "noteOn",
+            channel: trackIndex + 1,
+            pitch: note.name,
+            time: note.time,
+            dur: note.duration,
+            // REVIEW should scale be MIDI (0-127), (0-1) or (0-100)?
+            velocity: note.velocity * 127,
+          };
         });
       });
 
-      notesData.sort((a, b) => a.startTime - b.startTime);
-      return JSON.stringify(notesData, null, 2);
+      notesData.sort((a, b) => a.time - b.time);
+      return notesData;
     } catch (error) {
       return "Error parsing MIDI file: " + error.message;
     }
@@ -2433,8 +2428,11 @@
       return event ? midiToString(event) : "";
     }
     /** MIDI FILE FUNCTIONS **/
-    parseMidiDataUrl(args) {
-      return parseMidiDataUrl(args);
+    parseMidiDataUrl({ DATA_URL }, util) {
+      const dataUrl = Scratch.Cast.toString(DATA_URL).trim();
+      if (!dataUrl) return "";
+      const notesData = parseMidiDataUrl(dataUrl);
+      return JSON.stringify(notesData, null, 2);
     }
   }
 

From 958fc9ac2822547a9474926c82488a617e411278 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 18 Mar 2025 01:02:20 -0400
Subject: [PATCH 52/61] round midi file times to 1 millisecond

midi precision doesn't go under 2-5 milliseconds, so forcing numbers to be readable 1ms precision
---
 extensions/midi/midi.js | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 107bf46577..d501ca8e88 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -63,10 +63,10 @@
             type: "noteOn",
             channel: trackIndex + 1,
             pitch: note.name,
-            time: note.time,
-            dur: note.duration,
+            time: roundToMillisecond(note.time),
+            dur: roundToMillisecond(note.duration),
             // REVIEW should scale be MIDI (0-127), (0-1) or (0-100)?
-            velocity: note.velocity * 127,
+            velocity: Math.round(note.velocity * 127)
           };
         });
       });
@@ -78,6 +78,10 @@
     }
   }
 
+  function roundToMillisecond(value) {
+    return Math.round(value * 1000) / 1000;
+  }
+
   //#endregion
 
   //#region utils

From 9869c243d21016d27647a238917ce3e5975d60c2 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 18 Mar 2025 01:02:58 -0400
Subject: [PATCH 53/61] fix json to event formatting

---
 extensions/midi/midi.js | 49 ++++++++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 18 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index d501ca8e88..97fe40ed0e 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -118,6 +118,7 @@
    * @property {number} [startTimestamp] for future use
    * @property {boolean} [fixedWidth] include padding to make values line up
    * @property {boolean} [useHex] use hex for number values instead of base 10
+   * @property {boolean} [useFractions] output as fractions if possible
    * @property {number} [defaultOctave] default octave if not otherwise specfied. default 4
    *
    */
@@ -138,7 +139,7 @@
     midi,
     { useFlats = false, fixedWidth = false } = {}
   ) {
-    if (!isFinite(midi)) return "";
+    if (!isFinite(midi)) return Scratch.Cast.toString(midi) || "";
     let chroma = (useFlats ? FLATS : SHARPS)[midi % 12];
     if (fixedWidth) chroma = chroma.padEnd(2, "_");
     const octave = Math.floor(midi / 12) - 1;
@@ -615,14 +616,18 @@
     return ` ${PREFIX_WHEN}${formatTimespan(val)}`;
   }
 
-  // TODO FUTURE add in opts flag to use fractions or not
-  function formatPosition(value, _opts) {
-    return `${PREFIX_POS}${formatFraction(value)}`;
+  function formatPosition(value, opts) {
+    return ` ${PREFIX_POS}${formatSeconds(value, opts)}`;
   }
 
-  // TODO FUTURE add in opts flag to use fractions or not
-  function formatDuration(value, _opts) {
-    return `${PREFIX_DURATION}${formatFraction(value)}`;
+  function formatDuration(value, opts) {
+    return ` ${PREFIX_DURATION}${formatSeconds(value, opts)}`;
+  }
+
+  function formatSeconds(value, opts) {
+    // truncate to 1 millisecond accuracy
+    value = Math.round(value * 1000) / 1000;
+    return opts?.useFractions ? formatFraction(value) : `${value}`;
   }
 
   function formatTimespan(seconds, hoursOptional = true) {
@@ -2417,18 +2422,26 @@
       const raw = Scratch.Cast.toString(TEXT);
       let event = null;
       try {
-        event = {
-          ...JSON.parse(raw),
-        };
-        // rename aliases just in case
-        [
-          ["beats", "dur"],
-          ["offset", "pos"],
-          ["@", "time"],
-        ]
-          .filter(([alias, key]) => alias in event && event[key] == undefined)
-          .forEach(([alias, key]) => (event[key] = event[alias]));
+        event = JSON.parse(raw);
       } catch (error) {}
+
+      if (Array.isArray(event)) {
+        return event.map((e) => midiToString(e)).join("\n");
+      }
+      if (event === null) {
+        return "";
+      }
+      if (typeof event !== "object") {
+        return midiToString(stringToMidi(event));
+      }
+      // rename aliases just in case
+      [
+        ["beats", "dur"],
+        ["offset", "pos"],
+        ["@", "time"],
+      ]
+        .filter(([alias, key]) => alias in event && event[key] == undefined)
+        .forEach(([alias, key]) => (event[key] = event[alias]));
       return event ? midiToString(event) : "";
     }
     /** MIDI FILE FUNCTIONS **/

From fd1c19d0e30258f01e8e40214221e9de35f196d3 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Tue, 18 Mar 2025 01:06:23 -0400
Subject: [PATCH 54/61] fix linting

---
 extensions/midi/midi.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 97fe40ed0e..6b3eef3ecf 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -66,7 +66,7 @@
             time: roundToMillisecond(note.time),
             dur: roundToMillisecond(note.duration),
             // REVIEW should scale be MIDI (0-127), (0-1) or (0-100)?
-            velocity: Math.round(note.velocity * 127)
+            velocity: Math.round(note.velocity * 127),
           };
         });
       });
@@ -1712,7 +1712,7 @@
           {
             opcode: "parseMidiDataUrl",
             blockType: Scratch.BlockType.REPORTER,
-            text: "Parse MIDI Data URL [DATA_URL]",
+            text: Scratch.translate("Parse MIDI Data URL [DATA_URL]"),
             arguments: {
               DATA_URL: {
                 type: Scratch.ArgumentType.STRING,

From f87bc9b6fdea47711bd0c6cc9574324a9cfb445b Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 17 Apr 2025 21:11:40 -0400
Subject: [PATCH 55/61] allow formatting pitch as sharp/flat or number

---
 extensions/midi/midi.js | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 6b3eef3ecf..e234a3ee8d 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -112,7 +112,7 @@
    *
    * @typedef {object} FormatOptions
    * @property {number} [tempo] override tempo used in converting beats/pos. default is stage tempo
-   * @property {boolean} [useFlats] show notes as flats instead of sharps
+   * @property {'sharps' |'flats' | 'num'} [pitchFormat] show notes as flats instead of sharps, or number value
    * @property {boolean} [noMinify] include all data even if defaults
    * @property {'omit' | 'timestamp' | 'absolute'} [timestampFormat] for future use
    * @property {number} [startTimestamp] for future use
@@ -137,10 +137,11 @@
   const FLATS = "C Db D Eb E F Gb G Ab A Bb B".split(" ");
   function midiPitchToNoteName(
     midi,
-    { useFlats = false, fixedWidth = false } = {}
+    { pitchFormat = "sharps", fixedWidth = false } = {}
   ) {
-    if (!isFinite(midi)) return Scratch.Cast.toString(midi) || "";
-    let chroma = (useFlats ? FLATS : SHARPS)[midi % 12];
+    if (!isFinite(midi) || pitchFormat === "num")
+      return Scratch.Cast.toString(midi) || "";
+    let chroma = (pitchFormat === "flats" ? FLATS : SHARPS)[midi % 12];
     if (fixedWidth) chroma = chroma.padEnd(2, "_");
     const octave = Math.floor(midi / 12) - 1;
     return `${chroma}${octave}`;
@@ -175,6 +176,8 @@
     if (typeof text === "number") return text;
     if (!text) return undefined;
     text = text.trim();
+    // parse float value
+    if (text.includes(".")) return parseFloat(text);
     const useHex = opts?.useHex ?? /[a-f]/i.test(text);
     const radix = useHex ? 16 : 10;
     const val = parseInt(text, radix);
@@ -328,7 +331,7 @@
     duration: "dur",
     pos: "pos",
     beats: "beats",
-    value: "value2",
+    value: "value",
   };
 
   // These are how different midi event keys are split. ch and dev are special cases that don't include =, since they're common. Other params use = to allow arbitrary additional properties if needed
@@ -1921,6 +1924,10 @@
                 value: "flats",
                 text: `♭ ${Scratch.translate("Flats")}`,
               },
+              {
+                value: "num",
+                text: `${Scratch.translate("MIDI Number")}`,
+              },
             ],
           },
           NOTE_NAMES: {
@@ -2249,13 +2256,12 @@
       return noteNameToMidiPitch(name) || 0;
     }
     nameForNote({ NOTE, ACCIDENTAL }, util) {
-      const useFlats =
-        Scratch.Cast.toString(ACCIDENTAL).toLowerCase() === "flats";
+      const pitchFormat = Scratch.Cast.toString(ACCIDENTAL).toLowerCase();
       let val = Scratch.Cast.toNumber(NOTE);
       if (!val && /^[a-g]/i.test(`${NOTE}`)) {
         val = noteNameToMidiPitch(Scratch.Cast.toString(NOTE)) || 0;
       }
-      return midiPitchToNoteName(val, { useFlats });
+      return midiPitchToNoteName(val, { pitchFormat });
     }
     makeOutputNote({ NOTE, BEATS, VELOCITY, CHANNEL, DEVICE }) {
       let beats =

From c98d827a7b0eb03c7cc94e78186eeaec7b3ac116 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 17 Apr 2025 21:15:26 -0400
Subject: [PATCH 56/61] always include node/noteon type in string output and
 catch some edge input cases

---
 extensions/midi/midi.js | 30 +++++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index e234a3ee8d..6e237b68b9 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -379,7 +379,8 @@
       opts = {}
     ) {
       return formatNoteType(
-        opts?.noMinify ? shorthands.noteOn : undefined,
+        // opts?.noMinify ? shorthands.noteOn : undefined,
+        shorthands.noteOn,
         note,
         velocity,
         opts
@@ -387,7 +388,8 @@
     },
     noteOff({ value1: note }, opts = {}) {
       return formatNoteType(
-        opts?.noMinify ? shorthands.noteOff : undefined,
+        // opts?.noMinify ? shorthands.noteOff : undefined,
+        shorthands.noteOff,
         note,
         0,
         opts
@@ -582,6 +584,7 @@
       case "reset":
         break;
       case "rest":
+        break;
       // do nothing
     }
     // look at eventMap to give 'friendly' names to value1/value2 (ex. "pitch", "velocity")
@@ -752,7 +755,7 @@
     let { type, value1, value2, channel = 1 } = event;
     const spec = eventMapping[type];
     // return empty if not valid event
-    if (!spec) return new Uint8Array();
+    if (!spec || !spec.command) return new Uint8Array();
     const commandAndChannel = spec.command + Math.max(channel - 1, 0);
     if (spec.param1 && value1 == undefined) {
       value1 = (event[spec.param1] ?? spec.defaults?.[0]) || 0;
@@ -1384,7 +1387,8 @@
    */
   const SEPARATOR = "---";
 
-  /** Menu list. Reused in two menus, so defined here rather than below */
+  class MidiExtension {
+    getInfo() {
   const EVENT_TYPES_ITEMS = [
     {
       value: "noteOn",
@@ -1997,13 +2001,14 @@
        * Lazy initialize midi - only upon first executing, and used in other calls to make sure it gets triggered
        */
       this._ensureInitialize = (evt) => {
-        if (this.midi.status === "pending" /* Initial */) {
+        if (this.midi.status === "pending") {
           this.initialize().catch(() => {});
         }
       };
       this._addListeners();
       // globalThis.midiExt = this;
       const vm = Scratch.vm;
+      // REVIEW this will end up always requesting midi permissions even if just using this extension for midi files. does this matter?
       vm.runtime.once("BEFORE_EXECUTE", this._ensureInitialize);
     }
     /**
@@ -2100,6 +2105,7 @@
       return this.midi.outputs.length;
     }
     getDeviceInfo({ DEVICE_TYPE, INDEX, DEVICE_PROP }, util) {
+      this._ensureInitialize();
       const deviceType = Scratch.Cast.toString(DEVICE_TYPE).toLowerCase();
       const deviceList =
         deviceType === "input" ? this.midi.inputs : this.midi.outputs;
@@ -2426,15 +2432,20 @@
     }
     jsonToEvent({ TEXT }, util) {
       const raw = Scratch.Cast.toString(TEXT);
+      // ignore empty inputs
+      if (raw === "" || raw === "0") return "";
+
       let event = null;
       try {
         event = JSON.parse(raw);
-      } catch (error) {}
+      } catch (error) {
+        event = stringToMidi(raw);
+      }
 
       if (Array.isArray(event)) {
         return event.map((e) => midiToString(e)).join("\n");
       }
-      if (event === null) {
+      if (event == null) {
         return "";
       }
       if (typeof event !== "object") {
@@ -2448,6 +2459,11 @@
       ]
         .filter(([alias, key]) => alias in event && event[key] == undefined)
         .forEach(([alias, key]) => (event[key] = event[alias]));
+
+      // normalize type and default to note if not otherwise specified
+      let type =
+        event.type === REST_LITERAL ? "rest" : normalizeType(event.type);
+      if (!type && event.pitch) type = "noteOn";
       return event ? midiToString(event) : "";
     }
     /** MIDI FILE FUNCTIONS **/

From b02976904d9a7839d8b80e33c2d92c0c030c05f2 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 17 Apr 2025 21:21:26 -0400
Subject: [PATCH 57/61] add generic key=value parser/formatter

---
 extensions/midi/midi.js | 88 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 6e237b68b9..03ed950eed 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -597,6 +597,94 @@
     return event;
   }
 
+  /**
+   * Key Values helper
+   * generic helper to convert key=value pairs to/from javascript object
+   * any values that aren't in key=value format go into unkeyed array
+   */
+  const kvHelper = {
+    _tokenizeRe: /(?<ws>\s*)((?<key>\w+)=)?(?<value>("[^"]*"|\S+)?)?/g,
+    *tokenize(str = "") {
+      const { unquote } = kvHelper;
+      let unkeyed = "";
+      for (let match of String(str).matchAll(kvHelper._tokenizeRe)) {
+        const { key, value = "", ws } = match.groups;
+        if (!key) {
+          unkeyed += `${unkeyed ? ws : ""}${value}`;
+          continue;
+        }
+        if (unkeyed) {
+          yield { value: unquote(unkeyed) };
+          unkeyed = "";
+        }
+        yield { key, value: unquote(value) };
+      }
+      if (unkeyed) yield { value: unquote(unkeyed) };
+    },
+    /**
+     *
+     * @param {*} str
+     * @returns {{ args: Record<string, string>, _: string[]}}
+     */
+    parseKeyValues(str = "") {
+      const out = { args: {}, _: [] };
+      for (let { key, value } of kvHelper.tokenize(str)) {
+        if (key) {
+          out.args[key] = value;
+        } else {
+          out._.push(value);
+        }
+      }
+      return out;
+    },
+    isQuoted(str) {
+      return str.length > 1 && str.startsWith('"') && str.endsWith('"');
+    },
+    quote(str, force = false) {
+      if (!/[\s="]/.test(str) && !force) return str;
+      if (kvHelper.isQuoted(str)) str = str.slice(1, -1);
+      return `"${str.replace(/"/g, "''")}"`;
+    },
+    unquote(str) {
+      if (kvHelper.isQuoted(str)) {
+        return str.slice(1, -1).replace(/''/g, '"');
+      }
+      return str;
+    },
+    /**
+     * Convert an object into key/value pairs (values with special characters get quoted/escaped)
+     * @param {Record<string, any>} args
+     * @param {any[]} [unkeyed]
+     * @param {boolean} [compact] remove falsy values
+     * @returns {string}
+     */
+    formatKeyValues(args, unkeyed, compact = true) {
+      let entries = Object.entries(args);
+      if (Array.isArray(unkeyed)) entries.push(...unkeyed.map((v) => ["", v]));
+      if (compact)
+        entries = entries.filter(([_, value]) => value || value === 0);
+      return entries
+        .map(([key, val]) => kvHelper.formatKeyValue(key, val))
+        .filter(Boolean)
+        .join(" ");
+    },
+    /**
+     *
+     * @param {*} [key]
+     * @param {*} [value]
+     * @returns {string}
+     */
+    formatKeyValue(key = "", value = "") {
+      const { quote } = kvHelper;
+      // REVIEW this makes sure output is compatible with parse by avoiding " or spaces etc
+      key = String(key).trim().replace(/[^\w]/, "");
+      value = String(value).trim();
+      if (key === "" && value === "") return "";
+      // surround with quotes if necessary
+      return `${key ? `${quote(key)}=` : ""}${kvHelper.quote(value)}`;
+    },
+  };
+
   function formatChannel(channel = 0, opts) {
     const str = opts?.useHex
       ? formatHex(channel, 1)

From 29de0469ffdabc1cc595fb6a34ffc3dca7a76755 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 17 Apr 2025 21:23:58 -0400
Subject: [PATCH 58/61] revamp midi file parsing to use Scratch.fetch, include
 meta events like tempo/keySignature

---
 extensions/midi/midi.js | 478 +++++++++++++++++++++++++++++++---------
 1 file changed, 373 insertions(+), 105 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 03ed950eed..f9a650a892 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -31,52 +31,163 @@
     return module.exports.Midi;
   })();
 
-  function parseMidiDataUrl(dataUrl) {
-    if (!dataUrl) {
-      return "MIDI Data URL is empty";
-    }
-
-    try {
-      // Parse Data URL
-      const base64Data = dataUrl.split(",")[1];
-      if (!base64Data) {
-        throw new Error("Invalid Data URL format");
+  class MidiFileManager {
+    cache = new Map();
+    async fetchMidiUrl(url, force = false) {
+      if (this.cache.has(url) && !force) {
+        return this.cache.get(url);
       }
 
-      // Decode Base64 data to ArrayBuffer
-      const binaryString = atob(base64Data);
-      const len = binaryString.length;
-      const buffer = new ArrayBuffer(len);
-      const view = new Uint8Array(buffer);
-      for (let i = 0; i < len; i++) {
-        view[i] = binaryString.charCodeAt(i);
+      if (!(await Scratch.canFetch(url))) {
+        throw new Error(`Permission to fetch ${url} denied`);
+      }
+      const res = await Scratch.fetch(url, { mode: "cors" });
+      if (!res.ok) {
+        throw new Error(`${res.status} ${res.statusText} fetch ${url} failed`);
       }
 
       // Parse MIDI file
-      const midi = new Midi(buffer);
-
+      const midi = new Midi(await res.arrayBuffer());
+      // const parsed = this.parseMidiData(midi, "ANY");
+      this.cache.set(url, midi);
+      return midi;
+    }
+    /**
+     *
+     * @param {any} midi midi file from cache
+     * @param {EventType | "ANY"} filter
+     * @returns
+     */
+    parseMidiData(midi, filter = "ANY") {
       // Store note information
       /** @type {MidiEvent[]} */
-      const notesData = midi.tracks.flatMap((track, trackIndex) => {
-        return track.notes.map((note) => {
-          return {
+      const events = [];
+      if (filter === "ANY" || filter === "meta") {
+        events.push(...this._parseHeader(midi.header));
+      }
+      events.push(
+        ...midi.tracks.flatMap((track) => this._parseTrack(track, filter))
+      );
+
+      const sortOrder = ["meta", "programChange", "noteOn"];
+      return events.sort((a, b) => {
+        // sort by timestamp
+        let delta = a.time - b.time;
+        delta ||= (a.channel ?? 0) - (b.channel ?? 0);
+        delta ||=
+          sortOrder.indexOf(a.type) + 1 - (sortOrder.indexOf(b.type) + 1);
+        return delta;
+      });
+    }
+    /**
+     *
+     * @param {*} header
+     * @returns {MidiEvent[]}
+     */
+    _parseHeader(header) {
+      const {
+        keySignatures = [],
+        meta = [],
+        // ppq,
+        tempos = [],
+        timeSignatures = [],
+      } = header;
+      /**
+       *
+       * @param {any[]} list
+       * @param {(evt: any) => Partial<MidiEvent>} transform
+       * @returns {MidiEvent[]}
+       */
+      const toEventList = (list, transform) => {
+        return list.map((evt) => ({
+          type: "meta",
+          time: header.ticksToSeconds(evt.ticks),
+          ...transform(evt),
+        }));
+      };
+      return [
+        ...toEventList(tempos, ({ bpm }) => ({ tempo: bpm })),
+        ...toEventList(timeSignatures, ({ timeSignature }) => ({
+          timeSignature: `${timeSignature[0]}/${timeSignature[1]}`,
+        })),
+        ...toEventList(keySignatures, ({ key, scale }) => ({
+          keySignature: `${key}${scale}`,
+        })),
+        // FUTURE type could be "lyrics", "cuePoint", "marker" or "text"
+        ...toEventList(meta, ({ text, type: _ }) => ({ text })),
+      ];
+    }
+    /**
+     *
+     * @param {*} track
+     * @param {EventType | "ANY"} filter
+     */
+    _parseTrack(track, filter) {
+      const channel = track.channel + 1;
+      const { name: trackName, instrument } = track;
+      /** @type {MidiEvent[]} */
+      const events = [];
+      if (filter === "ANY" || filter.includes("meta")) {
+        if (trackName) {
+          events.push({
+            type: "meta",
+            channel,
+            trackName,
+            time: 0,
+          });
+        }
+        if (instrument?.number !== undefined) {
+          events.push({
+            type: "programChange",
+            channel,
+            value: instrument.number,
+            ...(instrument.name && { instrument: instrument.name }),
+            time: 0,
+          });
+        }
+      }
+      if (filter === "ANY" || filter === "noteOn") {
+        events.push(
+          ...track.notes.map((note) => ({
             type: "noteOn",
-            channel: trackIndex + 1,
+            channel,
             pitch: note.name,
             time: roundToMillisecond(note.time),
             dur: roundToMillisecond(note.duration),
-            // REVIEW should scale be MIDI (0-127), (0-1) or (0-100)?
             velocity: Math.round(note.velocity * 127),
-          };
-        });
-      });
-
-      notesData.sort((a, b) => a.time - b.time);
-      return notesData;
-    } catch (error) {
-      return "Error parsing MIDI file: " + error.message;
+          }))
+        );
+      }
+      if (filter === "ANY" || filter === "cc") {
+        const ccEvents = Object.values(track.controlChanges).flatMap(
+          (arr) => arr
+        );
+        // @ts-ignore
+        events.push(
+          ...ccEvents.map((evt) => ({
+            type: /** @type {EventType} */("cc"),
+            channel,
+            cc: evt.number,
+            time: roundToMillisecond(evt.time),
+            value: Math.round(evt.value * 127),
+          }))
+        );
+      }
+      if (filter === "ANY" || filter === "pitchBend") {
+        events.push(
+          ...track.pitchBends.map((evt) => ({
+            type: "pitchBend",
+            channel,
+            time: roundToMillisecond(evt.time),
+            // REVIEW - saving highResParam as 0-16384 instead of -1 -> 1
+            value: Math.round((evt.value + 1) * 8192),
+          }))
+        );
+      }
+      return events;
     }
   }
+  const fileManager = new MidiFileManager();
 
   function roundToMillisecond(value) {
     return Math.round(value * 1000) / 1000;
@@ -92,7 +203,11 @@
    *
    *
    * // definition for the parsed midi event
-   * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset'} EventType
+   * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset' | 'meta'} EventType
+   *
+   * @typedef {'timeSignature' | 'tempo' | 'keySignature' | 'text' | 'trackName' | 'instrument'} MetaKey
+   *
+   *
    * @typedef {object} MidiEvent
    * @property {EventType | 'rest'} type type of midi command (note on, program change, tc). Default is 'noteOn'
    * @property {number} [value1] (0-127) raw data1 byte value
@@ -107,6 +222,15 @@
    * @property {number} [pos] time in beats - gets converted to time using current tempo
    * @property {number} [dur] (note type only) duration in seconds- send corresponding note off event automatically
    * @property {number} [beats] gets converted to dur using current tempo
+   *
+   * // midi file meta fields
+   * @property {string} [keySignature] midi file only
+   * @property {string} [text] midi file lyric event
+   * @property {string} [trackName] midi file name of track
+   * @property {string} [timeSignature] midi file 3/8 4/4
+   * @property {number} [tempo] midi file tempo bpm
+   * @property {string} [instrument] midi file friendly instrument name
+   *
    * @property {string} [_str] cached string representation of this event
    *
    *
@@ -295,11 +419,19 @@
       command: 255,
       description: "System Reset (Sys Realtime)",
     },
+    meta: {
+      shorthand: "meta",
+      command: 0,
+      description: "MIDI File Meta Message",
+    },
   };
   /** @type {Map<number, EventType>} */
   // @ts-ignore
   const commandLookup = new Map(
-    Object.entries(eventMapping).map(([key, { command }]) => [command, key])
+    Object.entries(eventMapping)
+      // ignore midi file only entries (i.e. "meta")
+      .filter(([key, { command }]) => !!command)
+      .map(([key, { command }]) => [command, key])
   );
   /** @type {Map<string, EventType>} */
   const shorthandLookup = Object.fromEntries([
@@ -333,6 +465,15 @@
     beats: "beats",
     value: "value",
   };
+  /** @type {ReadonlyArray<MetaKey>} */
+  const metaKeys = [
+    "tempo",
+    "timeSignature",
+    "keySignature",
+    "trackName",
+    "text",
+    "instrument",
+  ];
 
   // These are how different midi event keys are split. ch and dev are special cases that don't include =, since they're common. Other params use = to allow arbitrary additional properties if needed
   const PREFIX_CHANNEL = "ch";
@@ -427,6 +568,13 @@
     start: () => shorthands.start,
     stop: () => shorthands.stop,
     reset: () => shorthands.reset,
+    meta(event, opts) {
+      const keyValues = metaKeys
+        .map((key) => key in event && kvHelper.formatKeyValue(key, event[key]))
+        .filter(Boolean)
+        .join(" ");
+      return `${shorthands.meta} ${keyValues}`;
+    },
   };
 
   /**
@@ -456,6 +604,10 @@
     if (event.device != undefined || noMinify) {
       msg += formatDevice(event.device, opts);
     }
+    // HACK just for midi file support, ideally this would be generic
+    if (event.instrument) {
+      msg += ` ${kvHelper.formatKeyValue("instrument", event.instrument)}`;
+    }
     if (event.time != undefined) {
       msg += formatTime(event, opts);
     }
@@ -477,44 +629,55 @@
    */
   function stringToMidi(text, opts = {}) {
     if (typeof text !== "string") text = Scratch.Cast.toString(text);
-    const fullRe =
-      /^\s*(?<type>[a-zA-Z]{2,}|~)?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<data1>\b-?[0-9a-f]{1,5}\b))?\s*(?<data2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.*)\s*$/;
-    const match = fullRe.exec(text);
-    if (!match?.groups) return null;
-    // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
-    // ch/dev/@ (channel, device, time) are special keys that don't need =
-    const keyvalRe = /\s*(?<key>\w+(?==)|ch|dev|@)=?(?<val>\S+)\s*/g;
-    /** @type {{[K in keyof MidiEvent | 'beats']?: string}} */
-    const extras = Object.fromEntries(
-      Array.from(match.groups.keyvals?.matchAll(keyvalRe) || [])
-        // paramLookup converts "t=2" into "time=2"
-        .map(({ groups: { key, val } }) => [paramLookup[key] || key, val])
-    );
-    let {
-      type: shorthand = extras.type,
-      pitch = extras.pitch,
-      data1,
-      data2,
-    } = match.groups;
+    if (text === "" || text === "0") return null;
+
+    /** @type {null | {[K in keyof MidiEvent | 'beats' | 'keyvals']?: string}} */
+    let data = null;
+
+    // handle JSON input
+    if (text.startsWith("{")) {
+      try {
+        data = JSON.parse(text);
+      } catch (_err) {}
+    } else {
+      const fullRe =
+        /^\s*(?<type>[a-zA-Z]{2,}|~)?\s*((?<pitch>[A-G][#b♯♭_]*-?\d?)|(?<value1>\b-?[0-9a-f]{1,5}\b))?\s*(?<value2>\b[0-9a-f]{1,3}\b)?\s*(?<keyvals>.*)\s*$/;
+      data = fullRe.exec(text)?.groups ?? null;
+    }
+    if (!data) return null;
+
+    // add extra meta / keyvalue pairs
+    if (typeof data.keyvals === "string") {
+      // turn key=val other=32.43 @14.23 into {key: 'val', other: 32.43, time=14.23}
+      for (let { key, value } of kvHelper.tokenize(data.keyvals)) {
+        // match values that have shorthand notation
+        if (!key && value) {
+          [key, value] = /^(ch|dev|@)?(.*)$/.exec(value).slice(1);
+        }
+        if (!key) continue;
+        key = paramLookup[key] || key;
+        data[key] = data[key] ?? value;
+      }
+    }
 
     // midi value1 can be specified as pitch or as number
-    const value1 = pitch
-      ? noteNameToMidiPitch(pitch, opts.defaultOctave)
-      : parseNumValue(data1, opts);
+    const value1 = data.pitch
+      ? noteNameToMidiPitch(data.pitch, opts.defaultOctave)
+      : parseNumValue(data.value1, opts);
 
-    let value2 = parseNumValue(data2, opts);
+    let value2 = parseNumValue(data.value2, opts);
 
     /** @type {MidiEvent} */
     const event = {
-      type: shorthand === REST_LITERAL ? "rest" : normalizeType(shorthand),
+      type: data.type === REST_LITERAL ? "rest" : normalizeType(data.type),
       ...(value1 != undefined && { value1 }),
       ...(value2 != undefined && { value2 }),
-      channel: parseNumValue(extras.channel, opts),
-      device: parseNumValue(extras.device, opts),
-      ...(extras.time && { time: parseTimespan(extras.time) }),
-      ...(extras.dur && { dur: parseFraction(extras.dur) }),
-      ...(extras.pos && { pos: parseFraction(extras.pos) }),
-      ...(extras.beats && { beats: parseFraction(extras.beats) }),
+      channel: parseNumValue(data.channel, opts),
+      device: parseNumValue(data.device, opts),
+      ...(data.time && { time: parseTimespan(data.time) }),
+      ...(data.dur && { dur: parseFraction(data.dur) }),
+      ...(data.pos && { pos: parseFraction(data.pos) }),
+      ...(data.beats && { beats: parseFraction(data.beats) }),
     };
 
     if (event.beats && event.dur == undefined) {
@@ -576,6 +739,19 @@
           value2: parsedHighRes.value2,
         });
         break;
+      case "meta":
+        Object.assign(
+          event,
+          Object.fromEntries(
+            metaKeys
+              .filter((key) => key in data)
+              .map((key) => [
+                key,
+                key === "tempo" ? parseFloat(data[key]) : data[key],
+              ])
+          )
+        );
+        break;
       case "clock":
       case "start":
       case "continue":
@@ -594,6 +770,7 @@
     if (spec?.param2 && event.value2 != undefined) {
       event[spec.param2] = event.value2;
     }
+
     return event;
   }
 
@@ -1477,39 +1654,41 @@
 
   class MidiExtension {
     getInfo() {
-  const EVENT_TYPES_ITEMS = [
-    {
-      value: "noteOn",
-      text: Scratch.translate("Note On"),
-    },
-    {
-      value: "noteOff",
-      text: Scratch.translate("Note Off"),
-    },
-    {
-      value: "cc",
-      text: Scratch.translate("CC"),
-    },
-    {
-      value: "polyTouch",
-      text: Scratch.translate("AfterTouch"),
-    },
-    {
-      value: "pitchBend",
-      text: Scratch.translate("Pitch Bend"),
-    },
-    {
-      value: "programChange",
-      text: Scratch.translate("Program Change"),
-    },
-    {
-      value: "channelPressure",
-      text: Scratch.translate("Channel Pressure"),
-    },
-  ];
+      const EVENT_TYPES_ITEMS = [
+        {
+          value: "noteOn",
+          text: Scratch.translate("Note On"),
+        },
+        {
+          value: "noteOff",
+          text: Scratch.translate("Note Off"),
+        },
+        {
+          value: "cc",
+          text: Scratch.translate("CC"),
+        },
+        {
+          value: "polyTouch",
+          text: Scratch.translate("AfterTouch"),
+        },
+        {
+          value: "pitchBend",
+          text: Scratch.translate("Pitch Bend"),
+        },
+        {
+          value: "programChange",
+          text: Scratch.translate("Program Change"),
+        },
+        {
+          value: "channelPressure",
+          text: Scratch.translate("Channel Pressure"),
+        },
+        {
+          value: "meta",
+          text: Scratch.translate("Midi File Meta"),
+        },
+      ];
 
-  class MidiExtension {
-    getInfo() {
       return {
         id: EXT_ID,
         name: Scratch.translate("Midi"),
@@ -1805,13 +1984,34 @@
           },
           SEPARATOR,
           {
-            opcode: "parseMidiDataUrl",
+            opcode: "parseMidiUrl",
             blockType: Scratch.BlockType.REPORTER,
-            text: Scratch.translate("Parse MIDI Data URL [DATA_URL]"),
+            text: Scratch.translate("Parse MIDI from url: [PATH]"),
             arguments: {
-              DATA_URL: {
+              PATH: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: ".mid",
+              },
+            },
+          },
+          {
+            opcode: "setListToMidi",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate(
+              "Set list [LIST] to [FILTER] in [MIDIDATA]"
+            ),
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists",
+              },
+              FILTER: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "MIDI_FILTER",
+                defaultValue: "ANY",
+              },
+              MIDIDATA: {
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "",
               },
             },
           },
@@ -2074,6 +2274,36 @@
               },
             ],
           },
+          MIDI_FILTER: {
+            acceptReporters: true,
+            // TODO dedupe this with EVENT_TYPES?
+            items: [
+              {
+                value: "ANY",
+                text: Scratch.translate("all events"),
+              },
+              {
+                value: "noteOn",
+                text: Scratch.translate("all Notes"),
+              },
+              {
+                value: "meta",
+                text: Scratch.translate("MIDI File Meta"),
+              },
+              {
+                value: "programChange",
+                text: Scratch.translate("Program Changes"),
+              },
+              {
+                value: "cc",
+                text: Scratch.translate("CC"),
+              },
+              {
+                value: "pitchBend",
+                text: Scratch.translate("Pitch Bends"),
+              },
+            ],
+          },
           // taken from /Lily/ListTools.js
           lists: {
             acceptReporters: true,
@@ -2555,11 +2785,49 @@
       return event ? midiToString(event) : "";
     }
     /** MIDI FILE FUNCTIONS **/
-    parseMidiDataUrl({ DATA_URL }, util) {
-      const dataUrl = Scratch.Cast.toString(DATA_URL).trim();
-      if (!dataUrl) return "";
-      const notesData = parseMidiDataUrl(dataUrl);
-      return JSON.stringify(notesData, null, 2);
+    async parseMidiUrl({ PATH }, util) {
+      // cribbed from sound.js
+      try {
+        const url = Scratch.Cast.toString(PATH).trim();
+        if (!url) return "";
+        const midiFile = await fileManager.fetchMidiUrl(url);
+        const eventData = fileManager.parseMidiData(midiFile, "ANY");
+
+        return JSON.stringify(eventData, null, 2);
+      } catch (e) {
+        console.warn(`Parse ${PATH} failed`, e);
+        return "";
+      }
+    }
+    async setListToMidi({ LIST, FILTER, MIDIDATA }, util) {
+      let raw = Scratch.Cast.toString(MIDIDATA).trim();
+      const filter = Scratch.Cast.toString(FILTER) || "ANY";
+      /** @type {MidiEvent[]} */
+      let events = [];
+      if (/^(data|blob|https?)/.test(raw)) {
+        const midiFile = await fileManager.fetchMidiUrl(raw);
+        events = fileManager.parseMidiData(midiFile, FILTER);
+      } else if (/^\s*[[{]/.test(raw)) {
+        // may fail
+        try {
+          events = JSON.parse(raw);
+        } catch (err) {}
+      } else {
+        // TODO COMBAK verify
+        // NOTE doesn't check for newlines in "text" type fields
+        events = raw.split(/\s*[\r\n]+\s*/).map((row) => stringToMidi(row));
+      }
+      if (filter !== "ANY") {
+        events = events.filter(({ type }) => type === filter);
+      }
+      if (LIST) {
+        this._upsertList(
+          Scratch.Cast.toString(LIST),
+          // COMBAK no formatting options set
+          events.map((evt) => midiToString(evt)),
+          util.target
+        );
+      }
     }
   }
 

From c012e3577e6ff495cdf31f3ef3a20f4e4837f554 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 17 Apr 2025 21:24:41 -0400
Subject: [PATCH 59/61] add license credits

---
 extensions/midi/midi.js | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index f9a650a892..67bfde5b55 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -19,11 +19,27 @@
     const exports = {};
     const module = { exports };
 
+    /*!
+      The followig code is from tonejs/midi, which is based on midi-file
+      The original code is available at https://github.com/Tonejs/Midi and https://github.com/carter-thaxton/midi-file
+
+      We use it under the following license:
+
+      The MIT License
+
+      @tonejs/midi - Copyright © 2016 Yotam Mann
+      midi-file - Copyright © 2016 Carter Thaxton
+
+      Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+      The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+     * 
+     */
+
     /* eslint-disable */
     // prettier-ignore
-
-    //  tonejs/midi
-    // TODO FIXME - include full link to original code + licensing here - see newgroundsIO.js for one such example
     !function(t,e){if("object"==typeof exports&&"object"==typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var r=e();for(var n in r)("object"==typeof exports?exports:t)[n]=r[n]}}("undefined"!=typeof self?self:this,(function(){return(()=>{var t={507:(t,e,r)=>{"use strict";function n(t){var e=[];return i(t,e),e}function i(t,e){for(var r=0;r<t.length;r++){var n=t[r];Array.isArray(n)?i(n,e):e.push(n)}}r.r(e),r.d(e,{flatten:()=>n})},289:(t,e,r)=>{e.parseMidi=r(666),e.writeMidi=r(865)},666:t=>{function e(t){for(var e,n=new r(t),i=[];!n.eof();){var a=o();i.push(a)}return i;function o(){var t={};t.deltaTime=n.readVarInt();var r=n.readUInt8();if(240==(240&r)){if(255!==r){if(240==r)return t.type="sysEx",a=n.readVarInt(),t.data=n.readBytes(a),t;if(247==r)return t.type="endSysEx",a=n.readVarInt(),t.data=n.readBytes(a),t;throw"Unrecognised MIDI event type byte: "+r}t.meta=!0;var i=n.readUInt8(),a=n.readVarInt();switch(i){case 0:if(t.type="sequenceNumber",2!==a)throw"Expected length for sequenceNumber event is 2, got "+a;return t.number=n.readUInt16(),t;case 1:return t.type="text",t.text=n.readString(a),t;case 2:return t.type="copyrightNotice",t.text=n.readString(a),t;case 3:return t.type="trackName",t.text=n.readString(a),t;case 4:return t.type="instrumentName",t.text=n.readString(a),t;case 5:return t.type="lyrics",t.text=n.readString(a),t;case 6:return t.type="marker",t.text=n.readString(a),t;case 7:return t.type="cuePoint",t.text=n.readString(a),t;case 32:if(t.type="channelPrefix",1!=a)throw"Expected length for channelPrefix event is 1, got "+a;return t.channel=n.readUInt8(),t;case 33:if(t.type="portPrefix",1!=a)throw"Expected length for portPrefix event is 1, got "+a;return t.port=n.readUInt8(),t;case 47:if(t.type="endOfTrack",0!=a)throw"Expected length for endOfTrack event is 0, got "+a;return t;case 81:if(t.type="setTempo",3!=a)throw"Expected length for setTempo event is 3, got "+a;return t.microsecondsPerBeat=n.readUInt24(),t;case 84:if(t.type="smpteOffset",5!=a)throw"Expected length for smpteOffset event is 5, got "+a;var o=n.readUInt8();return t.frameRate={0:24,32:25,64:29,96:30}[96&o],t.hour=31&o,t.min=n.readUInt8(),t.sec=n.readUInt8(),t.frame=n.readUInt8(),t.subFrame=n.readUInt8(),t;case 88:if(t.type="timeSignature",4!=a)throw"Expected length for timeSignature event is 4, got "+a;return t.numerator=n.readUInt8(),t.denominator=1<<n.readUInt8(),t.metronome=n.readUInt8(),t.thirtyseconds=n.readUInt8(),t;case 89:if(t.type="keySignature",2!=a)throw"Expected length for keySignature event is 2, got "+a;return t.key=n.readInt8(),t.scale=n.readUInt8(),t;case 127:return t.type="sequencerSpecific",t.data=n.readBytes(a),t;default:return t.type="unknownMeta",t.data=n.readBytes(a),t.metatypeByte=i,t}}else{var s;if(0==(128&r)){if(null===e)throw"Running status byte encountered before status byte";s=r,r=e,t.running=!0}else s=n.readUInt8(),e=r;var c=r>>4;switch(t.channel=15&r,c){case 8:return t.type="noteOff",t.noteNumber=s,t.velocity=n.readUInt8(),t;case 9:var u=n.readUInt8();return t.type=0===u?"noteOff":"noteOn",t.noteNumber=s,t.velocity=u,0===u&&(t.byte9=!0),t;case 10:return t.type="noteAftertouch",t.noteNumber=s,t.amount=n.readUInt8(),t;case 11:return t.type="controller",t.controllerType=s,t.value=n.readUInt8(),t;case 12:return t.type="programChange",t.programNumber=s,t;case 13:return t.type="channelAftertouch",t.amount=s,t;case 14:return t.type="pitchBend",t.value=s+(n.readUInt8()<<7)-8192,t;default:throw"Unrecognised MIDI event type: "+c}}}}function r(t){this.buffer=t,this.bufferLen=this.buffer.length,this.pos=0}r.prototype.eof=function(){return this.pos>=this.bufferLen},r.prototype.readUInt8=function(){var t=this.buffer[this.pos];return this.pos+=1,t},r.prototype.readInt8=function(){var t=this.readUInt8();return 128&t?t-256:t},r.prototype.readUInt16=function(){return(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readInt16=function(){var t=this.readUInt16();return 32768&t?t-65536:t},r.prototype.readUInt24=function(){return(this.readUInt8()<<16)+(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readInt24=function(){var t=this.readUInt24();return 8388608&t?t-16777216:t},r.prototype.readUInt32=function(){return(this.readUInt8()<<24)+(this.readUInt8()<<16)+(this.readUInt8()<<8)+this.readUInt8()},r.prototype.readBytes=function(t){var e=this.buffer.slice(this.pos,this.pos+t);return this.pos+=t,e},r.prototype.readString=function(t){var e=this.readBytes(t);return String.fromCharCode.apply(null,e)},r.prototype.readVarInt=function(){for(var t=0;!this.eof();){var e=this.readUInt8();if(!(128&e))return t+e;t+=127&e,t<<=7}return t},r.prototype.readChunk=function(){var t=this.readString(4),e=this.readUInt32();return{id:t,length:e,data:this.readBytes(e)}},t.exports=function(t){var n=new r(t),i=n.readChunk();if("MThd"!=i.id)throw"Bad MIDI file.  Expected 'MHdr', got: '"+i.id+"'";for(var a=function(t){var e=new r(t),n={format:e.readUInt16(),numTracks:e.readUInt16()},i=e.readUInt16();return 32768&i?(n.framesPerSecond=256-(i>>8),n.ticksPerFrame=255&i):n.ticksPerBeat=i,n}(i.data),o=[],s=0;!n.eof()&&s<a.numTracks;s++){var c=n.readChunk();if("MTrk"!=c.id)throw"Bad MIDI file.  Expected 'MTrk', got: '"+c.id+"'";var u=e(c.data);o.push(u)}return{header:a,tracks:o}}},865:t=>{function e(t,e,i){var a,o=new n,s=e.length,c=null;for(a=0;a<s;a++)!1!==i.running&&(i.running||e[a].running)||(c=null),c=r(o,e[a],c,i.useByte9ForNoteOff);t.writeChunk("MTrk",o.buffer)}function r(t,e,r,n){var i=e.type,a=e.deltaTime,o=e.text||"",s=e.data||[],c=null;switch(t.writeVarInt(a),i){case"sequenceNumber":t.writeUInt8(255),t.writeUInt8(0),t.writeVarInt(2),t.writeUInt16(e.number);break;case"text":t.writeUInt8(255),t.writeUInt8(1),t.writeVarInt(o.length),t.writeString(o);break;case"copyrightNotice":t.writeUInt8(255),t.writeUInt8(2),t.writeVarInt(o.length),t.writeString(o);break;case"trackName":t.writeUInt8(255),t.writeUInt8(3),t.writeVarInt(o.length),t.writeString(o);break;case"instrumentName":t.writeUInt8(255),t.writeUInt8(4),t.writeVarInt(o.length),t.writeString(o);break;case"lyrics":t.writeUInt8(255),t.writeUInt8(5),t.writeVarInt(o.length),t.writeString(o);break;case"marker":t.writeUInt8(255),t.writeUInt8(6),t.writeVarInt(o.length),t.writeString(o);break;case"cuePoint":t.writeUInt8(255),t.writeUInt8(7),t.writeVarInt(o.length),t.writeString(o);break;case"channelPrefix":t.writeUInt8(255),t.writeUInt8(32),t.writeVarInt(1),t.writeUInt8(e.channel);break;case"portPrefix":t.writeUInt8(255),t.writeUInt8(33),t.writeVarInt(1),t.writeUInt8(e.port);break;case"endOfTrack":t.writeUInt8(255),t.writeUInt8(47),t.writeVarInt(0);break;case"setTempo":t.writeUInt8(255),t.writeUInt8(81),t.writeVarInt(3),t.writeUInt24(e.microsecondsPerBeat);break;case"smpteOffset":t.writeUInt8(255),t.writeUInt8(84),t.writeVarInt(5);var u=31&e.hour|{24:0,25:32,29:64,30:96}[e.frameRate];t.writeUInt8(u),t.writeUInt8(e.min),t.writeUInt8(e.sec),t.writeUInt8(e.frame),t.writeUInt8(e.subFrame);break;case"timeSignature":t.writeUInt8(255),t.writeUInt8(88),t.writeVarInt(4),t.writeUInt8(e.numerator);var h=255&Math.floor(Math.log(e.denominator)/Math.LN2);t.writeUInt8(h),t.writeUInt8(e.metronome),t.writeUInt8(e.thirtyseconds||8);break;case"keySignature":t.writeUInt8(255),t.writeUInt8(89),t.writeVarInt(2),t.writeInt8(e.key),t.writeUInt8(e.scale);break;case"sequencerSpecific":t.writeUInt8(255),t.writeUInt8(127),t.writeVarInt(s.length),t.writeBytes(s);break;case"unknownMeta":null!=e.metatypeByte&&(t.writeUInt8(255),t.writeUInt8(e.metatypeByte),t.writeVarInt(s.length),t.writeBytes(s));break;case"sysEx":t.writeUInt8(240),t.writeVarInt(s.length),t.writeBytes(s);break;case"endSysEx":t.writeUInt8(247),t.writeVarInt(s.length),t.writeBytes(s);break;case"noteOff":(c=(!1!==n&&e.byte9||n&&0==e.velocity?144:128)|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.velocity);break;case"noteOn":(c=144|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.velocity);break;case"noteAftertouch":(c=160|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.noteNumber),t.writeUInt8(e.amount);break;case"controller":(c=176|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.controllerType),t.writeUInt8(e.value);break;case"programChange":(c=192|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.programNumber);break;case"channelAftertouch":(c=208|e.channel)!==r&&t.writeUInt8(c),t.writeUInt8(e.amount);break;case"pitchBend":(c=224|e.channel)!==r&&t.writeUInt8(c);var f=8192+e.value,p=127&f,l=f>>7&127;t.writeUInt8(p),t.writeUInt8(l);break;default:throw"Unrecognized event type: "+i}return c}function n(){this.buffer=[]}n.prototype.writeUInt8=function(t){this.buffer.push(255&t)},n.prototype.writeInt8=n.prototype.writeUInt8,n.prototype.writeUInt16=function(t){var e=t>>8&255,r=255&t;this.writeUInt8(e),this.writeUInt8(r)},n.prototype.writeInt16=n.prototype.writeUInt16,n.prototype.writeUInt24=function(t){var e=t>>16&255,r=t>>8&255,n=255&t;this.writeUInt8(e),this.writeUInt8(r),this.writeUInt8(n)},n.prototype.writeInt24=n.prototype.writeUInt24,n.prototype.writeUInt32=function(t){var e=t>>24&255,r=t>>16&255,n=t>>8&255,i=255&t;this.writeUInt8(e),this.writeUInt8(r),this.writeUInt8(n),this.writeUInt8(i)},n.prototype.writeInt32=n.prototype.writeUInt32,n.prototype.writeBytes=function(t){this.buffer=this.buffer.concat(Array.prototype.slice.call(t,0))},n.prototype.writeString=function(t){var e,r=t.length,n=[];for(e=0;e<r;e++)n.push(t.codePointAt(e));this.writeBytes(n)},n.prototype.writeVarInt=function(t){if(t<0)throw"Cannot write negative variable-length integer";if(t<=127)this.writeUInt8(t);else{var e=t,r=[];for(r.push(127&e),e>>=7;e;){var n=127&e|128;r.push(n),e>>=7}this.writeBytes(r.reverse())}},n.prototype.writeChunk=function(t,e){this.writeString(t),this.writeUInt32(e.length),this.writeBytes(e)},t.exports=function(t,r){if("object"!=typeof t)throw"Invalid MIDI data";r=r||{};var i,a=t.header||{},o=t.tracks||[],s=o.length,c=new n;for(function(t,e,r){var i=null==e.format?1:e.format,a=128;e.timeDivision?a=e.timeDivision:e.ticksPerFrame&&e.framesPerSecond?a=-(255&e.framesPerSecond)<<8|255&e.ticksPerFrame:e.ticksPerBeat&&(a=32767&e.ticksPerBeat);var o=new n;o.writeUInt16(i),o.writeUInt16(r),o.writeUInt16(a),t.writeChunk("MThd",o.buffer)}(c,a,s),i=0;i<s;i++)e(c,o[i],r);return c.buffer}},805:(t,e)=>{"use strict";function r(t,e,r){void 0===r&&(r="ticks");var n=0,i=t.length,a=i;if(i>0&&t[i-1][r]<=e)return i-1;for(;n<a;){var o=Math.floor(n+(a-n)/2),s=t[o],c=t[o+1];if(s[r]===e){for(var u=o;u<t.length;u++)t[u][r]===e&&(o=u);return o}if(s[r]<e&&c[r]>e)return o;s[r]>e?a=o:s[r]<e&&(n=o+1)}return-1}Object.defineProperty(e,"__esModule",{value:!0}),e.insert=e.search=void 0,e.search=r,e.insert=function(t,e,n){if(void 0===n&&(n="ticks"),t.length){var i=r(t,e[n],n);t.splice(i+1,0,e)}else t.push(e)}},543:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.ControlChange=e.controlChangeIds=e.controlChangeNames=void 0,e.controlChangeNames={1:"modulationWheel",2:"breath",4:"footController",5:"portamentoTime",7:"volume",8:"balance",10:"pan",64:"sustain",65:"portamentoTime",66:"sostenuto",67:"softPedal",68:"legatoFootswitch",84:"portamentoControl"},e.controlChangeIds=Object.keys(e.controlChangeNames).reduce((function(t,r){return t[e.controlChangeNames[r]]=r,t}),{});var r=new WeakMap,n=new WeakMap,i=function(){function t(t,e){r.set(this,e),n.set(this,t.controllerType),this.ticks=t.absoluteTime,this.value=t.value}return Object.defineProperty(t.prototype,"number",{get:function(){return n.get(this)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"name",{get:function(){return e.controlChangeNames[this.number]?e.controlChangeNames[this.number]:null},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"time",{get:function(){return r.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=r.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{number:this.number,ticks:this.ticks,time:this.time,value:this.value}},t}();e.ControlChange=i},906:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.createControlChanges=void 0;var n=r(543);e.createControlChanges=function(){return new Proxy({},{get:function(t,e){return t[e]?t[e]:n.controlChangeIds.hasOwnProperty(e)?t[n.controlChangeIds[e]]:void 0},set:function(t,e,r){return n.controlChangeIds.hasOwnProperty(e)?t[n.controlChangeIds[e]]=r:t[e]=r,!0}})}},54:function(t,e,r){"use strict";var n=this&&this.__spreadArray||function(t,e,r){if(r||2===arguments.length)for(var n,i=0,a=e.length;i<a;i++)!n&&i in e||(n||(n=Array.prototype.slice.call(e,0,i)),n[i]=e[i]);return t.concat(n||Array.prototype.slice.call(e))};Object.defineProperty(e,"__esModule",{value:!0}),e.encode=void 0;var i=r(289),a=r(535),o=r(507);function s(t,e){return{absoluteTime:t.ticks,channel:e,controllerType:t.number,deltaTime:0,type:"controller",value:Math.floor(127*t.value)}}function c(t){return{absoluteTime:0,channel:t.channel,deltaTime:0,programNumber:t.instrument.number,type:"programChange"}}e.encode=function(t){var e={header:{format:1,numTracks:t.tracks.length+1,ticksPerBeat:t.header.ppq},tracks:n([n(n(n(n([{absoluteTime:0,deltaTime:0,meta:!0,text:t.header.name,type:"trackName"}],t.header.keySignatures.map((function(t){return function(t){var e=a.keySignatureKeys.indexOf(t.key);return{absoluteTime:t.ticks,deltaTime:0,key:e+7,meta:!0,scale:"major"===t.scale?0:1,type:"keySignature"}}(t)})),!0),t.header.meta.map((function(t){return{absoluteTime:(e=t).ticks,deltaTime:0,meta:!0,text:e.text,type:e.type};var e})),!0),t.header.tempos.map((function(t){return function(t){return{absoluteTime:t.ticks,deltaTime:0,meta:!0,microsecondsPerBeat:Math.floor(6e7/t.bpm),type:"setTempo"}}(t)})),!0),t.header.timeSignatures.map((function(t){return function(t){return{absoluteTime:t.ticks,deltaTime:0,denominator:t.timeSignature[1],meta:!0,metronome:24,numerator:t.timeSignature[0],thirtyseconds:8,type:"timeSignature"}}(t)})),!0)],t.tracks.map((function(t){return n(n(n([(e=t.name,{absoluteTime:0,deltaTime:0,meta:!0,text:e,type:"trackName"}),c(t)],function(t){return(0,o.flatten)(t.notes.map((function(e){return function(t,e){return[{absoluteTime:t.ticks,channel:e,deltaTime:0,noteNumber:t.midi,type:"noteOn",velocity:Math.floor(127*t.velocity)},{absoluteTime:t.ticks+t.durationTicks,channel:e,deltaTime:0,noteNumber:t.midi,type:"noteOff",velocity:Math.floor(127*t.noteOffVelocity)}]}(e,t.channel)})))}(t),!0),function(t){for(var e=[],r=0;r<127;r++)t.controlChanges.hasOwnProperty(r)&&t.controlChanges[r].forEach((function(r){e.push(s(r,t.channel))}));return e}(t),!0),function(t){var e=[];return t.pitchBends.forEach((function(r){e.push(function(t,e){return{absoluteTime:t.ticks,channel:e,deltaTime:0,type:"pitchBend",value:t.value}}(r,t.channel))})),e}(t),!0);var e})),!0)};return e.tracks=e.tracks.map((function(t){t=t.sort((function(t,e){return t.absoluteTime-e.absoluteTime}));var e=0;return t.forEach((function(t){t.deltaTime=t.absoluteTime-e,e=t.absoluteTime,delete t.absoluteTime})),t.push({deltaTime:0,meta:!0,type:"endOfTrack"}),t})),new Uint8Array((0,i.writeMidi)(e))}},535:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Header=e.keySignatureKeys=void 0;var n=r(805),i=new WeakMap;e.keySignatureKeys=["Cb","Gb","Db","Ab","Eb","Bb","F","C","G","D","A","E","B","F#","C#"];var a=function(){function t(t){var r=this;if(this.tempos=[],this.timeSignatures=[],this.keySignatures=[],this.meta=[],this.name="",i.set(this,480),t){i.set(this,t.header.ticksPerBeat),t.tracks.forEach((function(t){t.forEach((function(t){t.meta&&("timeSignature"===t.type?r.timeSignatures.push({ticks:t.absoluteTime,timeSignature:[t.numerator,t.denominator]}):"setTempo"===t.type?r.tempos.push({bpm:6e7/t.microsecondsPerBeat,ticks:t.absoluteTime}):"keySignature"===t.type&&r.keySignatures.push({key:e.keySignatureKeys[t.key+7],scale:0===t.scale?"major":"minor",ticks:t.absoluteTime}))}))}));var n=0;t.tracks[0].forEach((function(t){n+=t.deltaTime,t.meta&&("trackName"===t.type?r.name=t.text:"text"!==t.type&&"cuePoint"!==t.type&&"marker"!==t.type&&"lyrics"!==t.type||r.meta.push({text:t.text,ticks:n,type:t.type}))})),this.update()}}return t.prototype.update=function(){var t=this,e=0,r=0;this.tempos.sort((function(t,e){return t.ticks-e.ticks})),this.tempos.forEach((function(n,i){var a=i>0?t.tempos[i-1].bpm:t.tempos[0].bpm,o=n.ticks/t.ppq-r,s=60/a*o;n.time=s+e,e=n.time,r+=o})),this.timeSignatures.sort((function(t,e){return t.ticks-e.ticks})),this.timeSignatures.forEach((function(e,r){var n=r>0?t.timeSignatures[r-1]:t.timeSignatures[0],i=(e.ticks-n.ticks)/t.ppq/n.timeSignature[0]/(n.timeSignature[1]/4);n.measures=n.measures||0,e.measures=i+n.measures}))},t.prototype.ticksToSeconds=function(t){var e=(0,n.search)(this.tempos,t);if(-1!==e){var r=this.tempos[e],i=r.time,a=(t-r.ticks)/this.ppq;return i+60/r.bpm*a}return t/this.ppq*.5},t.prototype.ticksToMeasures=function(t){var e=(0,n.search)(this.timeSignatures,t);if(-1!==e){var r=this.timeSignatures[e],i=(t-r.ticks)/this.ppq;return r.measures+i/(r.timeSignature[0]/r.timeSignature[1])/4}return t/this.ppq/4},Object.defineProperty(t.prototype,"ppq",{get:function(){return i.get(this)},enumerable:!1,configurable:!0}),t.prototype.secondsToTicks=function(t){var e=(0,n.search)(this.tempos,t,"time");if(-1!==e){var r=this.tempos[e],i=(t-r.time)/(60/r.bpm);return Math.round(r.ticks+i*this.ppq)}var a=t/.5;return Math.round(a*this.ppq)},t.prototype.toJSON=function(){return{keySignatures:this.keySignatures,meta:this.meta,name:this.name,ppq:this.ppq,tempos:this.tempos.map((function(t){return{bpm:t.bpm,ticks:t.ticks}})),timeSignatures:this.timeSignatures}},t.prototype.fromJSON=function(t){this.name=t.name,this.tempos=t.tempos.map((function(t){return Object.assign({},t)})),this.timeSignatures=t.timeSignatures.map((function(t){return Object.assign({},t)})),this.keySignatures=t.keySignatures.map((function(t){return Object.assign({},t)})),this.meta=t.meta.map((function(t){return Object.assign({},t)})),i.set(this,t.ppq),this.update()},t.prototype.setTempo=function(t){this.tempos=[{bpm:t,ticks:0}],this.update()},t}();e.Header=a},362:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Instrument=void 0;var n=r(438),i=new WeakMap,a=function(){function t(t,e){if(this.number=0,i.set(this,e),this.number=0,t){var r=t.find((function(t){return"programChange"===t.type}));r&&(this.number=r.programNumber)}}return Object.defineProperty(t.prototype,"name",{get:function(){return this.percussion?n.DrumKitByPatchID[this.number]:n.instrumentByPatchID[this.number]},set:function(t){var e=n.instrumentByPatchID.indexOf(t);-1!==e&&(this.number=e)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"family",{get:function(){return this.percussion?"drums":n.InstrumentFamilyByID[Math.floor(this.number/8)]},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"percussion",{get:function(){return 9===i.get(this).channel},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{family:this.family,number:this.number,name:this.name}},t.prototype.fromJSON=function(t){this.number=t.number},t}();e.Instrument=a},438:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.DrumKitByPatchID=e.InstrumentFamilyByID=e.instrumentByPatchID=void 0,e.instrumentByPatchID=["acoustic grand piano","bright acoustic piano","electric grand piano","honky-tonk piano","electric piano 1","electric piano 2","harpsichord","clavi","celesta","glockenspiel","music box","vibraphone","marimba","xylophone","tubular bells","dulcimer","drawbar organ","percussive organ","rock organ","church organ","reed organ","accordion","harmonica","tango accordion","acoustic guitar (nylon)","acoustic guitar (steel)","electric guitar (jazz)","electric guitar (clean)","electric guitar (muted)","overdriven guitar","distortion guitar","guitar harmonics","acoustic bass","electric bass (finger)","electric bass (pick)","fretless bass","slap bass 1","slap bass 2","synth bass 1","synth bass 2","violin","viola","cello","contrabass","tremolo strings","pizzicato strings","orchestral harp","timpani","string ensemble 1","string ensemble 2","synthstrings 1","synthstrings 2","choir aahs","voice oohs","synth voice","orchestra hit","trumpet","trombone","tuba","muted trumpet","french horn","brass section","synthbrass 1","synthbrass 2","soprano sax","alto sax","tenor sax","baritone sax","oboe","english horn","bassoon","clarinet","piccolo","flute","recorder","pan flute","blown bottle","shakuhachi","whistle","ocarina","lead 1 (square)","lead 2 (sawtooth)","lead 3 (calliope)","lead 4 (chiff)","lead 5 (charang)","lead 6 (voice)","lead 7 (fifths)","lead 8 (bass + lead)","pad 1 (new age)","pad 2 (warm)","pad 3 (polysynth)","pad 4 (choir)","pad 5 (bowed)","pad 6 (metallic)","pad 7 (halo)","pad 8 (sweep)","fx 1 (rain)","fx 2 (soundtrack)","fx 3 (crystal)","fx 4 (atmosphere)","fx 5 (brightness)","fx 6 (goblins)","fx 7 (echoes)","fx 8 (sci-fi)","sitar","banjo","shamisen","koto","kalimba","bag pipe","fiddle","shanai","tinkle bell","agogo","steel drums","woodblock","taiko drum","melodic tom","synth drum","reverse cymbal","guitar fret noise","breath noise","seashore","bird tweet","telephone ring","helicopter","applause","gunshot"],e.InstrumentFamilyByID=["piano","chromatic percussion","organ","guitar","bass","strings","ensemble","brass","reed","pipe","synth lead","synth pad","synth effects","world","percussive","sound effects"],e.DrumKitByPatchID={0:"standard kit",8:"room kit",16:"power kit",24:"electronic kit",25:"tr-808 kit",32:"jazz kit",40:"brush kit",48:"orchestra kit",56:"sound fx kit"}},233:function(t,e,r){"use strict";var n=this&&this.__awaiter||function(t,e,r,n){return new(r||(r=Promise))((function(i,a){function o(t){try{c(n.next(t))}catch(t){a(t)}}function s(t){try{c(n.throw(t))}catch(t){a(t)}}function c(t){var e;t.done?i(t.value):(e=t.value,e instanceof r?e:new r((function(t){t(e)}))).then(o,s)}c((n=n.apply(t,e||[])).next())}))},i=this&&this.__generator||function(t,e){var r,n,i,a,o={label:0,sent:function(){if(1&i[0])throw i[1];return i[1]},trys:[],ops:[]};return a={next:s(0),throw:s(1),return:s(2)},"function"==typeof Symbol&&(a[Symbol.iterator]=function(){return this}),a;function s(a){return function(s){return function(a){if(r)throw new TypeError("Generator is already executing.");for(;o;)try{if(r=1,n&&(i=2&a[0]?n.return:a[0]?n.throw||((i=n.return)&&i.call(n),0):n.next)&&!(i=i.call(n,a[1])).done)return i;switch(n=0,i&&(a=[2&a[0],i.value]),a[0]){case 0:case 1:i=a;break;case 4:return o.label++,{value:a[1],done:!1};case 5:o.label++,n=a[1],a=[0];continue;case 7:a=o.ops.pop(),o.trys.pop();continue;default:if(!((i=(i=o.trys).length>0&&i[i.length-1])||6!==a[0]&&2!==a[0])){o=0;continue}if(3===a[0]&&(!i||a[1]>i[0]&&a[1]<i[3])){o.label=a[1];break}if(6===a[0]&&o.label<i[1]){o.label=i[1],i=a;break}if(i&&o.label<i[2]){o.label=i[2],o.ops.push(a);break}i[2]&&o.ops.pop(),o.trys.pop();continue}a=e.call(t,o)}catch(t){a=[6,t],n=0}finally{r=i=0}if(5&a[0])throw a[1];return{value:a[0]?a[1]:void 0,done:!0}}([a,s])}}};Object.defineProperty(e,"__esModule",{value:!0}),e.Header=e.Track=e.Midi=void 0;var a=r(289),o=r(535),s=r(334),c=r(54),u=function(){function t(t){var e=this,r=null;if(t){var n=t instanceof ArrayBuffer?new Uint8Array(t):t;(r=(0,a.parseMidi)(n)).tracks.forEach((function(t){var e=0;t.forEach((function(t){e+=t.deltaTime,t.absoluteTime=e}))})),r.tracks=function(t){for(var e=[],r=0;r<t.length;r++)for(var n=e.length,i=new Map,a=Array(16).fill(0),o=0,s=t[r];o<s.length;o++){var c=s[o],u=n,h=c.channel;if(void 0!==h){"programChange"===c.type&&(a[h]=c.programNumber);var f=a[h],p="".concat(f," ").concat(h);i.has(p)?u=i.get(p):(u=n+i.size,i.set(p,u))}e[u]||e.push([]),e[u].push(c)}return e}(r.tracks)}this.header=new o.Header(r),this.tracks=[],t&&(this.tracks=r.tracks.map((function(t){return new s.Track(t,e.header)})),1===r.header.format&&0===this.tracks[0].duration&&this.tracks.shift())}return t.fromUrl=function(e){return n(this,void 0,void 0,(function(){var r;return i(this,(function(n){switch(n.label){case 0:return[4,fetch(e)];case 1:return(r=n.sent()).ok?[4,r.arrayBuffer()]:[3,3];case 2:return[2,new t(n.sent())];case 3:throw new Error("Could not load '".concat(e,"'"))}}))}))},Object.defineProperty(t.prototype,"name",{get:function(){return this.header.name},set:function(t){this.header.name=t},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"duration",{get:function(){var t=this.tracks.map((function(t){return t.duration}));return Math.max.apply(Math,t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"durationTicks",{get:function(){var t=this.tracks.map((function(t){return t.durationTicks}));return Math.max.apply(Math,t)},enumerable:!1,configurable:!0}),t.prototype.addTrack=function(){var t=new s.Track(void 0,this.header);return this.tracks.push(t),t},t.prototype.toArray=function(){return(0,c.encode)(this)},t.prototype.toJSON=function(){return{header:this.header.toJSON(),tracks:this.tracks.map((function(t){return t.toJSON()}))}},t.prototype.fromJSON=function(t){var e=this;this.header=new o.Header,this.header.fromJSON(t.header),this.tracks=t.tracks.map((function(t){var r=new s.Track(void 0,e.header);return r.fromJSON(t),r}))},t.prototype.clone=function(){var e=new t;return e.fromJSON(this.toJSON()),e},t}();e.Midi=u;var h=r(334);Object.defineProperty(e,"Track",{enumerable:!0,get:function(){return h.Track}});var f=r(535);Object.defineProperty(e,"Header",{enumerable:!0,get:function(){return f.Header}})},518:(t,e)=>{"use strict";function r(t){return["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"][t%12]}Object.defineProperty(e,"__esModule",{value:!0}),e.Note=void 0;var n,i,a=(n=/^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,i={cbb:-2,cb:-1,c:0,"c#":1,cx:2,dbb:0,db:1,d:2,"d#":3,dx:4,ebb:2,eb:3,e:4,"e#":5,ex:6,fbb:3,fb:4,f:5,"f#":6,fx:7,gbb:5,gb:6,g:7,"g#":8,gx:9,abb:7,ab:8,a:9,"a#":10,ax:11,bbb:9,bb:10,b:11,"b#":12,bx:13},function(t){var e=n.exec(t),r=e[1],a=e[2];return i[r.toLowerCase()]+12*(parseInt(a,10)+1)}),o=new WeakMap,s=function(){function t(t,e,r){o.set(this,r),this.midi=t.midi,this.velocity=t.velocity,this.noteOffVelocity=e.velocity,this.ticks=t.ticks,this.durationTicks=e.ticks-t.ticks}return Object.defineProperty(t.prototype,"name",{get:function(){return t=this.midi,e=Math.floor(t/12)-1,r(t)+e.toString();var t,e},set:function(t){this.midi=a(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"octave",{get:function(){return Math.floor(this.midi/12)-1},set:function(t){var e=t-this.octave;this.midi+=12*e},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"pitch",{get:function(){return r(this.midi)},set:function(t){this.midi=12*(this.octave+1)+["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"].indexOf(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"duration",{get:function(){var t=o.get(this);return t.ticksToSeconds(this.ticks+this.durationTicks)-t.ticksToSeconds(this.ticks)},set:function(t){var e=o.get(this).secondsToTicks(this.time+t);this.durationTicks=e-this.ticks},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"time",{get:function(){return o.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=o.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"bars",{get:function(){return o.get(this).ticksToMeasures(this.ticks)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{duration:this.duration,durationTicks:this.durationTicks,midi:this.midi,name:this.name,ticks:this.ticks,time:this.time,velocity:this.velocity}},t}();e.Note=s},882:(t,e)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.PitchBend=void 0;var r=new WeakMap,n=function(){function t(t,e){r.set(this,e),this.ticks=t.absoluteTime,this.value=t.value}return Object.defineProperty(t.prototype,"time",{get:function(){return r.get(this).ticksToSeconds(this.ticks)},set:function(t){var e=r.get(this);this.ticks=e.secondsToTicks(t)},enumerable:!1,configurable:!0}),t.prototype.toJSON=function(){return{ticks:this.ticks,time:this.time,value:this.value}},t}();e.PitchBend=n},334:(t,e,r)=>{"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Track=void 0;var n=r(805),i=r(543),a=r(906),o=r(882),s=r(362),c=r(518),u=new WeakMap,h=function(){function t(t,e){var r=this;if(this.name="",this.notes=[],this.controlChanges=(0,a.createControlChanges)(),this.pitchBends=[],u.set(this,e),t){var n=t.find((function(t){return"trackName"===t.type}));this.name=n?n.text:""}if(this.instrument=new s.Instrument(t,this),this.channel=0,t){for(var i=t.filter((function(t){return"noteOn"===t.type})),o=t.filter((function(t){return"noteOff"===t.type})),c=function(){var t=i.shift();h.channel=t.channel;var e=o.findIndex((function(e){return e.noteNumber===t.noteNumber&&e.absoluteTime>=t.absoluteTime}));if(-1!==e){var r=o.splice(e,1)[0];h.addNote({durationTicks:r.absoluteTime-t.absoluteTime,midi:t.noteNumber,noteOffVelocity:r.velocity/127,ticks:t.absoluteTime,velocity:t.velocity/127})}},h=this;i.length;)c();t.filter((function(t){return"controller"===t.type})).forEach((function(t){r.addCC({number:t.controllerType,ticks:t.absoluteTime,value:t.value/127})})),t.filter((function(t){return"pitchBend"===t.type})).forEach((function(t){r.addPitchBend({ticks:t.absoluteTime,value:t.value/Math.pow(2,13)})}));var f=t.find((function(t){return"endOfTrack"===t.type}));this.endOfTrackTicks=void 0!==f?f.absoluteTime:void 0}}return t.prototype.addNote=function(t){var e=u.get(this),r=new c.Note({midi:0,ticks:0,velocity:1},{ticks:0,velocity:0},e);return Object.assign(r,t),(0,n.insert)(this.notes,r,"ticks"),this},t.prototype.addCC=function(t){var e=u.get(this),r=new i.ControlChange({controllerType:t.number},e);return delete t.number,Object.assign(r,t),Array.isArray(this.controlChanges[r.number])||(this.controlChanges[r.number]=[]),(0,n.insert)(this.controlChanges[r.number],r,"ticks"),this},t.prototype.addPitchBend=function(t){var e=u.get(this),r=new o.PitchBend({},e);return Object.assign(r,t),(0,n.insert)(this.pitchBends,r,"ticks"),this},Object.defineProperty(t.prototype,"duration",{get:function(){if(!this.notes.length)return 0;for(var t=this.notes[this.notes.length-1].time+this.notes[this.notes.length-1].duration,e=0;e<this.notes.length-1;e++){var r=this.notes[e].time+this.notes[e].duration;t<r&&(t=r)}return t},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"durationTicks",{get:function(){if(!this.notes.length)return 0;for(var t=this.notes[this.notes.length-1].ticks+this.notes[this.notes.length-1].durationTicks,e=0;e<this.notes.length-1;e++){var r=this.notes[e].ticks+this.notes[e].durationTicks;t<r&&(t=r)}return t},enumerable:!1,configurable:!0}),t.prototype.fromJSON=function(t){var e=this;for(var r in this.name=t.name,this.channel=t.channel,this.instrument=new s.Instrument(void 0,this),this.instrument.fromJSON(t.instrument),void 0!==t.endOfTrackTicks&&(this.endOfTrackTicks=t.endOfTrackTicks),t.controlChanges)t.controlChanges[r]&&t.controlChanges[r].forEach((function(t){e.addCC({number:t.number,ticks:t.ticks,value:t.value})}));t.notes.forEach((function(t){e.addNote({durationTicks:t.durationTicks,midi:t.midi,ticks:t.ticks,velocity:t.velocity})}))},t.prototype.toJSON=function(){for(var t={},e=0;e<127;e++)this.controlChanges.hasOwnProperty(e)&&(t[e]=this.controlChanges[e].map((function(t){return t.toJSON()})));var r={channel:this.channel,controlChanges:t,pitchBends:this.pitchBends.map((function(t){return t.toJSON()})),instrument:this.instrument.toJSON(),name:this.name,notes:this.notes.map((function(t){return t.toJSON()}))};return void 0!==this.endOfTrackTicks&&(r.endOfTrackTicks=this.endOfTrackTicks),r},t}();e.Track=h}},e={};function r(n){var i=e[n];if(void 0!==i)return i.exports;var a=e[n]={exports:{}};return t[n].call(a.exports,a,a.exports,r),a.exports}return r.d=(t,e)=>{for(var n in e)r.o(e,n)&&!r.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:e[n]})},r.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},r(233)})()}));
     //# sourceMappingURL=Midi.js.map
     /* eslint-enable */

From 1a7ffd882ee28cb1402c074edbf750e83d7a1df3 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Thu, 17 Apr 2025 21:25:02 -0400
Subject: [PATCH 60/61] add midi extension to extensions.json

---
 extensions/extensions.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/extensions/extensions.json b/extensions/extensions.json
index 43d6c3a2c9..0ffbe65d45 100644
--- a/extensions/extensions.json
+++ b/extensions/extensions.json
@@ -31,6 +31,7 @@
   "Lily/LooksPlus",
   "Lily/MoreEvents",
   "Lily/ListTools",
+  "midi/midi",
   "veggiecan/mobilekeyboard",
   "NexusKitten/moremotion",
   "CubesterYT/WindowControls",

From 774ba7686c2effed45ee817880113051783457a1 Mon Sep 17 00:00:00 2001
From: lselden <2904993+lselden@users.noreply.github.com>
Date: Fri, 18 Apr 2025 00:26:56 -0400
Subject: [PATCH 61/61] change "noteOn" to "note", add Duration/Instrument
 event props, bugfixes

---
 extensions/midi/midi.js | 151 ++++++++++++++++++++++------------------
 1 file changed, 83 insertions(+), 68 deletions(-)

diff --git a/extensions/midi/midi.js b/extensions/midi/midi.js
index 67bfde5b55..d056df544f 100644
--- a/extensions/midi/midi.js
+++ b/extensions/midi/midi.js
@@ -85,7 +85,7 @@
         ...midi.tracks.flatMap((track) => this._parseTrack(track, filter))
       );
 
-      const sortOrder = ["meta", "programChange", "noteOn"];
+      const sortOrder = ["meta", "programChange", "note"];
       return events.sort((a, b) => {
         // sort by timestamp
         let delta = a.time - b.time;
@@ -162,10 +162,10 @@
           });
         }
       }
-      if (filter === "ANY" || filter === "noteOn") {
+      if (filter === "ANY" || filter === "note") {
         events.push(
           ...track.notes.map((note) => ({
-            type: "noteOn",
+            type: "note",
             channel,
             pitch: note.name,
             time: roundToMillisecond(note.time),
@@ -181,7 +181,7 @@
         // @ts-ignore
         events.push(
           ...ccEvents.map((evt) => ({
-            type: /** @type {EventType} */("cc"),
+            type: /** @type {EventType} */ ("cc"),
             channel,
             cc: evt.number,
             time: roundToMillisecond(evt.time),
@@ -219,13 +219,13 @@
    *
    *
    * // definition for the parsed midi event
-   * @typedef {'noteOn' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset' | 'meta'} EventType
+   * @typedef {'note' | 'noteOff' | 'cc' | 'polyTouch' | 'programChange' | 'pitchBend' | 'channelPressure' | 'songPosition' | 'songSelect' | 'clock' | 'start' | 'continue' | 'stop' | 'activeSensing' | 'reset' | 'meta'} EventType
    *
    * @typedef {'timeSignature' | 'tempo' | 'keySignature' | 'text' | 'trackName' | 'instrument'} MetaKey
    *
    *
    * @typedef {object} MidiEvent
-   * @property {EventType | 'rest'} type type of midi command (note on, program change, tc). Default is 'noteOn'
+   * @property {EventType | 'rest'} type type of midi command (note on, program change, tc). Default is 'note'
    * @property {number} [value1] (0-127) raw data1 byte value
    * @property {number} [value2] (0-127) raw data2 byte value
    * @property {number} [channel] (1-16) channel of event. default is 1
@@ -271,7 +271,7 @@
    * adapted from https://github.com/fheyen/musicvis-lib/blob/905edbdc8280e8ca76a329ffc83a160f3cda674a/src/fileFormats/Midi.js#L41
    *
    * each key (the "EventType" relates to a raw midi "command". The "shorthand" could
-   * be used to format midi events to string (future). param1 and param2 determine what property of the object the value1 + value2 bytes mean (i.e. noteOn gets pitch + velocity, cc gets cc# and value)
+   * be used to format midi events to string (future). param1 and param2 determine what property of the object the value1 + value2 bytes mean (i.e. note gets pitch + velocity, cc gets cc# and value)
    */
   const SHARPS = "C C# D D# E F F# G G# A A# B".split(" ");
   const FLATS = "C Db D Eb E F Gb G Ab A Bb B".split(" ");
@@ -343,7 +343,7 @@
    * @type {Record<EventType, EventSpec>}
    */
   const eventMapping = {
-    noteOn: {
+    note: {
       shorthand: "note",
       command: 144,
       description: "Note-on",
@@ -531,13 +531,13 @@
    * @type {Record<EventType, (event: MidiEvent, opts: FormatOptions) => string>}
    */
   const formatters = {
-    noteOn(
-      { value1: note, value2: velocity = eventMapping.noteOn.defaults[1] },
+    note(
+      { value1: note, value2: velocity = eventMapping.note.defaults[1] },
       opts = {}
     ) {
       return formatNoteType(
-        // opts?.noMinify ? shorthands.noteOn : undefined,
-        shorthands.noteOn,
+        // opts?.noMinify ? shorthands.note : undefined,
+        shorthands.note,
         note,
         velocity,
         opts
@@ -601,6 +601,8 @@
    * @returns
    */
   function midiToString(event, opts = {}) {
+    if (!event) return "";
+    if (typeof event === "string") event = stringToMidi(event, opts);
     const { noMinify } = opts;
     const spec = eventMapping[event.type] ?? {};
     // ensure these are set properly
@@ -690,7 +692,7 @@
       ...(value2 != undefined && { value2 }),
       channel: parseNumValue(data.channel, opts),
       device: parseNumValue(data.device, opts),
-      ...(data.time && { time: parseTimespan(data.time) }),
+      ...(data.time && { time: parseNumValue(data.time, opts) }),
       ...(data.dur && { dur: parseFraction(data.dur) }),
       ...(data.pos && { pos: parseFraction(data.pos) }),
       ...(data.beats && { beats: parseFraction(data.beats) }),
@@ -707,7 +709,7 @@
 
     // default to note event if has pitch (off if velocity = 0)
     if (!event.type && value1 >= 0) {
-      event.type = "noteOn";
+      event.type = "note";
     } else if (!event.type) {
       // no type set, invalid input
       return null;
@@ -715,13 +717,13 @@
     const spec = eventMapping[event.type];
     let parsedHighRes = undefined;
     switch (event.type) {
-      case "noteOn":
+      case "note":
       case "noteOff":
         if (value1 == undefined) return null;
         if (value2 === 0) event.type = "noteOff";
         if (value2 == undefined) {
           event.value2 =
-            event.velocity ?? event.value ?? (event.type === "noteOn" ? 96 : 0);
+            event.velocity ?? event.value ?? (event.type === "note" ? 96 : 0);
         }
         break;
       case "polyTouch":
@@ -739,6 +741,9 @@
         if (value1 == undefined || value2 == undefined) return null;
         break;
       case "programChange":
+        if (data.instrument) event.instrument = data.instrument;
+        event.value1 ||= event.value ?? 0;
+        break;
       case "channelPressure":
       case "songSelect":
         // default to 0 for these types
@@ -926,27 +931,27 @@
     const parts = hoursOptional && h === 0 ? [m, s] : [h, m, s];
     return `${parts.map((p) => p.toFixed(0).padStart(2, "0")).join(":")}.${ms.toFixed().padEnd(3, "0")}`;
   }
-  /**
-   *
-   * @param {string} text
-   * @returns
-   */
-  function parseTimespan(text) {
-    if (!text) return 0;
-    // split into [hh]:mm:ss.000 parts
-    const parts = text.split(":");
-    // somewhat unnecessarily clever method to sum [hh][mm][ss]
-    // by incrementing the scale from [1, 60, 3600].
-    // goes right to left because hours and minutes are optional
-    const [value] = parts.reduceRight(
-      ([acc, scale], part) => {
-        const val = (parseFloat(part) || 0) * scale;
-        return [acc + val, scale * 60];
-      },
-      [0, 1]
-    );
-    return value;
-  }
+  // /**
+  //  *
+  //  * @param {string} text
+  //  * @returns
+  //  */
+  // function parseTimespan(text) {
+  //   if (!text || typeof text !== 'string') return +text || 0;
+  //   // split into [hh]:mm:ss.000 parts
+  //   const parts = text.split(":");
+  //   // somewhat unnecessarily clever method to sum [hh][mm][ss]
+  //   // by incrementing the scale from [1, 60, 3600].
+  //   // goes right to left because hours and minutes are optional
+  //   const [value] = parts.reduceRight(
+  //     ([acc, scale], part) => {
+  //       const val = (parseFloat(part) || 0) * scale;
+  //       return [acc + val, scale * 60];
+  //     },
+  //     [0, 1]
+  //   );
+  //   return value;
+  // }
   function parseFraction(text) {
     if (typeof text !== "string") {
       return +text || 0;
@@ -1071,7 +1076,7 @@
   // function isPitchedEvent(type) {
   //   return (
   //     !!type &&
-  //     (type === "noteOn" || type === "noteOff" || type === "polyTouch")
+  //     (type === "note" || type === "noteOff" || type === "polyTouch")
   //   );
   // }
 
@@ -1084,30 +1089,40 @@
 
   /**
    * Scratch menu items of @see {MidiEvent} properties
+   * @type {Record<string, { key: keyof MidiEvent, text: string, type?: EventType }>}
    */
-  const eventProps = {
-    type: { key: "type", text: Scratch.translate("Event Type") },
-    pitch: { key: "pitch", text: Scratch.translate("Note Pitch") },
+  const EVENT_PROPS = {
+    type: { key: "type", text: Scratch.translate("(type) Event Type") },
+    pitch: { key: "pitch", text: Scratch.translate("(pitch) Note Pitch") },
     velocity: {
       key: "velocity",
-      type: "noteOn",
+      type: "note",
       text: Scratch.translate("Velocity"),
     },
-    ccNumber: { key: "cc", text: Scratch.translate("Continuous Controller #") },
-    ccValue: { key: "value", type: "cc", text: Scratch.translate("CC Value") },
+    ccNumber: {
+      key: "cc",
+      text: Scratch.translate("(cc) Continuous Controller #"),
+    },
+    ccValue: {
+      key: "value",
+      type: "cc",
+      text: Scratch.translate("(value) CC Value"),
+    },
     channel: { key: "channel", text: Scratch.translate("Channel") },
     device: { key: "device", text: Scratch.translate("Device") },
     pitchbend: {
       key: "value",
       type: "pitchBend",
-      text: Scratch.translate("Pitch Bend"),
+      text: Scratch.translate("(value) Pitch Bend"),
     },
     aftertouch: {
       key: "value",
       type: "polyTouch",
-      text: Scratch.translate("Aftertouch"),
+      text: Scratch.translate("(polyTouch) Aftertouch"),
     },
-    time: { key: "time", text: Scratch.translate("Timestamp") },
+    time: { key: "time", text: Scratch.translate("(time) Timestamp") },
+    duration: { key: "dur", text: Scratch.translate("(dur) Duration") },
+    instrument: { key: "instrument", text: Scratch.translate("Instrument") },
   };
 
   //#endregion utils
@@ -1133,7 +1148,7 @@
       this._init = undefined;
       /** @type {MidiEvent} */
       this._defaultOutputEvent = {
-        type: "noteOn",
+        type: "note",
         channel: 1,
         device: 0,
         pitch: 60,
@@ -1255,7 +1270,7 @@
     ) {
       /** @type {MidiEvent} */
       let data;
-      // midi pitch = noteon now for 1/2 beat
+      // midi pitch = note now for 1/2 beat
       if (typeof event === "number") {
         data = {
           ...defaults,
@@ -1290,7 +1305,7 @@
         return false;
       }
       // ensure 0 velocity is interpreted as noteOff
-      if (data.type === "noteOn" && data.velocity === 0) {
+      if (data.type === "note" && data.velocity === 0) {
         data.type = "noteOff";
       }
 
@@ -1299,7 +1314,7 @@
       let raw = midiToRawMessage(data);
       device.send(raw, start);
       // also send off event
-      if (data.type === "noteOn" && end) {
+      if (data.type === "note" && end) {
         /** @type {MidiEvent} */
         const offEvent = {
           ...data,
@@ -1343,7 +1358,7 @@
     _trackActiveNotes(event, device) {
       // NOTE - same default channel as midiToRawEvent, maybe default should be a magic value?
       const { type, pitch, channel = 1 } = event;
-      if (!(type === "noteOn" || type === "noteOff")) {
+      if (!(type === "note" || type === "noteOff")) {
         return;
       }
       const key = `${channel}_${pitch}`;
@@ -1351,7 +1366,7 @@
         this._activeNotes.set(device, new Set());
       }
       const list = this._activeNotes.get(device);
-      if (type === "noteOn") {
+      if (type === "note") {
         list.add(key);
       } else {
         list.delete(key);
@@ -1448,7 +1463,7 @@
         this._prune(when);
       }
       switch (evt.type) {
-        case "noteOn":
+        case "note":
           this._onNoteOn(evt);
           break;
         case "noteOff":
@@ -1541,7 +1556,7 @@
       return this.getLast(undefined, undefined, channel);
     }
     getLastNote(pitch, channel) {
-      return this.getLast("noteOn", pitch, channel);
+      return this.getLast("note", pitch, channel);
     }
     getLastCC(cc, channel) {
       return this.getLast("cc", cc, channel);
@@ -1672,7 +1687,7 @@
     getInfo() {
       const EVENT_TYPES_ITEMS = [
         {
-          value: "noteOn",
+          value: "note",
           text: Scratch.translate("Note On"),
         },
         {
@@ -1864,7 +1879,7 @@
               TYPE: {
                 menu: "EVENT_TYPES",
                 type: Scratch.ArgumentType.STRING,
-                defaultValue: "noteOn",
+                defaultValue: "note",
               },
             },
           },
@@ -2091,7 +2106,7 @@
               TEXT: {
                 type: Scratch.ArgumentType.STRING,
                 defaultValue:
-                  '{"type":"noteOn","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}',
+                  '{"type":"note","channel":1,"device":0,"pos":0.25,"dur":0.25,"pitch":52,"velocity":96}',
               },
             },
           },
@@ -2212,7 +2227,7 @@
                 text: Scratch.translate("Note On/Off"),
               },
               {
-                value: "noteOn",
+                value: "note",
                 text: Scratch.translate("Note On"),
               },
               {
@@ -2264,7 +2279,7 @@
           },
           PROPS: {
             acceptReporters: true,
-            items: Object.entries(eventProps).map(([value, { text }]) => ({
+            items: Object.entries(EVENT_PROPS).map(([value, { text }]) => ({
               value,
               text,
             })),
@@ -2299,7 +2314,7 @@
                 text: Scratch.translate("all events"),
               },
               {
-                value: "noteOn",
+                value: "note",
                 text: Scratch.translate("all Notes"),
               },
               {
@@ -2366,7 +2381,7 @@
           setThreadMidiValue(thread, midiEvent);
         }
         switch (midiEvent.type) {
-          case "noteOn":
+          case "note":
           case "noteOff":
             vm.runtime.startHats(HATS.NOTE);
             vm.runtime.startHats(HATS.NOTEANY);
@@ -2474,7 +2489,7 @@
     whenNoteOnOff({ NOTE, PRESS }, util) {
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
-        ? ["noteOn", "noteOff"]
+        ? ["note", "noteOff"]
         : [normalizeType(Scratch.Cast.toString(PRESS))];
 
       const pitch = this._isAnyArg(NOTE)
@@ -2497,7 +2512,7 @@
     whenAnyNoteOnOff({ PRESS }, util) {
       const isAny = this._isAnyArg(PRESS);
       let type = isAny
-        ? ["noteOn", "noteOff"]
+        ? ["note", "noteOff"]
         : [normalizeType(Scratch.Cast.toString(PRESS))];
 
       const last = this.recorder.getLast();
@@ -2549,7 +2564,7 @@
     }
     getEventProp({ EVENT, PROP }, util) {
       const propName = Scratch.Cast.toString(PROP);
-      const { key = "value" } = eventProps[propName] ?? {};
+      const { key = "value" } = EVENT_PROPS[propName] ?? {};
       if (!EVENT) return "";
       const last = getThreadMidiValue(util.thread);
       // use cached thread value if available instead of re-parsing
@@ -2620,7 +2635,7 @@
       const device = this._getDeviceIndex(DEVICE, "output");
       /** @type {MidiEvent} */
       const event = {
-        type: "noteOn",
+        type: "note",
         pitch: this.noteForName({ NOTE }),
         velocity,
         channel: Scratch.Cast.toNumber(CHANNEL) || undefined,
@@ -2797,7 +2812,7 @@
       // normalize type and default to note if not otherwise specified
       let type =
         event.type === REST_LITERAL ? "rest" : normalizeType(event.type);
-      if (!type && event.pitch) type = "noteOn";
+      if (!type && event.pitch) type = "note";
       return event ? midiToString(event) : "";
     }
     /** MIDI FILE FUNCTIONS **/
@@ -2840,7 +2855,7 @@
         this._upsertList(
           Scratch.Cast.toString(LIST),
           // COMBAK no formatting options set
-          events.map((evt) => midiToString(evt)),
+          events.filter(Boolean).map((evt) => midiToString(evt)),
           util.target
         );
       }