pxt-core 7.5.8 → 7.5.9

package/built/pxt.js

@@ -113530,7 +113530,8 @@ var ts;
             "topblock",
             "callInDebugger",
             "duplicateShadowOnDrag",
-            "argsNullable"
+            "argsNullable",
+            "compileHiddenArguments"
         ];
         function parseCommentString(cmt) {
             let res = {
@@ -114448,6 +114449,125 @@ var pxt;
         skillmap.IndexedDBWorkspace = IndexedDBWorkspace;
     })(skillmap = pxt.skillmap || (pxt.skillmap = {}));
 })(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var assets;
+    (function (assets) {
+        function renderSoundPath(sound, width, height) {
+            const { startFrequency, endFrequency, startVolume, endVolume, wave, interpolation } = sound;
+            const scale = (start, end, percent) => {
+                return Math.pow(start, 1 - percent) * Math.pow(end, percent);
+            };
+            // To make the graph appear consistent with the implementation, use a seeded random for the noise waveform.
+            // The numbers are still nonsense but at least this reflects that it's deterministic.
+            const random = new SeededRandom(startFrequency + endFrequency + 1);
+            let getFrequencyAt;
+            switch (interpolation) {
+                case "linear":
+                    getFrequencyAt = x => startFrequency + x * (endFrequency - startFrequency) / width;
+                    break;
+                case "curve":
+                    getFrequencyAt = x => startFrequency + (endFrequency - startFrequency) * Math.sin(x / width * (Math.PI / 2));
+                    break;
+                case "logarithmic":
+                    getFrequencyAt = x => startFrequency + Math.log10(1 + 9 * (x / width)) * (endFrequency - startFrequency);
+                    break;
+            }
+            if (wave === "noise") {
+                getFrequencyAt = () => random.randomRange(500, 1000);
+            }
+            const getVolumeAt = (x) => ((endVolume - startVolume) / width) * x + startVolume;
+            const volumeToAmplitude = (volume) => (volume / 1023) * (height - 2) / 2;
+            const frequencyToWidth = (frequency) => Math.min(width, Math.max(10, (1 / scale(1, 4000, frequency / 4000)) * width / 2));
+            const parts = [`M ${2} ${height / 2}`];
+            let currentX = 0;
+            while (currentX < width) {
+                parts.push(renderHalfWavePart(volumeToAmplitude(getVolumeAt(currentX)), frequencyToWidth(getFrequencyAt(currentX)) / 2, wave, false, random));
+                currentX += frequencyToWidth(getFrequencyAt(currentX)) / 2;
+                parts.push(renderHalfWavePart(volumeToAmplitude(getVolumeAt(currentX)), frequencyToWidth(getFrequencyAt(currentX)) / 2, wave, true, random));
+                currentX += frequencyToWidth(getFrequencyAt(currentX)) / 2;
+            }
+            return parts.join(" ");
+        }
+        assets.renderSoundPath = renderSoundPath;
+        function renderWaveSnapshot(frequency, volume, wave, width, height, timeBase) {
+            // To make the graph appear consistent with the implementation, use a seeded random for the noise waveform.
+            // The numbers are still nonsense but at least this reflects that it's deterministic.
+            const random = new SeededRandom(frequency);
+            if (wave === "noise")
+                frequency = random.randomRange(500, 1000);
+            const amplitude = (volume / 1023) * (height - 2) / 2;
+            const waveHalfWidth = (width / (frequency * timeBase / 1000)) / 2;
+            let numSegments = Math.ceil(width / (waveHalfWidth * 2));
+            if (numSegments % 2 === 1)
+                numSegments++;
+            // Center the wave because it makes an animation look better. The overflow will be clipped
+            // by the outer svg
+            const parts = [`M ${(width / 2) - (numSegments * waveHalfWidth)} ${height / 2}`];
+            let currentX = 0;
+            for (let i = 0; i < numSegments; i++) {
+                parts.push(renderHalfWavePart(amplitude, waveHalfWidth, wave, false, random));
+                currentX += waveHalfWidth;
+                parts.push(renderHalfWavePart(amplitude, waveHalfWidth, wave, true, random));
+                currentX += waveHalfWidth;
+            }
+            return parts.join(" ");
+        }
+        assets.renderWaveSnapshot = renderWaveSnapshot;
+        class SeededRandom {
+            constructor(seed) {
+                this.seed = seed;
+                this.lfsr = seed;
+            }
+            next() {
+                const n = this.lfsr = (this.lfsr >> 1) ^ ((-(this.lfsr & 1)) & 0xb400);
+                return n / 0xffff;
+            }
+            randomRange(min, max) {
+                return min + (max - min) * this.next();
+            }
+        }
+        function renderHalfWavePart(amplitude, width, wave, flip, random) {
+            switch (wave) {
+                case "triangle":
+                    return `l ${width / 2} ${flip ? amplitude : -amplitude} l ${width / 2} ${flip ? -amplitude : amplitude}`;
+                case "square":
+                    return `v ${flip ? amplitude : -amplitude} h ${width} v ${flip ? -amplitude : amplitude}`;
+                case "sawtooth":
+                    if (flip) {
+                        return `l ${width} ${amplitude} v ${-amplitude}`;
+                    }
+                    else {
+                        return `v ${-amplitude} l ${width} ${amplitude}`;
+                    }
+                case "sine":
+                    return `q ${width / 2} ${(flip ? amplitude : -amplitude) * 1.9} ${width} 0`;
+                case "noise":
+                    const outParts = [];
+                    const points = [];
+                    const slice = Math.min(4, width / 4);
+                    let positive = flip;
+                    for (let x = 0; x < width; x += slice) {
+                        points.push(random.randomRange(0, amplitude) * (positive ? 1 : -1));
+                        positive = !positive;
+                    }
+                    points[0] = flip ? amplitude : -amplitude;
+                    points[points.length - 1] = 0;
+                    let offset = 0;
+                    let x = 0;
+                    for (const point of points) {
+                        let dx = Math.min(slice, width - x);
+                        outParts.push(`v ${point - offset} h ${dx}`);
+                        offset = point;
+                        x += dx;
+                        if (x >= width)
+                            break;
+                    }
+                    return outParts.join(" ");
+            }
+        }
+    })(assets = pxt.assets || (pxt.assets = {}));
+})(pxt || (pxt = {}));
 // See https://github.com/microsoft/TouchDevelop-backend/blob/master/docs/streams.md
 var pxt;
 (function (pxt) {
@@ -114855,6 +114975,10 @@ var pxt;
                 cb(this.d);
                 return this.update();
             }
+            setD(d) {
+                this.setAttribute("d", d);
+                return this;
+            }
         }
         svgUtil.Path = Path;
         class Image extends Drawable {
@@ -152823,7 +152947,7 @@ var pxsim;
             frame.id = 'sim-frame-' + this.nextId();
             frame.title = pxsim.localization.lf("Simulator");
             frame.allowFullscreen = true;
-            frame.setAttribute('allow', 'autoplay');
+            frame.setAttribute('allow', 'autoplay;microphone');
             frame.setAttribute('sandbox', 'allow-same-origin allow-scripts');
             frame.className = 'no-select';
             const furl = (url || this.getSimUrl()) + '#' + frame.id;
@@ -154379,6 +154503,882 @@ var pxsim;
     })(svg = pxsim.svg || (pxsim.svg = {}));
 })(pxsim || (pxsim = {}));
 var pxsim;
+(function (pxsim) {
+    var codal;
+    (function (codal) {
+        var music;
+        (function (music) {
+            var MusicalIntervals;
+            (function (MusicalIntervals) {
+                // #if CONFIG_ENABLED(JUST_SCALE)
+                // const float MusicalIntervals.chromaticInterval[] = [1.000000, 1.059463, 1.122462, 1.189207, 1.259921, 1.334840, 1.414214, 1.498307, 1.587401, 1.681793, 1.781797, 1.887749];
+                // #else
+                // const float MusicalIntervals.chromaticInterval[] = [1.000000, 1.0417, 1.1250, 1.2000, 1.2500, 1.3333, 1.4063, 1.5000, 1.6000, 1.6667, 1.8000, 1.8750];
+                // #endif
+                MusicalIntervals.chromaticInterval = [1.000000, 1.0417, 1.1250, 1.2000, 1.2500, 1.3333, 1.4063, 1.5000, 1.6000, 1.6667, 1.8000, 1.8750];
+                MusicalIntervals.majorScaleInterval = [MusicalIntervals.chromaticInterval[0], MusicalIntervals.chromaticInterval[2], MusicalIntervals.chromaticInterval[4], MusicalIntervals.chromaticInterval[5], MusicalIntervals.chromaticInterval[7], MusicalIntervals.chromaticInterval[9], MusicalIntervals.chromaticInterval[11]];
+                MusicalIntervals.minorScaleInterval = [MusicalIntervals.chromaticInterval[0], MusicalIntervals.chromaticInterval[2], MusicalIntervals.chromaticInterval[3], MusicalIntervals.chromaticInterval[5], MusicalIntervals.chromaticInterval[7], MusicalIntervals.chromaticInterval[8], MusicalIntervals.chromaticInterval[10]];
+                MusicalIntervals.pentatonicScaleInterval = [MusicalIntervals.chromaticInterval[0], MusicalIntervals.chromaticInterval[2], MusicalIntervals.chromaticInterval[4], MusicalIntervals.chromaticInterval[7], MusicalIntervals.chromaticInterval[9]];
+                MusicalIntervals.majorTriadInterval = [MusicalIntervals.chromaticInterval[0], MusicalIntervals.chromaticInterval[4], MusicalIntervals.chromaticInterval[7]];
+                MusicalIntervals.minorTriadInterval = [MusicalIntervals.chromaticInterval[0], MusicalIntervals.chromaticInterval[3], MusicalIntervals.chromaticInterval[7]];
+                MusicalIntervals.diminishedInterval = [MusicalIntervals.chromaticInterval[0], MusicalIntervals.chromaticInterval[3], MusicalIntervals.chromaticInterval[6], MusicalIntervals.chromaticInterval[9]];
+                MusicalIntervals.wholeToneInterval = [MusicalIntervals.chromaticInterval[0], MusicalIntervals.chromaticInterval[2], MusicalIntervals.chromaticInterval[4], MusicalIntervals.chromaticInterval[6], MusicalIntervals.chromaticInterval[8], MusicalIntervals.chromaticInterval[10]];
+            })(MusicalIntervals = music.MusicalIntervals || (music.MusicalIntervals = {}));
+        })(music = codal.music || (codal.music = {}));
+    })(codal = pxsim.codal || (pxsim.codal = {}));
+})(pxsim || (pxsim = {}));
+(function (pxsim) {
+    var codal;
+    (function (codal) {
+        var music;
+        (function (music) {
+            var MusicalProgressions;
+            (function (MusicalProgressions) {
+                MusicalProgressions.chromatic = { interval: music.MusicalIntervals.chromaticInterval, length: 12 };
+                MusicalProgressions.majorScale = { interval: music.MusicalIntervals.majorScaleInterval, length: 7 };
+                MusicalProgressions.minorScale = { interval: music.MusicalIntervals.minorScaleInterval, length: 7 };
+                MusicalProgressions.pentatonicScale = { interval: music.MusicalIntervals.pentatonicScaleInterval, length: 5 };
+                MusicalProgressions.majorTriad = { interval: music.MusicalIntervals.majorTriadInterval, length: 3 };
+                MusicalProgressions.minorTriad = { interval: music.MusicalIntervals.minorTriadInterval, length: 3 };
+                MusicalProgressions.diminished = { interval: music.MusicalIntervals.diminishedInterval, length: 4 };
+                MusicalProgressions.wholeTone = { interval: music.MusicalIntervals.wholeToneInterval, length: 6 };
+                /**
+                 * Determine the frequency of a given note in a given progressions
+                 *
+                 * @param root The root frequency of the progression
+                 * @param progression The Progression to use
+                 * @param offset The offset (interval) of the note to generate
+                 * @return The frequency of the note requested in Hz.
+                 */
+                function calculateFrequencyFromProgression(root, progression, offset) {
+                    let octave = Math.floor(offset / progression.length);
+                    let index = offset % progression.length;
+                    return root * Math.pow(2, octave) * progression.interval[index];
+                }
+                MusicalProgressions.calculateFrequencyFromProgression = calculateFrequencyFromProgression;
+            })(MusicalProgressions = music.MusicalProgressions || (music.MusicalProgressions = {}));
+        })(music = codal.music || (codal.music = {}));
+    })(codal = pxsim.codal || (pxsim.codal = {}));
+})(pxsim || (pxsim = {}));
+/**
+ * Adapted from lancaster-university/codal-microbit-v2
+ * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundEmojiSynthesizer.cpp
+ */
+var pxsim;
+(function (pxsim) {
+    var codal;
+    (function (codal) {
+        var music;
+        (function (music) {
+            // https://github.com/lancaster-university/codal-microbit-v2/blob/master/inc/SoundEmojiSynthesizer.h#L30
+            music.EMOJI_SYNTHESIZER_SAMPLE_RATE = 44100;
+            music.EMOJI_SYNTHESIZER_TONE_WIDTH_F = 1024;
+            music.EMOJI_SYNTHESIZER_TONE_WIDTH = 1024;
+            music.EMOJI_SYNTHESIZER_BUFFER_SIZE = 512;
+            music.EMOJI_SYNTHESIZER_TONE_EFFECT_PARAMETERS = 2;
+            music.EMOJI_SYNTHESIZER_TONE_EFFECTS = 3;
+            music.EMOJI_SYNTHESIZER_STATUS_ACTIVE = 0x1;
+            music.EMOJI_SYNTHESIZER_STATUS_OUTPUT_SILENCE_AS_EMPTY = 0x2;
+            music.EMOJI_SYNTHESIZER_STATUS_STOPPING = 0x4;
+            class SoundEmojiSynthesizer {
+                constructor(id, sampleRate = music.EMOJI_SYNTHESIZER_SAMPLE_RATE) {
+                    this.samplesPerStep = [];
+                    this.status = 0;
+                    this.effectPointer = 0;
+                    this.position = 0;
+                    this.bufferSize = music.EMOJI_SYNTHESIZER_BUFFER_SIZE;
+                    this.sampleRate = sampleRate;
+                    this.samplesToWrite = 0;
+                    this.samplesWritten = 0;
+                    this.sampleRange = 1023;
+                    this.orMask = 0;
+                    this.effectPointer = -1;
+                    this.volume = 1;
+                }
+                get effect() {
+                    return this.effectBuffer[this.effectPointer];
+                }
+                play(sound) {
+                    this.effectBuffer = sound;
+                    this.effectPointer = -1;
+                    this.nextSoundEffect();
+                }
+                nextSoundEffect() {
+                    const hadEffect = this.effect != null;
+                    if (this.status & music.EMOJI_SYNTHESIZER_STATUS_STOPPING) {
+                        this.effectPointer = null;
+                        this.effectBuffer = [];
+                    }
+                    // If a sequence of SoundEffects are being played, attempt to move on to the next.
+                    // If not, select the first in the buffer.
+                    if (this.effect)
+                        this.effectPointer++;
+                    else
+                        this.effectPointer = 0;
+                    // Validate that we have a valid sound effect. If not, record that we have nothing to play.
+                    if (this.effectPointer >= this.effectBuffer.length) {
+                        // if we have an effect with a negative duration, reset the buffer (unless there is an update pending)
+                        this.effectPointer = 0;
+                        if (this.effect.duration >= 0) {
+                            this.effectPointer = -1;
+                            this.effectBuffer = [];
+                            this.samplesWritten = 0;
+                            this.samplesToWrite = 0;
+                            this.position = 0;
+                            return hadEffect;
+                        }
+                    }
+                    // We have a valid buffer. Set up our synthesizer to the requested parameters.
+                    this.samplesToWrite = this.determineSampleCount(this.effect.duration);
+                    this.frequency = this.effect.frequency;
+                    this.volume = this.effect.volume;
+                    this.samplesWritten = 0;
+                    // validate and initialise per effect rendering state.
+                    for (let i = 0; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++) {
+                        this.effect.effects[i].step = 0;
+                        this.effect.effects[i].steps = Math.max(this.effect.effects[i].steps, 1);
+                        this.samplesPerStep[i] = Math.floor(this.samplesToWrite / this.effect.effects[i].steps);
+                    }
+                    return false;
+                }
+                pull() {
+                    let done = false;
+                    let sample;
+                    let bufferEnd;
+                    while (!done) {
+                        if (this.samplesWritten == this.samplesToWrite || this.status & music.EMOJI_SYNTHESIZER_STATUS_STOPPING) {
+                            let renderComplete = this.nextSoundEffect();
+                            // If we have just completed active playout of an effect, and there are no more effects scheduled,
+                            // unblock any fibers that may be waiting to play a sound effect.
+                            if (this.samplesToWrite == 0 || this.status & music.EMOJI_SYNTHESIZER_STATUS_STOPPING) {
+                                done = true;
+                                if (renderComplete || this.status & music.EMOJI_SYNTHESIZER_STATUS_STOPPING) {
+                                    this.status &= ~music.EMOJI_SYNTHESIZER_STATUS_STOPPING;
+                                    // Event(id, DEVICE_SOUND_EMOJI_SYNTHESIZER_EVT_DONE);
+                                    // lock.notify();
+                                }
+                            }
+                        }
+                        // If we have something to do, ensure our buffers are created.
+                        // We defer creation to avoid unnecessary heap allocation when generating silence.
+                        if (((this.samplesWritten < this.samplesToWrite) || !(this.status & music.EMOJI_SYNTHESIZER_STATUS_OUTPUT_SILENCE_AS_EMPTY)) && sample == null) {
+                            this.buffer = new Array(this.bufferSize);
+                            sample = 0;
+                            bufferEnd = this.buffer.length;
+                        }
+                        // Generate some samples with the current this.effect parameters.
+                        while (this.samplesWritten < this.samplesToWrite) {
+                            let skip = ((music.EMOJI_SYNTHESIZER_TONE_WIDTH_F * this.frequency) / this.sampleRate);
+                            let gain = (this.sampleRange * this.volume) / 1024;
+                            let offset = 512 - (512 * gain);
+                            let effectStepEnd = [];
+                            for (let i = 0; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++) {
+                                effectStepEnd[i] = (this.samplesPerStep[i] * (this.effect.effects[i].step));
+                                if (this.effect.effects[i].step == this.effect.effects[i].steps - 1)
+                                    effectStepEnd[i] = this.samplesToWrite;
+                            }
+                            let stepEndPosition = effectStepEnd[0];
+                            for (let i = 1; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++)
+                                stepEndPosition = Math.min(stepEndPosition, effectStepEnd[i]);
+                            // Write samples until the end of the next this.effect-step
+                            while (this.samplesWritten < stepEndPosition) {
+                                // Stop processing when we've filled the requested this.buffer
+                                if (sample == bufferEnd) {
+                                    // downStream.pullRequest();
+                                    return this.buffer;
+                                }
+                                // Synthesize a sample
+                                let s = this.effect.tone.tonePrint(this.effect.tone.parameter, this.position);
+                                // Apply volume scaling and OR mask (if specified).
+                                this.buffer[sample] = (((s * gain) + offset)); // | this.orMask;
+                                // Move on our pointers.
+                                sample++;
+                                this.samplesWritten++;
+                                this.position += skip;
+                                // Keep our toneprint pointer in range
+                                while (this.position > music.EMOJI_SYNTHESIZER_TONE_WIDTH_F)
+                                    this.position -= music.EMOJI_SYNTHESIZER_TONE_WIDTH_F;
+                            }
+                            // Invoke the this.effect function for any effects that are due.
+                            for (let i = 0; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++) {
+                                if (this.samplesWritten == effectStepEnd[i]) {
+                                    if (this.effect.effects[i].step < this.effect.effects[i].steps) {
+                                        if (this.effect.effects[i].effect)
+                                            this.effect.effects[i].effect(this, this.effect.effects[i]);
+                                        this.effect.effects[i].step++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // if we have no data to send, return an empty this.buffer (if requested)
+                    if (sample == null) {
+                        this.buffer = [];
+                    }
+                    else {
+                        // Pad the output this.buffer with silence if necessary.
+                        const silence = (this.sampleRange * 0.5); // | this.orMask;
+                        while (sample < bufferEnd) {
+                            this.buffer[sample] = silence;
+                            sample++;
+                        }
+                    }
+                    // Issue a Pull Request so that we are always receiver driven, and we're done.
+                    // downStream.pullRequest();
+                    return this.buffer;
+                }
+                determineSampleCount(playoutTime) {
+                    if (playoutTime < 0)
+                        playoutTime = -playoutTime;
+                    const seconds = playoutTime / 1000;
+                    return Math.floor(this.sampleRate * seconds);
+                }
+                totalDuration() {
+                    let duration = 0;
+                    for (const effect of this.effectBuffer)
+                        duration += effect.duration;
+                    return duration;
+                }
+            }
+            music.SoundEmojiSynthesizer = SoundEmojiSynthesizer;
+        })(music = codal.music || (codal.music = {}));
+    })(codal = pxsim.codal || (pxsim.codal = {}));
+})(pxsim || (pxsim = {}));
+/**
+ * Adapted from lancaster-university/codal-core
+ * https://github.com/lancaster-university/codal-core/blob/master/source/streams/Synthesizer.cpp#L54
+ */
+var pxsim;
+(function (pxsim) {
+    var codal;
+    (function (codal) {
+        var music;
+        (function (music) {
+            var Synthesizer;
+            (function (Synthesizer) {
+                const sineTone = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 11, 12, 13, 13, 14, 15, 16, 16, 17, 18, 19, 20, 21, 22, 22, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 38, 40, 41, 42, 43, 45, 46, 47, 49, 50, 51, 53, 54, 56, 57, 58, 60, 61, 63, 64, 66, 68, 69, 71, 72, 74, 76, 77, 79, 81, 82, 84, 86, 87, 89, 91, 93, 95, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 141, 143, 145, 147, 149, 152, 154, 156, 158, 161, 163, 165, 167, 170, 172, 175, 177, 179, 182, 184, 187, 189, 191, 194, 196, 199, 201, 204, 206, 209, 211, 214, 216, 219, 222, 224, 227, 229, 232, 235, 237, 240, 243, 245, 248, 251, 253, 256, 259, 262, 264, 267, 270, 273, 275, 278, 281, 284, 287, 289, 292, 295, 298, 301, 304, 307, 309, 312, 315, 318, 321, 324, 327, 330, 333, 336, 339, 342, 345, 348, 351, 354, 357, 360, 363, 366, 369, 372, 375, 378, 381, 384, 387, 390, 393, 396, 399, 402, 405, 408, 411, 414, 417, 420, 424, 427, 430, 433, 436, 439, 442, 445, 448, 452, 455, 458, 461, 464, 467, 470, 473, 477, 480, 483, 486, 489, 492, 495, 498, 502, 505, 508, 511, 514, 517, 520, 524, 527, 530, 533, 536, 539, 542, 545, 549, 552, 555, 558, 561, 564, 567, 570, 574, 577, 580, 583, 586, 589, 592, 595, 598, 602, 605, 608, 611, 614, 617, 620, 623, 626, 629, 632, 635, 638, 641, 644, 647, 650, 653, 656, 659, 662, 665, 668, 671, 674, 677, 680, 683, 686, 689, 692, 695, 698, 701, 704, 707, 710, 713, 715, 718, 721, 724, 727, 730, 733, 735, 738, 741, 744, 747, 749, 752, 755, 758, 760, 763, 766, 769, 771, 774, 777, 779, 782, 785, 787, 790, 793, 795, 798, 800, 803, 806, 808, 811, 813, 816, 818, 821, 823, 826, 828, 831, 833, 835, 838, 840, 843, 845, 847, 850, 852, 855, 857, 859, 861, 864, 866, 868, 870, 873, 875, 877, 879, 881, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 927, 929, 931, 933, 935, 936, 938, 940, 941, 943, 945, 946, 948, 950, 951, 953, 954, 956, 958, 959, 961, 962, 964, 965, 966, 968, 969, 971, 972, 973, 975, 976, 977, 979, 980, 981, 982, 984, 985, 986, 987, 988, 989, 990, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1006, 1007, 1008, 1009, 1009, 1010, 1011, 1011, 1012, 1013, 1013, 1014, 1014, 1015, 1015, 1016, 1016, 1017, 1017, 1018, 1018, 1019, 1019, 1019, 1020, 1020, 1020, 1021, 1021, 1021, 1021, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1023, 1022];
+                const TONE_WIDTH = 1024;
+                function SineTone(arg, position) {
+                    position |= 0;
+                    let off = TONE_WIDTH - position;
+                    if (off < TONE_WIDTH / 2)
+                        position = off;
+                    return sineTone[position];
+                }
+                Synthesizer.SineTone = SineTone;
+                function SawtoothTone(arg, position) {
+                    return position;
+                }
+                Synthesizer.SawtoothTone = SawtoothTone;
+                function TriangleTone(arg, position) {
+                    return position < 512 ? position * 2 : (1023 - position) * 2;
+                }
+                Synthesizer.TriangleTone = TriangleTone;
+                function NoiseTone(arg, position) {
+                    // deterministic, semi-random noise
+                    let mult = arg[0];
+                    if (mult == 0)
+                        mult = 7919;
+                    return (position * mult) & 1023;
+                }
+                Synthesizer.NoiseTone = NoiseTone;
+                function SquareWaveTone(arg, position) {
+                    return position < 512 ? 1023 : 0;
+                }
+                Synthesizer.SquareWaveTone = SquareWaveTone;
+            })(Synthesizer = music.Synthesizer || (music.Synthesizer = {}));
+        })(music = codal.music || (codal.music = {}));
+    })(codal = pxsim.codal || (pxsim.codal = {}));
+})(pxsim || (pxsim = {}));
+/**
+ * Adapted from lancaster-university/codal-microbit-v2
+ * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundSynthesizerEffects.cpp
+ */
+var pxsim;
+(function (pxsim) {
+    var codal;
+    (function (codal) {
+        var music;
+        (function (music) {
+            var SoundSynthesizerEffects;
+            (function (SoundSynthesizerEffects) {
+                /*
+                 * Definitions of standard progressions.
+                 */
+                /**
+                 * Root Frequency Interpolation Effect Functions
+                 */
+                function noInterpolation(synth, context) {
+                }
+                SoundSynthesizerEffects.noInterpolation = noInterpolation;
+                // Linear interpolate function.
+                // parameter[0]: end frequency
+                function linearInterpolation(synth, context) {
+                    let interval = (context.parameter[0] - synth.effect.frequency) / context.steps;
+                    synth.frequency = synth.effect.frequency + interval * context.step;
+                }
+                SoundSynthesizerEffects.linearInterpolation = linearInterpolation;
+                // Linear interpolate function.
+                // parameter[0]: end frequency
+                function logarithmicInterpolation(synth, context) {
+                    synth.frequency = synth.effect.frequency + (Math.log10(Math.max(context.step, 0.1)) * (context.parameter[0] - synth.effect.frequency) / 1.95);
+                }
+                SoundSynthesizerEffects.logarithmicInterpolation = logarithmicInterpolation;
+                // Curve interpolate function
+                // parameter[0]: end frequency
+                function curveInterpolation(synth, context) {
+                    synth.frequency = (Math.sin(context.step * 3.12159 / 180.0) * (context.parameter[0] - synth.effect.frequency) + synth.effect.frequency);
+                }
+                SoundSynthesizerEffects.curveInterpolation = curveInterpolation;
+                // Cosine interpolate function
+                // parameter[0]: end frequency
+                function slowVibratoInterpolation(synth, context) {
+                    synth.frequency = Math.sin(context.step / 10) * context.parameter[0] + synth.effect.frequency;
+                }
+                SoundSynthesizerEffects.slowVibratoInterpolation = slowVibratoInterpolation;
+                //warble function
+                // parameter[0]: end frequency
+                function warbleInterpolation(synth, context) {
+                    synth.frequency = (Math.sin(context.step) * (context.parameter[0] - synth.effect.frequency) + synth.effect.frequency);
+                }
+                SoundSynthesizerEffects.warbleInterpolation = warbleInterpolation;
+                // Vibrato function
+                // parameter[0]: end frequency
+                function vibratoInterpolation(synth, context) {
+                    synth.frequency = synth.effect.frequency + Math.sin(context.step) * context.parameter[0];
+                }
+                SoundSynthesizerEffects.vibratoInterpolation = vibratoInterpolation;
+                // Exponential rising function
+                // parameter[0]: end frequency
+                function exponentialRisingInterpolation(synth, context) {
+                    synth.frequency = synth.effect.frequency + Math.sin(0.01745329 * context.step) * context.parameter[0];
+                }
+                SoundSynthesizerEffects.exponentialRisingInterpolation = exponentialRisingInterpolation;
+                // Exponential falling function
+                function exponentialFallingInterpolation(synth, context) {
+                    synth.frequency = synth.effect.frequency + Math.cos(0.01745329 * context.step) * context.parameter[0];
+                }
+                SoundSynthesizerEffects.exponentialFallingInterpolation = exponentialFallingInterpolation;
+                // Argeppio functions
+                function appregrioAscending(synth, context) {
+                    synth.frequency = music.MusicalProgressions.calculateFrequencyFromProgression(synth.effect.frequency, context.parameter_p[0], context.step);
+                }
+                SoundSynthesizerEffects.appregrioAscending = appregrioAscending;
+                function appregrioDescending(synth, context) {
+                    synth.frequency = music.MusicalProgressions.calculateFrequencyFromProgression(synth.effect.frequency, context.parameter_p[0], context.steps - context.step - 1);
+                }
+                SoundSynthesizerEffects.appregrioDescending = appregrioDescending;
+                /**
+                 * Frequency Delta effects
+                 */
+                // Frequency vibrato function
+                // parameter[0]: vibrato frequency multiplier
+                function frequencyVibratoEffect(synth, context) {
+                    if (context.step == 0)
+                        return;
+                    if (context.step % 2 == 0)
+                        synth.frequency /= context.parameter[0];
+                    else
+                        synth.frequency *= context.parameter[0];
+                }
+                SoundSynthesizerEffects.frequencyVibratoEffect = frequencyVibratoEffect;
+                // Volume vibrato function
+                // parameter[0]: vibrato volume multiplier
+                function volumeVibratoEffect(synth, context) {
+                    if (context.step == 0)
+                        return;
+                    if (context.step % 2 == 0)
+                        synth.volume /= context.parameter[0];
+                    else
+                        synth.volume *= context.parameter[0];
+                }
+                SoundSynthesizerEffects.volumeVibratoEffect = volumeVibratoEffect;
+                /**
+                 * Volume Delta effects
+                 */
+                /** Simple ADSR enveleope effect.
+                 * parameter[0]: Centre volume
+                 * parameter[1]: End volume
+                 * effect.volume: start volume
+                 */
+                function adsrVolumeEffect(synth, context) {
+                    let halfSteps = context.steps * 0.5;
+                    if (context.step <= halfSteps) {
+                        let delta = (context.parameter[0] - synth.effect.volume) / halfSteps;
+                        synth.volume = synth.effect.volume + context.step * delta;
+                    }
+                    else {
+                        let delta = (context.parameter[1] - context.parameter[0]) / halfSteps;
+                        synth.volume = context.parameter[0] + (context.step - halfSteps) * delta;
+                    }
+                }
+                SoundSynthesizerEffects.adsrVolumeEffect = adsrVolumeEffect;
+                /**
+                 * Simple volume ramp effect
+                 * parameter[0]: End volume
+                 * effect.volume: start volume
+                 */
+                function volumeRampEffect(synth, context) {
+                    let delta = (context.parameter[0] - synth.effect.volume) / context.steps;
+                    synth.volume = synth.effect.volume + context.step * delta;
+                }
+                SoundSynthesizerEffects.volumeRampEffect = volumeRampEffect;
+            })(SoundSynthesizerEffects = music.SoundSynthesizerEffects || (music.SoundSynthesizerEffects = {}));
+        })(music = codal.music || (codal.music = {}));
+    })(codal = pxsim.codal || (pxsim.codal = {}));
+})(pxsim || (pxsim = {}));
+var pxsim;
+(function (pxsim) {
+    var codal;
+    (function (codal) {
+        var music;
+        (function (music) {
+            let WaveShape;
+            (function (WaveShape) {
+                WaveShape[WaveShape["Sine"] = 0] = "Sine";
+                WaveShape[WaveShape["Sawtooth"] = 1] = "Sawtooth";
+                WaveShape[WaveShape["Triangle"] = 2] = "Triangle";
+                WaveShape[WaveShape["Square"] = 3] = "Square";
+                WaveShape[WaveShape["Noise"] = 4] = "Noise";
+            })(WaveShape = music.WaveShape || (music.WaveShape = {}));
+            let InterpolationEffect;
+            (function (InterpolationEffect) {
+                InterpolationEffect[InterpolationEffect["None"] = 0] = "None";
+                InterpolationEffect[InterpolationEffect["Linear"] = 1] = "Linear";
+                InterpolationEffect[InterpolationEffect["Curve"] = 2] = "Curve";
+                InterpolationEffect[InterpolationEffect["ExponentialRising"] = 5] = "ExponentialRising";
+                InterpolationEffect[InterpolationEffect["ExponentialFalling"] = 6] = "ExponentialFalling";
+                InterpolationEffect[InterpolationEffect["ArpeggioRisingMajor"] = 8] = "ArpeggioRisingMajor";
+                InterpolationEffect[InterpolationEffect["ArpeggioRisingMinor"] = 10] = "ArpeggioRisingMinor";
+                InterpolationEffect[InterpolationEffect["ArpeggioRisingDiminished"] = 12] = "ArpeggioRisingDiminished";
+                InterpolationEffect[InterpolationEffect["ArpeggioRisingChromatic"] = 14] = "ArpeggioRisingChromatic";
+                InterpolationEffect[InterpolationEffect["ArpeggioRisingWholeTone"] = 16] = "ArpeggioRisingWholeTone";
+                InterpolationEffect[InterpolationEffect["ArpeggioFallingMajor"] = 9] = "ArpeggioFallingMajor";
+                InterpolationEffect[InterpolationEffect["ArpeggioFallingMinor"] = 11] = "ArpeggioFallingMinor";
+                InterpolationEffect[InterpolationEffect["ArpeggioFallingDiminished"] = 13] = "ArpeggioFallingDiminished";
+                InterpolationEffect[InterpolationEffect["ArpeggioFallingChromatic"] = 15] = "ArpeggioFallingChromatic";
+                InterpolationEffect[InterpolationEffect["ArpeggioFallingWholeTone"] = 17] = "ArpeggioFallingWholeTone";
+                InterpolationEffect[InterpolationEffect["Logarithmic"] = 18] = "Logarithmic";
+            })(InterpolationEffect = music.InterpolationEffect || (music.InterpolationEffect = {}));
+            let Effect;
+            (function (Effect) {
+                Effect[Effect["None"] = 0] = "None";
+                Effect[Effect["Vibrato"] = 1] = "Vibrato";
+                Effect[Effect["Tremolo"] = 2] = "Tremolo";
+                Effect[Effect["Warble"] = 3] = "Warble";
+            })(Effect = music.Effect || (music.Effect = {}));
+            class Sound {
+                constructor() {
+                    this.src = "000000000000000000000000000000000000000000000000000000000000000000000000";
+                }
+                get wave() {
+                    return this.getValue(0, 1);
+                }
+                set wave(value) {
+                    this.setValue(0, constrain(value, 0, 4), 1);
+                }
+                get volume() {
+                    return this.getValue(1, 4);
+                }
+                set volume(value) {
+                    this.setValue(1, constrain(value, 0, 1023), 4);
+                }
+                get frequency() {
+                    return this.getValue(5, 4);
+                }
+                set frequency(value) {
+                    this.setValue(5, value, 4);
+                }
+                get duration() {
+                    return this.getValue(9, 4);
+                }
+                set duration(value) {
+                    this.setValue(9, value, 4);
+                }
+                get shape() {
+                    return this.getValue(13, 2);
+                }
+                set shape(value) {
+                    this.setValue(13, value, 2);
+                }
+                get endFrequency() {
+                    return this.getValue(18, 4);
+                }
+                set endFrequency(value) {
+                    this.setValue(18, value, 4);
+                }
+                get endVolume() {
+                    return this.getValue(26, 4);
+                }
+                set endVolume(value) {
+                    this.setValue(26, constrain(value, 0, 1023), 4);
+                }
+                get steps() {
+                    return this.getValue(30, 4);
+                }
+                set steps(value) {
+                    this.setValue(30, value, 4);
+                }
+                get fx() {
+                    return this.getValue(34, 2);
+                }
+                set fx(value) {
+                    this.setValue(34, constrain(value, 0, 3), 2);
+                }
+                get fxParam() {
+                    return this.getValue(36, 4);
+                }
+                set fxParam(value) {
+                    this.setValue(36, value, 4);
+                }
+                get fxnSteps() {
+                    return this.getValue(40, 4);
+                }
+                set fxnSteps(value) {
+                    this.setValue(40, value, 4);
+                }
+                get frequencyRandomness() {
+                    return this.getValue(44, 4);
+                }
+                set frequencyRandomness(value) {
+                    this.setValue(44, value, 4);
+                }
+                get endFrequencyRandomness() {
+                    return this.getValue(48, 4);
+                }
+                set endFrequencyRandomness(value) {
+                    this.setValue(48, value, 4);
+                }
+                get volumeRandomness() {
+                    return this.getValue(52, 4);
+                }
+                set volumeRandomness(value) {
+                    this.setValue(52, value, 4);
+                }
+                get endVolumeRandomness() {
+                    return this.getValue(56, 4);
+                }
+                set endVolumeRandomness(value) {
+                    this.setValue(56, value, 4);
+                }
+                get durationRandomness() {
+                    return this.getValue(60, 4);
+                }
+                set durationRandomness(value) {
+                    this.setValue(60, value, 4);
+                }
+                get fxParamRandomness() {
+                    return this.getValue(64, 4);
+                }
+                set fxParamRandomness(value) {
+                    this.setValue(64, value, 4);
+                }
+                get fxnStepsRandomness() {
+                    return this.getValue(68, 4);
+                }
+                set fxnStepsRandomness(value) {
+                    this.setValue(68, value, 4);
+                }
+                copy() {
+                    const result = new Sound();
+                    result.src = this.src.slice(0);
+                    return result;
+                }
+                setValue(offset, value, length) {
+                    value = constrain(value | 0, 0, Math.pow(10, length) - 1);
+                    this.src = this.src.substr(0, offset) + formatNumber(value, length) + this.src.substr(offset + length);
+                }
+                getValue(offset, length) {
+                    return parseInt(this.src.substr(offset, length));
+                }
+            }
+            music.Sound = Sound;
+            function formatNumber(num, length) {
+                let result = num + "";
+                while (result.length < length)
+                    result = "0" + result;
+                return result;
+            }
+            let soundPromise;
+            function __playSoundExpression(notes, waitTillDone) {
+                const cb = pxsim.getResume();
+                if (!soundPromise)
+                    soundPromise = Promise.resolve();
+                soundPromise = soundPromise.then(() => playSoundExpressionAsync(notes));
+                if (!waitTillDone)
+                    cb();
+                else
+                    soundPromise = soundPromise.then(cb);
+            }
+            music.__playSoundExpression = __playSoundExpression;
+            function playSoundExpressionAsync(notes, isCancelled, onPull) {
+                const synth = new music.SoundEmojiSynthesizer(0);
+                const soundEffects = parseSoundEffects(notes);
+                synth.play(soundEffects);
+                let cancelled = false;
+                return Promise.race([
+                    delayAsync(synth.totalDuration())
+                        .then(() => {
+                        // If safari didn't allow the sound to play for some reason,
+                        // it will get delayed until the user does something that
+                        // unmutes it. make sure we cancel it so that it doesn't
+                        // play long after it was supposed to
+                        cancelled = true;
+                    }),
+                    pxsim.AudioContextManager.playPCMBufferStreamAsync(() => {
+                        if (!synth.effect)
+                            return undefined;
+                        const buff = synth.pull();
+                        if (onPull)
+                            onPull(synth.frequency, synth.volume);
+                        const arr = new Float32Array(buff.length);
+                        for (let i = 0; i < buff.length; i++) {
+                            // Buffer is (0, 1023) we need to map it to (-1, 1)
+                            arr[i] = ((buff[i] - 512) / 512);
+                        }
+                        return arr;
+                    }, synth.sampleRate, 0.03, () => cancelled || (isCancelled && isCancelled()))
+                ]);
+            }
+            music.playSoundExpressionAsync = playSoundExpressionAsync;
+            function __stopSoundExpressions() {
+                pxsim.AudioContextManager.stopAll();
+            }
+            music.__stopSoundExpressions = __stopSoundExpressions;
+            /**
+             * Adapted from lancaster-university/codal-microbit-v2
+             * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundExpressions.cpp
+             */
+            function parseSoundEffects(notes) {
+                // https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundExpressions.cpp#L57
+                // 72 characters of sound data comma separated
+                const charsPerEffect = 72;
+                const effectCount = Math.floor((notes.length + 1) / (charsPerEffect + 1));
+                const expectedLength = effectCount * (charsPerEffect + 1) - 1;
+                if (notes.length != expectedLength) {
+                    return [];
+                }
+                const soundEffects = [];
+                for (let i = 0; i < effectCount; ++i) {
+                    const start = i * charsPerEffect + i;
+                    if (start > 0 && notes[start - 1] != ',') {
+                        return [];
+                    }
+                    const effect = blankSoundEffect();
+                    if (!parseSoundExpression(notes.substr(start), effect)) {
+                        return [];
+                    }
+                    soundEffects.push(effect);
+                }
+                return soundEffects;
+            }
+            function parseSoundExpression(soundChars, fx) {
+                // https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundExpressions.cpp#L115
+                // Encoded as a sequence of zero padded decimal strings.
+                // This encoding is worth reconsidering if we can!
+                // The ADSR effect (and perhaps others in future) has two parameters which cannot be expressed.
+                // 72 chars total
+                //  [0] 0-4 wave
+                let wave = parseInt(soundChars.substr(0, 1));
+                //  [1] 0000-1023 volume
+                let effectVolume = parseInt(soundChars.substr(1, 4));
+                //  [5] 0000-9999 frequency
+                let frequency = parseInt(soundChars.substr(5, 4));
+                //  [9] 0000-9999 duration
+                let duration = parseInt(soundChars.substr(9, 4));
+                // [13] 00 shape (specific known values)
+                let shape = parseInt(soundChars.substr(13, 2));
+                // [15] XXX unused/bug. This was startFrequency but we use frequency above.
+                // [18] 0000-9999 end frequency
+                let endFrequency = parseInt(soundChars.substr(18, 4));
+                // [22] XXXX unused. This was start volume but we use volume above.
+                // [26] 0000-1023 end volume
+                let endVolume = parseInt(soundChars.substr(26, 4));
+                // [30] 0000-9999 steps
+                let steps = parseInt(soundChars.substr(30, 4));
+                // [34] 00-03 fx choice
+                let fxChoice = parseInt(soundChars.substr(34, 2));
+                // [36] 0000-9999 fxParam
+                let fxParam = parseInt(soundChars.substr(36, 4));
+                // [40] 0000-9999 fxnSteps
+                let fxnSteps = parseInt(soundChars.substr(40, 4));
+                // Details that encoded randomness to be applied when frame is used:
+                // Can the randomness cause any parameters to go out of range?
+                // [44] 0000-9999 frequency random
+                frequency = applyRandom(frequency, parseInt(soundChars.substr(44, 4)));
+                // [48] 0000-9999 end frequency random
+                endFrequency = applyRandom(endFrequency, parseInt(soundChars.substr(48, 4)));
+                // [52] 0000-9999 volume random
+                effectVolume = applyRandom(effectVolume, parseInt(soundChars.substr(52, 4)));
+                // [56] 0000-9999 end volume random
+                endVolume = applyRandom(endVolume, parseInt(soundChars.substr(56, 4)));
+                // [60] 0000-9999 duration random
+                duration = applyRandom(duration, parseInt(soundChars.substr(60, 4)));
+                // [64] 0000-9999 fxParamRandom
+                fxParam = applyRandom(fxParam, parseInt(soundChars.substr(64, 4)));
+                // [68] 0000-9999 fxnStepsRandom
+                fxnSteps = applyRandom(fxnSteps, parseInt(soundChars.substr(68, 4)));
+                if (frequency == -1 || endFrequency == -1 || effectVolume == -1 || endVolume == -1 || duration == -1 || fxParam == -1 || fxnSteps == -1) {
+                    return false;
+                }
+                let volumeScaleFactor = 1;
+                switch (wave) {
+                    case 0:
+                        fx.tone.tonePrint = music.Synthesizer.SineTone;
+                        break;
+                    case 1:
+                        fx.tone.tonePrint = music.Synthesizer.SawtoothTone;
+                        break;
+                    case 2:
+                        fx.tone.tonePrint = music.Synthesizer.TriangleTone;
+                        break;
+                    case 3:
+                        fx.tone.tonePrint = music.Synthesizer.SquareWaveTone;
+                        break;
+                    case 4:
+                        fx.tone.tonePrint = music.Synthesizer.NoiseTone;
+                        break;
+                }
+                fx.frequency = frequency;
+                fx.duration = duration;
+                fx.effects[0].steps = steps;
+                switch (shape) {
+                    case 0:
+                        fx.effects[0].effect = music.SoundSynthesizerEffects.noInterpolation;
+                        break;
+                    case 1:
+                        fx.effects[0].effect = music.SoundSynthesizerEffects.linearInterpolation;
+                        fx.effects[0].parameter[0] = endFrequency;
+                        break;
+                    case 2:
+                        fx.effects[0].effect = music.SoundSynthesizerEffects.curveInterpolation;
+                        fx.effects[0].parameter[0] = endFrequency;
+                        break;
+                    case 5:
+                        fx.effects[0].effect = music.SoundSynthesizerEffects.exponentialRisingInterpolation;
+                        fx.effects[0].parameter[0] = endFrequency;
+                        break;
+                    case 6:
+                        fx.effects[0].effect = music.SoundSynthesizerEffects.exponentialFallingInterpolation;
+                        fx.effects[0].parameter[0] = endFrequency;
+                        break;
+                    case 8: // various ascending scales - see next switch
+                    case 10:
+                    case 12:
+                    case 14:
+                    case 16:
+                        fx.effects[0].effect = music.SoundSynthesizerEffects.appregrioAscending;
+                        break;
+                    case 9: // various descending scales - see next switch
+                    case 11:
+                    case 13:
+                    case 15:
+                    case 17:
+                        fx.effects[0].effect = music.SoundSynthesizerEffects.appregrioDescending;
+                        break;
+                    case 18:
+                        fx.effects[0].effect = music.SoundSynthesizerEffects.logarithmicInterpolation;
+                        fx.effects[0].parameter[0] = endFrequency;
+                        break;
+                }
+                // Scale
+                switch (shape) {
+                    case 8:
+                    case 9:
+                        fx.effects[0].parameter_p[0] = music.MusicalProgressions.majorScale;
+                        break;
+                    case 10:
+                    case 11:
+                        fx.effects[0].parameter_p[0] = music.MusicalProgressions.minorScale;
+                        break;
+                    case 12:
+                    case 13:
+                        fx.effects[0].parameter_p[0] = music.MusicalProgressions.diminished;
+                        break;
+                    case 14:
+                    case 15:
+                        fx.effects[0].parameter_p[0] = music.MusicalProgressions.chromatic;
+                        break;
+                    case 16:
+                    case 17:
+                        fx.effects[0].parameter_p[0] = music.MusicalProgressions.wholeTone;
+                        break;
+                }
+                // Volume envelope
+                let effectVolumeFloat = CLAMP(0, effectVolume, 1023) / 1023.0;
+                let endVolumeFloat = CLAMP(0, endVolume, 1023) / 1023.0;
+                fx.volume = volumeScaleFactor * effectVolumeFloat;
+                fx.effects[1].effect = music.SoundSynthesizerEffects.volumeRampEffect;
+                fx.effects[1].steps = 36;
+                fx.effects[1].parameter[0] = volumeScaleFactor * endVolumeFloat;
+                // Vibrato effect
+                // Steps need to be spread across duration evenly.
+                let normalizedFxnSteps = Math.round(fx.duration / 10000 * fxnSteps);
+                switch (fxChoice) {
+                    case 1:
+                        fx.effects[2].steps = normalizedFxnSteps;
+                        fx.effects[2].effect = music.SoundSynthesizerEffects.frequencyVibratoEffect;
+                        fx.effects[2].parameter[0] = fxParam;
+                        break;
+                    case 2:
+                        fx.effects[2].steps = normalizedFxnSteps;
+                        fx.effects[2].effect = music.SoundSynthesizerEffects.volumeVibratoEffect;
+                        fx.effects[2].parameter[0] = fxParam;
+                        break;
+                    case 3:
+                        fx.effects[2].steps = normalizedFxnSteps;
+                        fx.effects[2].effect = music.SoundSynthesizerEffects.warbleInterpolation;
+                        fx.effects[2].parameter[0] = fxParam;
+                        break;
+                }
+                return true;
+            }
+            music.parseSoundExpression = parseSoundExpression;
+            function random(max) {
+                return Math.floor(Math.random() * max);
+            }
+            function CLAMP(min, value, max) {
+                return Math.min(max, Math.max(min, value));
+            }
+            function applyRandom(value, rand) {
+                if (value < 0 || rand < 0) {
+                    return -1;
+                }
+                const delta = random(rand * 2 + 1) - rand;
+                return Math.abs(value + delta);
+            }
+            function blankSoundEffect() {
+                const res = {
+                    frequency: 0,
+                    volume: 1,
+                    duration: 0,
+                    tone: {
+                        tonePrint: undefined,
+                        parameter: [0]
+                    },
+                    effects: []
+                };
+                for (let i = 0; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++) {
+                    res.effects.push({
+                        effect: undefined,
+                        step: 0,
+                        steps: 0,
+                        parameter: [],
+                        parameter_p: []
+                    });
+                }
+                return res;
+            }
+            function delayAsync(millis) {
+                return new Promise(resolve => setTimeout(resolve, millis));
+            }
+            function constrain(val, min, max) {
+                return Math.min(Math.max(val, min), max);
+            }
+        })(music = codal.music || (codal.music = {}));
+    })(codal = pxsim.codal || (pxsim.codal = {}));
+})(pxsim || (pxsim = {}));
+var pxsim;
 (function (pxsim) {
     class Button {
         constructor(id) {