pxt-core 8.4.2 → 8.4.3

package/built/pxtlib.js

@@ -216,6 +216,9 @@ var pxt;
                 this.setUserProfileAsync(this.state$.profile);
                 this.setUserPreferencesAsync(this.state$.preferences);
             }
+            async authTokenAsync() {
+                return await pxt.storage.shared.getAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
+            }
             /**
              * Starts the process of authenticating the user against the given identity
              * provider. Upon success the backend will write an http-only session cookie
@@ -700,6 +703,11 @@ var pxt;
             return (_d = (_b = (_a = user === null || user === void 0 ? void 0 : user.idp) === null || _a === void 0 ? void 0 : _a.displayName) !== null && _b !== void 0 ? _b : (_c = user === null || user === void 0 ? void 0 : user.idp) === null || _c === void 0 ? void 0 : _c.username) !== null && _d !== void 0 ? _d : EMPTY_USERNAME;
         }
         auth.userName = userName;
+        function firstName(user) {
+            const userName = pxt.auth.userName(user);
+            return (userName === null || userName === void 0 ? void 0 : userName.split(" ").shift()) || userName;
+        }
+        auth.firstName = firstName;
         function userInitials(user) {
             const username = pxt.auth.userName(user);
             return ts.pxtc.Util.initials(username);
@@ -8742,6 +8750,7 @@ var pxt;
                     const url = new URL(`https://${endpointName}.streaming.media.azure.net/${videoID}/manifest(format=mpd-time-csf).mpd`);
                     if (startTime) {
                         url.hash = `t=${startTime}`;
+                        url.searchParams.append("startTime", startTime);
                     }
                     if (endTime) {
                         url.searchParams.append("endTime", endTime);
@@ -12633,6 +12642,8 @@ var pxt;
         sprite_1.IMAGE_PREFIX = "image";
         sprite_1.ANIMATION_NAMESPACE = "myAnimations";
         sprite_1.ANIMATION_PREFIX = "anim";
+        sprite_1.SONG_NAMESPACE = "mySongs";
+        sprite_1.SONG_PREFIX = "song";
         /**
          * 16-color sprite
          */
@@ -13688,6 +13699,1044 @@ var pxt;
         })(shared = storage.shared || (storage.shared = {}));
     })(storage = pxt.storage || (pxt.storage = {}));
 })(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var assets;
+    (function (assets) {
+        var music;
+        (function (music) {
+            const BUFFER_SIZE = 12;
+            function renderInstrument(instrument, noteFrequency, gateLength, volume) {
+                var _a, _b, _c, _d, _e;
+                const totalDuration = gateLength + instrument.ampEnvelope.release;
+                const ampLFOInterval = ((_a = instrument.ampLFO) === null || _a === void 0 ? void 0 : _a.amplitude) ? Math.max(500 / instrument.ampLFO.frequency, 50) : 50;
+                const pitchLFOInterval = ((_b = instrument.pitchLFO) === null || _b === void 0 ? void 0 : _b.amplitude) ? Math.max(500 / instrument.pitchLFO.frequency, 50) : 50;
+                let timePoints = [0];
+                let nextAETime = instrument.ampEnvelope.attack;
+                let nextPETime = ((_c = instrument.pitchEnvelope) === null || _c === void 0 ? void 0 : _c.amplitude) ? instrument.pitchEnvelope.attack : totalDuration;
+                let nextPLTime = ((_d = instrument.pitchLFO) === null || _d === void 0 ? void 0 : _d.amplitude) ? pitchLFOInterval : totalDuration;
+                let nextALTime = ((_e = instrument.ampLFO) === null || _e === void 0 ? void 0 : _e.amplitude) ? ampLFOInterval : totalDuration;
+                let time = 0;
+                while (time < totalDuration) {
+                    if (nextAETime <= nextPETime && nextAETime <= nextPLTime && nextAETime <= nextALTime) {
+                        time = nextAETime;
+                        timePoints.push(nextAETime);
+                        if (time < instrument.ampEnvelope.attack + instrument.ampEnvelope.decay && instrument.ampEnvelope.attack + instrument.ampEnvelope.decay < gateLength) {
+                            nextAETime = instrument.ampEnvelope.attack + instrument.ampEnvelope.decay;
+                        }
+                        else if (time < gateLength) {
+                            nextAETime = gateLength;
+                        }
+                        else {
+                            nextAETime = totalDuration;
+                        }
+                    }
+                    else if (nextPETime <= nextPLTime && nextPETime <= nextALTime && nextPETime < totalDuration) {
+                        time = nextPETime;
+                        timePoints.push(nextPETime);
+                        if (time < instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay && instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay < gateLength) {
+                            nextPETime = instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay;
+                        }
+                        else if (time < gateLength) {
+                            nextPETime = gateLength;
+                        }
+                        else if (time < gateLength + instrument.pitchEnvelope.release) {
+                            nextPETime = Math.min(totalDuration, gateLength + instrument.pitchEnvelope.release);
+                        }
+                        else {
+                            nextPETime = totalDuration;
+                        }
+                    }
+                    else if (nextPLTime <= nextALTime && nextPLTime < totalDuration) {
+                        time = nextPLTime;
+                        timePoints.push(nextPLTime);
+                        nextPLTime += pitchLFOInterval;
+                    }
+                    else if (nextALTime < totalDuration) {
+                        time = nextALTime;
+                        timePoints.push(nextALTime);
+                        nextALTime += ampLFOInterval;
+                    }
+                    if (time >= totalDuration) {
+                        break;
+                    }
+                    if (nextAETime <= time) {
+                        if (time < instrument.ampEnvelope.attack + instrument.ampEnvelope.decay && instrument.ampEnvelope.attack + instrument.ampEnvelope.decay < gateLength) {
+                            nextAETime = instrument.ampEnvelope.attack + instrument.ampEnvelope.decay;
+                        }
+                        else if (time < gateLength) {
+                            nextAETime = gateLength;
+                        }
+                        else {
+                            nextAETime = totalDuration;
+                        }
+                    }
+                    if (nextPETime <= time) {
+                        if (time < instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay && instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay < gateLength) {
+                            nextPETime = instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay;
+                        }
+                        else if (time < gateLength) {
+                            nextPETime = gateLength;
+                        }
+                        else if (time < gateLength + instrument.pitchEnvelope.release) {
+                            nextPETime = Math.min(totalDuration, gateLength + instrument.pitchEnvelope.release);
+                        }
+                        else {
+                            nextPETime = totalDuration;
+                        }
+                    }
+                    while (nextALTime <= time) {
+                        nextALTime += ampLFOInterval;
+                    }
+                    while (nextPLTime <= time) {
+                        nextPLTime += pitchLFOInterval;
+                    }
+                }
+                let prevAmp = instrumentVolumeAtTime(instrument, gateLength, 0, volume) | 0;
+                let prevPitch = instrumentPitchAtTime(instrument, noteFrequency, gateLength, 0) | 0;
+                let prevTime = 0;
+                let nextAmp;
+                let nextPitch;
+                const out = new Uint8Array(BUFFER_SIZE * (timePoints.length + 1));
+                for (let i = 1; i < timePoints.length; i++) {
+                    if (timePoints[i] - prevTime < 5) {
+                        prevTime = timePoints[i];
+                        continue;
+                    }
+                    nextAmp = instrumentVolumeAtTime(instrument, gateLength, timePoints[i], volume) | 0;
+                    nextPitch = instrumentPitchAtTime(instrument, noteFrequency, gateLength, timePoints[i]) | 0;
+                    addNote(out, (i - 1) * 12, (timePoints[i] - prevTime) | 0, prevAmp, nextAmp, instrument.waveform, prevPitch, nextPitch);
+                    prevAmp = nextAmp;
+                    prevPitch = nextPitch;
+                    prevTime = timePoints[i];
+                }
+                addNote(out, timePoints.length * 12, 10, prevAmp, 0, instrument.waveform, prevPitch, prevPitch);
+                return out;
+            }
+            music.renderInstrument = renderInstrument;
+            function renderDrumInstrument(sound, volume) {
+                let prevAmp = sound.startVolume;
+                let prevFreq = sound.startFrequency;
+                const scaleVolume = (value) => (value / 1024) * volume;
+                let out = new Uint8Array((sound.steps.length + 1) * BUFFER_SIZE);
+                for (let i = 0; i < sound.steps.length; i++) {
+                    addNote(out, i * BUFFER_SIZE, sound.steps[i].duration, scaleVolume(prevAmp), scaleVolume(sound.steps[i].volume), sound.steps[i].waveform, prevFreq, sound.steps[i].frequency);
+                    prevAmp = sound.steps[i].volume;
+                    prevFreq = sound.steps[i].frequency;
+                }
+                addNote(out, sound.steps.length * BUFFER_SIZE, 10, scaleVolume(prevAmp), 0, sound.steps[sound.steps.length - 1].waveform, prevFreq, prevFreq);
+                return out;
+            }
+            music.renderDrumInstrument = renderDrumInstrument;
+            function instrumentPitchAtTime(instrument, noteFrequency, gateLength, time) {
+                var _a, _b;
+                let mod = 0;
+                if ((_a = instrument.pitchEnvelope) === null || _a === void 0 ? void 0 : _a.amplitude) {
+                    mod += envelopeValueAtTime(instrument.pitchEnvelope, time, gateLength);
+                }
+                if ((_b = instrument.pitchLFO) === null || _b === void 0 ? void 0 : _b.amplitude) {
+                    mod += lfoValueAtTime(instrument.pitchLFO, time);
+                }
+                return Math.max(noteFrequency + mod, 0);
+            }
+            function instrumentVolumeAtTime(instrument, gateLength, time, maxVolume) {
+                var _a;
+                let mod = 0;
+                if (instrument.ampEnvelope.amplitude) {
+                    mod += envelopeValueAtTime(instrument.ampEnvelope, time, gateLength);
+                }
+                if ((_a = instrument.ampLFO) === null || _a === void 0 ? void 0 : _a.amplitude) {
+                    mod += lfoValueAtTime(instrument.ampLFO, time);
+                }
+                return ((Math.max(Math.min(mod, instrument.ampEnvelope.amplitude), 0) / 1024) * maxVolume) | 0;
+            }
+            function envelopeValueAtTime(envelope, time, gateLength) {
+                const adjustedSustain = (envelope.sustain / 1024) * envelope.amplitude;
+                if (time > gateLength) {
+                    if (time - gateLength > envelope.release)
+                        return 0;
+                    else if (time < envelope.attack) {
+                        const height = (envelope.amplitude / envelope.attack) * gateLength;
+                        return height - ((height / envelope.release) * (time - gateLength));
+                    }
+                    else if (time < envelope.attack + envelope.decay) {
+                        const height2 = envelope.amplitude - ((envelope.amplitude - adjustedSustain) / envelope.decay) * (gateLength - envelope.attack);
+                        return height2 - ((height2 / envelope.release) * (time - gateLength));
+                    }
+                    else {
+                        return adjustedSustain - (adjustedSustain / envelope.release) * (time - gateLength);
+                    }
+                }
+                else if (time < envelope.attack) {
+                    return (envelope.amplitude / envelope.attack) * time;
+                }
+                else if (time < envelope.attack + envelope.decay) {
+                    return envelope.amplitude - ((envelope.amplitude - adjustedSustain) / envelope.decay) * (time - envelope.attack);
+                }
+                else {
+                    return adjustedSustain;
+                }
+            }
+            function lfoValueAtTime(lfo, time) {
+                return Math.cos(((time / 1000) * lfo.frequency) * 2 * Math.PI) * lfo.amplitude;
+            }
+            function set16BitNumber(buf, offset, value) {
+                const temp = new Uint8Array(2);
+                new Uint16Array(temp.buffer)[0] = value | 0;
+                buf[offset] = temp[0];
+                buf[offset + 1] = temp[1];
+            }
+            function get16BitNumber(buf, offset) {
+                const temp = new Uint8Array(2);
+                temp[0] = buf[offset];
+                temp[1] = buf[offset + 1];
+                return new Uint16Array(temp.buffer)[0];
+            }
+            function addNote(sndInstr, sndInstrPtr, ms, beg, end, soundWave, hz, endHz) {
+                if (ms > 0) {
+                    sndInstr[sndInstrPtr] = soundWave;
+                    sndInstr[sndInstrPtr + 1] = 0;
+                    set16BitNumber(sndInstr, sndInstrPtr + 2, hz);
+                    set16BitNumber(sndInstr, sndInstrPtr + 4, ms);
+                    set16BitNumber(sndInstr, sndInstrPtr + 6, (beg * 255) >> 6);
+                    set16BitNumber(sndInstr, sndInstrPtr + 8, (end * 255) >> 6);
+                    set16BitNumber(sndInstr, sndInstrPtr + 10, endHz);
+                    sndInstrPtr += BUFFER_SIZE;
+                }
+                sndInstr[sndInstrPtr] = 0;
+                return sndInstrPtr;
+            }
+            function encodeSongToHex(song) {
+                const encoded = encodeSong(song);
+                return pxt.U.toHex(encoded);
+            }
+            music.encodeSongToHex = encodeSongToHex;
+            function decodeSongFromHex(hex) {
+                const bytes = pxt.U.fromHex(hex);
+                return decodeSong(bytes);
+            }
+            music.decodeSongFromHex = decodeSongFromHex;
+            /**
+             * Byte encoding format for songs
+             * FIXME: should this all be word aligned?
+             *
+             * song(7 + length of all tracks bytes)
+             *     0 version
+             *     1 beats per minute
+             *     3 beats per measure
+             *     4 ticks per beat
+             *     5 measures
+             *     6 number of tracks
+             *     ...tracks
+             *
+             * track(6 + instrument length + note length bytes)
+             *     0 id
+             *     1 flags
+             *     2 instruments byte length
+             *     4...instrument
+             *     notes byte length
+             *     ...note events
+             *
+             * instrument(27 bytes)
+             *     0 waveform
+             *     1 amp attack
+             *     3 amp decay
+             *     5 amp sustain
+             *     7 amp release
+             *     9 amp amp
+             *     11 pitch attack
+             *     13 pitch decay
+             *     15 pitch sustain
+             *     17 pitch release
+             *     19 pitch amp
+             *     21 amp lfo freq
+             *     22 amp lfo amp
+             *     24 pitch lfo freq
+             *     25 pitch lfo amp
+             *
+             * drum(5 + 7 * steps bytes)
+             *     0 steps
+             *     1 start freq
+             *     3 start amp
+             *     5...steps
+             *
+             * drum step(7 bytes)
+             *     0 waveform
+             *     1 freq
+             *     3 volume
+             *     5 duration
+             *
+             * note event(5 + 1 * polyphony bytes)
+             *     0 start tick
+             *     2 end tick
+             *     4 polyphony
+             *     5...notes(1 byte each)
+             *
+             */
+            function encodeSong(song) {
+                const encodedTracks = song.tracks
+                    .filter((track) => track.notes.length > 0)
+                    .map(encodeTrack);
+                const trackLength = encodedTracks.reduce((d, c) => c.length + d, 0);
+                const out = new Uint8Array(7 + trackLength);
+                out[0] = 0; // encoding version
+                set16BitNumber(out, 1, song.beatsPerMinute);
+                out[3] = song.beatsPerMeasure;
+                out[4] = song.ticksPerBeat;
+                out[5] = song.measures;
+                out[6] = encodedTracks.length;
+                let current = 7;
+                for (const track of encodedTracks) {
+                    out.set(track, current);
+                    current += track.length;
+                }
+                return out;
+            }
+            function decodeSong(buf) {
+                const res = {
+                    beatsPerMinute: get16BitNumber(buf, 1),
+                    beatsPerMeasure: buf[3],
+                    ticksPerBeat: buf[4],
+                    measures: buf[5],
+                    tracks: []
+                };
+                let current = 7;
+                while (current < buf.length) {
+                    const [track, pointer] = decodeTrack(buf, current);
+                    current = pointer;
+                    res.tracks.push(track);
+                }
+                return res;
+            }
+            function encodeInstrument(instrument) {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+                const out = new Uint8Array(28);
+                out[0] = instrument.waveform;
+                set16BitNumber(out, 1, instrument.ampEnvelope.attack);
+                set16BitNumber(out, 3, instrument.ampEnvelope.decay);
+                set16BitNumber(out, 5, instrument.ampEnvelope.sustain);
+                set16BitNumber(out, 7, instrument.ampEnvelope.release);
+                set16BitNumber(out, 9, instrument.ampEnvelope.amplitude);
+                set16BitNumber(out, 11, ((_a = instrument.pitchEnvelope) === null || _a === void 0 ? void 0 : _a.attack) || 0);
+                set16BitNumber(out, 13, ((_b = instrument.pitchEnvelope) === null || _b === void 0 ? void 0 : _b.decay) || 0);
+                set16BitNumber(out, 15, ((_c = instrument.pitchEnvelope) === null || _c === void 0 ? void 0 : _c.sustain) || 0);
+                set16BitNumber(out, 17, ((_d = instrument.pitchEnvelope) === null || _d === void 0 ? void 0 : _d.release) || 0);
+                set16BitNumber(out, 19, ((_e = instrument.pitchEnvelope) === null || _e === void 0 ? void 0 : _e.amplitude) || 0);
+                out[21] = ((_f = instrument.ampLFO) === null || _f === void 0 ? void 0 : _f.frequency) || 0;
+                set16BitNumber(out, 22, ((_g = instrument.ampLFO) === null || _g === void 0 ? void 0 : _g.amplitude) || 0);
+                out[24] = ((_h = instrument.pitchLFO) === null || _h === void 0 ? void 0 : _h.frequency) || 0;
+                set16BitNumber(out, 25, ((_j = instrument.pitchLFO) === null || _j === void 0 ? void 0 : _j.amplitude) || 0);
+                return out;
+            }
+            function decodeInstrument(buf, offset) {
+                return {
+                    waveform: buf[offset],
+                    ampEnvelope: {
+                        attack: get16BitNumber(buf, offset + 1),
+                        decay: get16BitNumber(buf, offset + 3),
+                        sustain: get16BitNumber(buf, offset + 5),
+                        release: get16BitNumber(buf, offset + 7),
+                        amplitude: get16BitNumber(buf, offset + 9),
+                    },
+                    pitchEnvelope: {
+                        attack: get16BitNumber(buf, offset + 11),
+                        decay: get16BitNumber(buf, offset + 13),
+                        sustain: get16BitNumber(buf, offset + 15),
+                        release: get16BitNumber(buf, offset + 17),
+                        amplitude: get16BitNumber(buf, offset + 19),
+                    },
+                    ampLFO: {
+                        frequency: buf[offset + 21],
+                        amplitude: get16BitNumber(buf, 22)
+                    },
+                    pitchLFO: {
+                        frequency: buf[offset + 24],
+                        amplitude: get16BitNumber(buf, 25)
+                    }
+                };
+            }
+            function decodeTrack(buf, offset) {
+                if (buf[offset + 1]) {
+                    return decodeDrumTrack(buf, offset);
+                }
+                return decodeMelodicTrack(buf, offset);
+            }
+            function encodeDrumInstrument(drum) {
+                const out = new Uint8Array(5 + 7 * drum.steps.length);
+                out[0] = drum.steps.length;
+                set16BitNumber(out, 1, drum.startFrequency);
+                set16BitNumber(out, 3, drum.startVolume);
+                for (let i = 0; i < drum.steps.length; i++) {
+                    const start = 5 + i * 7;
+                    out[start] = drum.steps[i].waveform;
+                    set16BitNumber(out, start + 1, drum.steps[i].frequency);
+                    set16BitNumber(out, start + 3, drum.steps[i].volume);
+                    set16BitNumber(out, start + 5, drum.steps[i].duration);
+                }
+                return out;
+            }
+            function decodeDrumInstrument(buf, offset) {
+                const res = {
+                    startFrequency: get16BitNumber(buf, offset + 1),
+                    startVolume: get16BitNumber(buf, offset + 3),
+                    steps: []
+                };
+                for (let i = 0; i < buf[offset]; i++) {
+                    const start = offset + 5 + i * 7;
+                    res.steps.push({
+                        waveform: buf[start],
+                        frequency: get16BitNumber(buf, start + 1),
+                        volume: get16BitNumber(buf, start + 3),
+                        duration: get16BitNumber(buf, start + 5)
+                    });
+                }
+                return res;
+            }
+            function encodeNoteEvent(event) {
+                const out = new Uint8Array(5 + event.notes.length);
+                set16BitNumber(out, 0, event.startTick);
+                set16BitNumber(out, 2, event.endTick);
+                out[4] = event.notes.length;
+                for (let i = 0; i < event.notes.length; i++) {
+                    out[5 + i] = event.notes[i];
+                }
+                return out;
+            }
+            function decodeNoteEvent(buf, offset) {
+                const res = {
+                    startTick: get16BitNumber(buf, offset),
+                    endTick: get16BitNumber(buf, offset + 2),
+                    notes: []
+                };
+                for (let i = 0; i < buf[offset + 4]; i++) {
+                    res.notes.push(buf[offset + 5 + i]);
+                }
+                return res;
+            }
+            function encodeTrack(track) {
+                if (track.drums)
+                    return encodeDrumTrack(track);
+                return encodeMelodicTrack(track);
+            }
+            function encodeMelodicTrack(track) {
+                const encodedInstrument = encodeInstrument(track.instrument);
+                const encodedNotes = track.notes.map(encodeNoteEvent);
+                const noteLength = encodedNotes.reduce((d, c) => c.length + d, 0);
+                const out = new Uint8Array(6 + encodedInstrument.length + noteLength);
+                out[0] = track.id;
+                out[1] = 0;
+                set16BitNumber(out, 2, encodedInstrument.length);
+                let current = 4;
+                out.set(encodedInstrument, current);
+                current += encodedInstrument.length;
+                set16BitNumber(out, current, noteLength);
+                current += 2;
+                for (const note of encodedNotes) {
+                    out.set(note, current);
+                    current += note.length;
+                }
+                return out;
+            }
+            function decodeMelodicTrack(buf, offset) {
+                const res = {
+                    id: buf[offset],
+                    instrument: decodeInstrument(buf, offset + 4),
+                    notes: []
+                };
+                const noteStart = offset + 4 + get16BitNumber(buf, offset + 2);
+                const noteLength = get16BitNumber(buf, noteStart);
+                let currentOffset = noteStart + 2;
+                while (currentOffset < noteStart + 2 + noteLength) {
+                    res.notes.push(decodeNoteEvent(buf, currentOffset));
+                    currentOffset += 5 + res.notes[res.notes.length - 1].notes.length;
+                }
+                return [res, currentOffset];
+            }
+            function encodeDrumTrack(track) {
+                const encodedDrums = track.drums.map(encodeDrumInstrument);
+                const drumLength = encodedDrums.reduce((d, c) => c.length + d, 0);
+                const encodedNotes = track.notes.map(encodeNoteEvent);
+                const noteLength = encodedNotes.reduce((d, c) => c.length + d, 0);
+                const out = new Uint8Array(6 + drumLength + noteLength);
+                out[0] = track.id;
+                out[1] = 1;
+                set16BitNumber(out, 2, drumLength);
+                let current = 4;
+                for (const drum of encodedDrums) {
+                    out.set(drum, current);
+                    current += drum.length;
+                }
+                set16BitNumber(out, current, noteLength);
+                current += 2;
+                for (const note of encodedNotes) {
+                    out.set(note, current);
+                    current += note.length;
+                }
+                return out;
+            }
+            function decodeDrumTrack(buf, offset) {
+                const res = {
+                    id: buf[offset],
+                    instrument: { ampEnvelope: { attack: 0, decay: 0, sustain: 0, release: 0, amplitude: 0 }, waveform: 0 },
+                    notes: [],
+                    drums: []
+                };
+                const drumByteLength = get16BitNumber(buf, offset + 2);
+                let currentOffset = offset + 4;
+                while (currentOffset < offset + 4 + drumByteLength) {
+                    res.drums.push(decodeDrumInstrument(buf, currentOffset));
+                    currentOffset += 5 + 7 * res.drums[res.drums.length - 1].steps.length;
+                }
+                const noteLength = get16BitNumber(buf, currentOffset);
+                currentOffset += 2;
+                while (currentOffset < offset + 4 + drumByteLength + noteLength) {
+                    res.notes.push(decodeNoteEvent(buf, currentOffset));
+                    currentOffset += 5 + res.notes[res.notes.length - 1].notes.length;
+                }
+                return [res, currentOffset];
+            }
+            function cloneSong(song) {
+                return Object.assign(Object.assign({}, song), { tracks: song.tracks.map(track => (Object.assign(Object.assign({}, track), { instrument: track.instrument && Object.assign(Object.assign({}, track.instrument), { ampEnvelope: Object.assign({}, track.instrument.ampEnvelope), pitchEnvelope: track.instrument.pitchEnvelope && Object.assign({}, track.instrument.pitchEnvelope), ampLFO: track.instrument.ampLFO && Object.assign({}, track.instrument.ampLFO), pitchLFO: track.instrument.pitchLFO && Object.assign({}, track.instrument.pitchLFO) }), drums: track.drums && track.drums.map(drum => (Object.assign(Object.assign({}, drum), { steps: drum.steps.map(step => (Object.assign({}, step))) }))), notes: track.notes.map(noteEvent => (Object.assign(Object.assign({}, noteEvent), { notes: noteEvent.notes.slice() }))) }))) });
+            }
+            music.cloneSong = cloneSong;
+            function songEquals(a, b) {
+                return naiveEqualCheck(a, b);
+            }
+            music.songEquals = songEquals;
+            function naiveEqualCheck(a, b) {
+                if (typeof a !== typeof b)
+                    return false;
+                else if (typeof a !== "object")
+                    return a === b;
+                else if (Array.isArray(a)) {
+                    if (a.length !== b.length)
+                        return false;
+                    for (let i = 0; i < a.length; i++) {
+                        if (!naiveEqualCheck(a[i], b[i]))
+                            return false;
+                    }
+                    return true;
+                }
+                const aKeys = Object.keys(a);
+                const bKeys = Object.keys(b);
+                if (aKeys.length !== bKeys.length)
+                    return false;
+                for (const key of aKeys) {
+                    if (bKeys.indexOf(key) === -1)
+                        return false;
+                    if (!naiveEqualCheck(a[key], b[key]))
+                        return false;
+                }
+                return true;
+            }
+            function inflateSong(song) {
+                const base = getEmptySong(1);
+                song.tracks = base.tracks.map((track, index) => {
+                    const existing = song.tracks.find(t => t.id === index);
+                    if (existing)
+                        track.notes = existing.notes;
+                    return track;
+                });
+            }
+            music.inflateSong = inflateSong;
+            function getEmptySong(measures) {
+                return {
+                    ticksPerBeat: 8,
+                    beatsPerMeasure: 4,
+                    beatsPerMinute: 120,
+                    measures,
+                    tracks: [
+                        {
+                            id: 0,
+                            name: lf("Duck"),
+                            notes: [],
+                            iconURI: "/static/music-editor/duck.png",
+                            instrument: {
+                                waveform: 15,
+                                octave: 4,
+                                ampEnvelope: {
+                                    attack: 5,
+                                    decay: 530,
+                                    sustain: 705,
+                                    release: 450,
+                                    amplitude: 1024
+                                },
+                                pitchEnvelope: {
+                                    attack: 5,
+                                    decay: 40,
+                                    sustain: 0,
+                                    release: 100,
+                                    amplitude: 40
+                                },
+                                ampLFO: {
+                                    frequency: 3,
+                                    amplitude: 20
+                                },
+                                pitchLFO: {
+                                    frequency: 6,
+                                    amplitude: 2
+                                }
+                            }
+                        },
+                        {
+                            id: 1,
+                            name: lf("Cat"),
+                            notes: [],
+                            iconURI: "/static/music-editor/cat.png",
+                            instrument: {
+                                waveform: 12,
+                                octave: 5,
+                                ampEnvelope: {
+                                    attack: 150,
+                                    decay: 100,
+                                    sustain: 365,
+                                    release: 400,
+                                    amplitude: 1024
+                                },
+                                pitchEnvelope: {
+                                    attack: 120,
+                                    decay: 300,
+                                    sustain: 0,
+                                    release: 100,
+                                    amplitude: 50
+                                },
+                                pitchLFO: {
+                                    frequency: 10,
+                                    amplitude: 6
+                                }
+                            }
+                        },
+                        {
+                            id: 2,
+                            name: lf("Dog"),
+                            notes: [],
+                            iconURI: "/static/music-editor/dog.png",
+                            instrument: {
+                                waveform: 1,
+                                octave: 4,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 100,
+                                    amplitude: 1024
+                                },
+                                pitchLFO: {
+                                    frequency: 5,
+                                    amplitude: 0
+                                }
+                            }
+                        },
+                        {
+                            id: 3,
+                            name: lf("Fish"),
+                            notes: [],
+                            iconURI: "/static/music-editor/fish.png",
+                            instrument: {
+                                waveform: 1,
+                                octave: 3,
+                                ampEnvelope: {
+                                    attack: 220,
+                                    decay: 105,
+                                    sustain: 1024,
+                                    release: 350,
+                                    amplitude: 1024
+                                },
+                                ampLFO: {
+                                    frequency: 5,
+                                    amplitude: 100
+                                },
+                                pitchLFO: {
+                                    frequency: 1,
+                                    amplitude: 4
+                                }
+                            }
+                        },
+                        {
+                            id: 4,
+                            name: lf("Car"),
+                            notes: [],
+                            iconURI: "/static/music-editor/car.png",
+                            instrument: {
+                                waveform: 16,
+                                octave: 4,
+                                ampEnvelope: {
+                                    attack: 5,
+                                    decay: 100,
+                                    sustain: 1024,
+                                    release: 30,
+                                    amplitude: 1024
+                                },
+                                pitchLFO: {
+                                    frequency: 10,
+                                    amplitude: 4
+                                }
+                            }
+                        },
+                        {
+                            id: 5,
+                            name: lf("Computer"),
+                            notes: [],
+                            iconURI: "/static/music-editor/computer.png",
+                            instrument: {
+                                waveform: 15,
+                                octave: 1,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 10,
+                                    amplitude: 1024
+                                }
+                            }
+                        },
+                        {
+                            id: 6,
+                            name: lf("Burger"),
+                            notes: [],
+                            iconURI: "/static/music-editor/burger.png",
+                            instrument: {
+                                waveform: 1,
+                                octave: 1,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 100,
+                                    amplitude: 1024
+                                }
+                            }
+                        },
+                        {
+                            id: 7,
+                            name: lf("Cherry"),
+                            notes: [],
+                            iconURI: "/static/music-editor/cherry.png",
+                            instrument: {
+                                waveform: 2,
+                                octave: 3,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 100,
+                                    amplitude: 1024
+                                }
+                            }
+                        },
+                        {
+                            id: 8,
+                            name: lf("Lemon"),
+                            notes: [],
+                            iconURI: "/static/music-editor/lemon.png",
+                            instrument: {
+                                waveform: 15,
+                                octave: 2,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 10,
+                                    amplitude: 1024
+                                }
+                            }
+                        },
+                        {
+                            id: 9,
+                            name: lf("Explosion"),
+                            notes: [],
+                            iconURI: "/static/music-editor/explosion.png",
+                            instrument: {
+                                waveform: 11,
+                                octave: 4,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 100,
+                                    amplitude: 1024
+                                }
+                            },
+                            drums: [
+                                {
+                                    startFrequency: 100,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 3,
+                                            frequency: 120,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 3,
+                                            frequency: 1,
+                                            duration: 100,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 480
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 260
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 200
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 200,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 175,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 1,
+                                            frequency: 200,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 150,
+                                            duration: 20,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 100
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 300,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 100,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 3,
+                                            frequency: 120,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 120,
+                                            duration: 100,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 480
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 260
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 200
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 200,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 175,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 1,
+                                            frequency: 200,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 150,
+                                            duration: 20,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 100
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 300,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 100,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 3,
+                                            frequency: 120,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 120,
+                                            duration: 100,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 480
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 260
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 200
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 200,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 175,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 1,
+                                            frequency: 200,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 150,
+                                            duration: 20,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 100
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 300,
+                                            volume: 0
+                                        },
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                };
+            }
+            music.getEmptySong = getEmptySong;
+        })(music = assets.music || (assets.music = {}));
+    })(assets = pxt.assets || (pxt.assets = {}));
+})(pxt || (pxt = {}));
 /// <reference path="../localtypings/pxtpackage.d.ts"/>
 /// <reference path="../localtypings/pxtparts.d.ts"/>
 /// <reference path="../localtypings/pxtarget.d.ts"/>
@@ -17752,6 +18801,7 @@ var pxt;
     pxt.IMAGE_MIME_TYPE = "image/x-mkcd-f4";
     pxt.TILEMAP_MIME_TYPE = "application/mkcd-tilemap";
     pxt.ANIMATION_MIME_TYPE = "application/mkcd-animation";
+    pxt.SONG_MIME_TYPE = "application/mkcd-song";
     class AssetCollection {
         constructor() {
             this.assets = [];
@@ -17938,21 +18988,24 @@ var pxt;
                 tilemaps: new AssetCollection(),
                 tiles: new AssetCollection(),
                 animations: new AssetCollection(),
-                images: new AssetCollection()
+                images: new AssetCollection(),
+                songs: new AssetCollection(),
             };
             this.state = {
                 revision: this.nextID++,
                 tilemaps: new AssetCollection(),
                 tiles: new AssetCollection(),
                 animations: new AssetCollection(),
-                images: new AssetCollection()
+                images: new AssetCollection(),
+                songs: new AssetCollection(),
             };
             this.gallery = {
                 revision: 0,
                 tilemaps: new AssetCollection(),
                 tiles: new AssetCollection(),
                 animations: new AssetCollection(),
-                images: new AssetCollection()
+                images: new AssetCollection(),
+                songs: new AssetCollection(),
             };
             this.undoStack = [];
             this.redoStack = [];
@@ -18054,6 +19107,19 @@ var pxt;
             };
             return this.state.images.add(newImage);
         }
+        createNewSong(data, displayName) {
+            this.onChange();
+            const newSong = {
+                internalID: this.getNewInternalId(),
+                id: this.generateNewID("song" /* AssetType.Song */),
+                type: "song" /* AssetType.Song */,
+                song: pxt.assets.music.cloneSong(data),
+                meta: {
+                    displayName
+                },
+            };
+            return this.state.songs.add(newSong);
+        }
         updateTile(tile) {
             this.onChange();
             const existing = this.resolveProjectTileByInternalID(tile.internalID);
@@ -18090,6 +19156,7 @@ var pxt;
             const blob = {};
             this.state.images.serializeToJRes(blob);
             this.state.animations.serializeToJRes(blob);
+            this.state.songs.serializeToJRes(blob);
             blob["*"] = {
                 "mimeType": "image/x-mkcd-f4",
                 "dataEncoding": "base64",
@@ -18171,6 +19238,7 @@ var pxt;
                 tilemaps: this.state.tilemaps.clone(),
                 animations: this.state.animations.clone(),
                 tiles: this.state.tiles.clone(),
+                songs: this.state.songs.clone(),
             };
         }
         undo() {
@@ -18183,6 +19251,7 @@ var pxt;
                 this.state.images.applyDiff(undo.images, true);
                 this.state.tilemaps.applyDiff(undo.tilemaps, true);
                 this.state.animations.applyDiff(undo.animations, true);
+                this.state.songs.applyDiff(undo.songs, true);
                 this.state.revision = undo.beforeRevision;
                 this.redoStack.push(undo);
                 this.committedState = this.cloneState();
@@ -18196,6 +19265,7 @@ var pxt;
                 this.state.images.applyDiff(redo.images);
                 this.state.tilemaps.applyDiff(redo.tilemaps);
                 this.state.animations.applyDiff(redo.animations);
+                this.state.songs.applyDiff(redo.songs);
                 this.state.revision = redo.afterRevision;
                 this.undoStack.push(redo);
                 this.committedState = this.cloneState();
@@ -18212,7 +19282,8 @@ var pxt;
                 tiles: this.state.tiles.diff(this.committedState.tiles),
                 images: this.state.images.diff(this.committedState.images),
                 tilemaps: this.state.tilemaps.diff(this.committedState.tilemaps),
-                animations: this.state.animations.diff(this.committedState.animations)
+                animations: this.state.animations.diff(this.committedState.animations),
+                songs: this.state.songs.diff(this.committedState.songs)
             });
             this.committedState = this.cloneState();
             this.cleanupTemporaryAssets();
@@ -18242,16 +19313,8 @@ var pxt;
         }
         isNameTaken(assetType, name) {
             const isTaken = (id) => {
-                switch (assetType) {
-                    case "image" /* AssetType.Image */:
-                        return this.state.images.isIDTaken(id) || this.gallery.images.isIDTaken(id);
-                    case "tile" /* AssetType.Tile */:
-                        return this.state.tiles.isIDTaken(id) || this.gallery.tiles.isIDTaken(id);
-                    case "tilemap" /* AssetType.Tilemap */:
-                        return this.state.tilemaps.isIDTaken(id) || this.gallery.tilemaps.isIDTaken(id);
-                    case "animation" /* AssetType.Animation */:
-                        return this.state.animations.isIDTaken(id) || this.gallery.animations.isIDTaken(id);
-                }
+                return getAssetCollection(this.state, assetType).isIDTaken(id) ||
+                    getAssetCollection(this.gallery, assetType).isIDTaken(id);
             };
             const shortId = getShortIDCore(assetType, name);
             const checkShortId = shortId && shortId !== name;
@@ -18277,6 +19340,10 @@ var pxt;
          * assets.animation`shortId`
          * assets.animation`displayName`
          *
+         * SONGS:
+         * assets.song`shortId`
+         * assets.song`displayName`
+         *
          * TILEMAPS:
          * tilemap`shortId`
          *
@@ -18315,6 +19382,11 @@ var pxt;
                         if (displayName)
                             assetTsRefs += `|assets.animation\`${displayName}\``;
                         break;
+                    case "song" /* pxt.AssetType.Song */:
+                        assetTsRefs = `assets.song\`${shortId}\``;
+                        if (displayName)
+                            assetTsRefs += `|assets.song\`${displayName}\``;
+                        break;
                     default:
                         assetTsRefs = `assets.image\`${shortId}\``;
                         if (displayName)
@@ -18337,6 +19409,11 @@ var pxt;
                         if (displayName)
                             assetPyRefs += `|assets.animation\("""${displayName}"""\)`;
                         break;
+                    case "song" /* pxt.AssetType.Song */:
+                        assetPyRefs = `assets.song\("""${shortId}"""\)`;
+                        if (displayName)
+                            assetPyRefs += `|assets.song\("""${displayName}"""\)`;
+                        break;
                     default:
                         assetPyRefs = `assets.image\("""${shortId}"""\)`;
                         if (displayName)
@@ -18362,65 +19439,29 @@ var pxt;
             return false;
         }
         lookupAsset(assetType, name) {
-            switch (assetType) {
-                case "image" /* AssetType.Image */:
-                    return this.state.images.getByID(name) || this.gallery.images.getByID(name);
-                case "tile" /* AssetType.Tile */:
-                    return this.state.tiles.getByID(name) || this.gallery.tiles.getByID(name);
-                case "tilemap" /* AssetType.Tilemap */:
-                    return this.state.tilemaps.getByID(name) || this.gallery.tilemaps.getByID(name);
-                case "animation" /* AssetType.Animation */:
-                    return this.state.animations.getByID(name) || this.gallery.animations.getByID(name);
-            }
+            return getAssetCollection(this.state, assetType).getByID(name) ||
+                getAssetCollection(this.gallery, assetType).getByID(name);
         }
         lookupAssetByName(assetType, name) {
-            switch (assetType) {
-                case "image" /* AssetType.Image */:
-                    return this.state.images.getByDisplayName(name);
-                case "tile" /* AssetType.Tile */:
-                    return this.state.tiles.getByDisplayName(name);
-                case "tilemap" /* AssetType.Tilemap */:
-                    return this.state.tilemaps.getByDisplayName(name);
-                case "animation" /* AssetType.Animation */:
-                    return this.state.animations.getByDisplayName(name);
-            }
+            return getAssetCollection(this.state, assetType).getByDisplayName(name);
         }
         getAssets(type) {
-            switch (type) {
-                case "image" /* AssetType.Image */: return this.state.images.getSnapshot();
-                case "tile" /* AssetType.Tile */: return this.state.tiles.getSnapshot();
-                case "tilemap" /* AssetType.Tilemap */: return this.state.tilemaps.getSnapshot();
-                case "animation" /* AssetType.Animation */: return this.state.animations.getSnapshot();
-            }
+            return getAssetCollection(this.state, type).getSnapshot();
         }
         getGalleryAssets(type) {
-            switch (type) {
-                case "image" /* AssetType.Image */: return this.gallery.images.getSnapshot();
-                case "tile" /* AssetType.Tile */: return this.gallery.tiles.getSnapshot();
-                case "tilemap" /* AssetType.Tilemap */: return this.gallery.tilemaps.getSnapshot();
-                case "animation" /* AssetType.Animation */: return this.gallery.animations.getSnapshot();
-            }
+            return getAssetCollection(this.gallery, type).getSnapshot();
         }
         lookupBlockAsset(type, blockID) {
             let filter = (a) => { var _a, _b; return ((_b = (_a = a.meta) === null || _a === void 0 ? void 0 : _a.blockIDs) === null || _b === void 0 ? void 0 : _b.indexOf(blockID)) !== -1; };
-            switch (type) {
-                case "image" /* AssetType.Image */: return this.state.images.getSnapshot(filter)[0];
-                case "tile" /* AssetType.Tile */: return this.state.tiles.getSnapshot(filter)[0];
-                case "tilemap" /* AssetType.Tilemap */: return this.state.tilemaps.getSnapshot(filter)[0];
-                case "animation" /* AssetType.Animation */: return this.state.animations.getSnapshot(filter)[0];
-            }
+            return getAssetCollection(this.state, type).getSnapshot(filter)[0];
         }
         updateAsset(asset) {
             this.onChange();
             switch (asset.type) {
-                case "image" /* AssetType.Image */:
-                    return this.state.images.update(asset.id, asset);
                 case "tile" /* AssetType.Tile */:
                     return this.updateTile(asset);
-                case "tilemap" /* AssetType.Tilemap */:
-                    return this.state.tilemaps.update(asset.id, asset);
-                case "animation" /* AssetType.Animation */:
-                    return this.state.animations.update(asset.id, asset);
+                default:
+                    return getAssetCollection(this.state, asset.type).update(asset.id, asset);
             }
         }
         duplicateAsset(asset, displayName) {
@@ -18442,53 +19483,22 @@ var pxt;
                     break;
                 case "animation" /* AssetType.Animation */:
                     newAsset = this.createNewAnimationFromData(clone.frames, clone.interval, name);
+                    break;
+                case "song" /* AssetType.Song */:
+                    newAsset = this.createNewSong(asset.song, name);
+                    break;
             }
             return newAsset;
         }
         removeAsset(asset) {
             this.onChange();
-            switch (asset.type) {
-                case "image" /* AssetType.Image */:
-                    return this.state.images.removeByID(asset.id);
-                case "tile" /* AssetType.Tile */:
-                    return this.state.tiles.removeByID(asset.id);
-                case "tilemap" /* AssetType.Tilemap */:
-                    return this.state.tilemaps.removeByID(asset.id);
-                case "animation" /* AssetType.Animation */:
-                    return this.state.animations.removeByID(asset.id);
-            }
+            getAssetCollection(this.state, asset.type).removeByID(asset.id);
         }
         addChangeListener(asset, listener) {
-            switch (asset.type) {
-                case "image" /* AssetType.Image */:
-                    this.state.images.addListener(asset.internalID, listener);
-                    break;
-                case "tile" /* AssetType.Tile */:
-                    this.state.tiles.addListener(asset.internalID, listener);
-                    break;
-                case "tilemap" /* AssetType.Tilemap */:
-                    this.state.tilemaps.addListener(asset.internalID, listener);
-                    break;
-                case "animation" /* AssetType.Animation */:
-                    this.state.animations.addListener(asset.internalID, listener);
-                    break;
-            }
+            getAssetCollection(this.state, asset.type).addListener(asset.internalID, listener);
         }
         removeChangeListener(type, listener) {
-            switch (type) {
-                case "image" /* AssetType.Image */:
-                    this.state.images.removeListener(listener);
-                    break;
-                case "tile" /* AssetType.Tile */:
-                    this.state.tiles.removeListener(listener);
-                    break;
-                case "tilemap" /* AssetType.Tilemap */:
-                    this.state.tilemaps.removeListener(listener);
-                    break;
-                case "animation" /* AssetType.Animation */:
-                    this.state.animations.removeListener(listener);
-                    break;
-            }
+            getAssetCollection(this.state, type).removeListener(listener);
         }
         loadPackage(pack) {
             const allPackages = pack.sortedDeps();
@@ -18513,7 +19523,7 @@ var pxt;
                             this.gallery.images.add(image);
                         }
                     }
-                    else {
+                    else if (image.type === "animation" /* AssetType.Animation */) {
                         if (isProject) {
                             this.state.animations.add(image);
                         }
@@ -18521,6 +19531,14 @@ var pxt;
                             this.gallery.animations.add(image);
                         }
                     }
+                    else {
+                        if (isProject) {
+                            this.state.songs.add(image);
+                        }
+                        else {
+                            this.gallery.songs.add(image);
+                        }
+                    }
                 }
             }
             for (const tm of getTilemaps(pack.parseJRes())) {
@@ -18597,6 +19615,9 @@ var pxt;
                         this.state.animations.add(animation);
                     }
                 }
+                else if (entry.mimeType === pxt.SONG_MIME_TYPE) {
+                    this.state.songs.add(this.generateSong(entry));
+                }
             }
             for (const animation of toInflate) {
                 this.state.animations.add(this.inflateAnimation(animation, this.state.images.getSnapshot()));
@@ -18607,6 +19628,7 @@ var pxt;
             cleanupCollection(this.state.tiles);
             cleanupCollection(this.state.tilemaps);
             cleanupCollection(this.state.animations);
+            cleanupCollection(this.state.songs);
             function cleanupCollection(collection) {
                 const inactiveAssets = collection.getSnapshot(asset => { var _a; return !asset.meta.displayName && ((_a = asset.meta.blockIDs) === null || _a === void 0 ? void 0 : _a.some(id => activeBlockIDs.indexOf(id) === -1)); });
                 const toRemove = [];
@@ -18636,6 +19658,17 @@ var pxt;
                 bitmap: pxt.sprite.getBitmapFromJResURL(`data:${pxt.IMAGE_MIME_TYPE};base64,${entry.data}`).data()
             };
         }
+        generateSong(entry) {
+            return {
+                internalID: this.getNewInternalId(),
+                type: "song" /* AssetType.Song */,
+                id: entry.id,
+                meta: {
+                    displayName: entry.displayName
+                },
+                song: pxt.assets.music.decodeSongFromHex(entry.data)
+            };
+        }
         generateAnimation(entry) {
             if (entry.dataEncoding === "json") {
                 let data;
@@ -18689,6 +19722,8 @@ var pxt;
                     return this.generateNewIDInternal("tile" /* AssetType.Tile */, pxt.sprite.TILE_PREFIX, pxt.sprite.TILE_NAMESPACE);
                 case "tilemap" /* AssetType.Tilemap */:
                     return this.generateNewIDInternal("tilemap" /* AssetType.Tilemap */, lf("level"));
+                case "song" /* AssetType.Song */:
+                    return this.generateNewIDInternal("song" /* AssetType.Song */, pxt.sprite.SONG_PREFIX, pxt.sprite.SONG_NAMESPACE);
             }
         }
         generateNewIDInternal(type, varPrefix, namespaceString) {
@@ -18726,6 +19761,9 @@ var pxt;
                         assets.push(animation);
                     }
                 }
+                else if (entry.mimeType === pxt.SONG_MIME_TYPE) {
+                    assets.push(this.generateSong(entry));
+                }
             }
             for (const animation of toInflate) {
                 assets.push(this.inflateAnimation(animation, assets));
@@ -18786,6 +19824,7 @@ var pxt;
         let out = "";
         const imageEntries = [];
         const animationEntries = [];
+        const songEntries = [];
         for (const key of entries) {
             if (key === "*")
                 continue;
@@ -18812,10 +19851,17 @@ var pxt;
                     expression: `[${animation.frames.map(f => pxt.sprite.bitmapToImageLiteral(pxt.sprite.Bitmap.fromData(f), "typescript")).join(", ")}]`
                 });
             }
+            else if (entry.mimeType === pxt.SONG_MIME_TYPE) {
+                songEntries.push({
+                    keys: [getShortIDCore("song" /* AssetType.Song */, key, true), entry.displayName],
+                    expression: `hex\`${entry.data}\``
+                });
+            }
         }
         const warning = lf("Auto-generated code. Do not edit.");
         out += emitFactoryHelper("image", imageEntries);
         out += emitFactoryHelper("animation", animationEntries);
+        out += emitFactoryHelper("song", songEntries);
         return `// ${warning}\nnamespace ${pxt.sprite.IMAGES_NAMESPACE} {\n${out}\n}\n// ${warning}\n`;
     }
     pxt.emitProjectImages = emitProjectImages;
@@ -18859,6 +19905,8 @@ var pxt;
                 return Object.assign(Object.assign({}, asset), { frames: asset.frames.map(frame => cloneBitmap(frame)) });
             case "tilemap" /* AssetType.Tilemap */:
                 return Object.assign(Object.assign({}, asset), { data: asset.data.cloneData() });
+            case "song" /* AssetType.Song */:
+                return Object.assign(Object.assign({}, asset), { song: pxt.assets.music.cloneSong(asset.song) });
         }
     }
     pxt.cloneAsset = cloneAsset;
@@ -18892,6 +19940,13 @@ var pxt;
             case "animation" /* AssetType.Animation */:
                 allJRes[id] = serializeAnimation(asset);
                 break;
+            case "song" /* AssetType.Song */:
+                allJRes[id] = {
+                    data: pxt.assets.music.encodeSongToHex(asset.song),
+                    mimeType: pxt.SONG_MIME_TYPE,
+                    displayName: asset.meta.displayName
+                };
+                break;
         }
     }
     function assetEquals(a, b) {
@@ -18911,6 +19966,8 @@ var pxt;
                 return a.interval === bAnimation.interval && pxt.U.arrayEquals(a.frames, bAnimation.frames, pxt.sprite.bitmapEquals);
             case "tilemap" /* AssetType.Tilemap */:
                 return a.data.equals(b.data);
+            case "song" /* AssetType.Song */:
+                return pxt.assets.music.songEquals(a.song, b.song);
         }
     }
     pxt.assetEquals = assetEquals;
@@ -18950,11 +20007,13 @@ var pxt;
                 return `assets.animation${leftTick}${shortId}${rightTick}`;
             case "tilemap" /* AssetType.Tilemap */:
                 return `tilemap${leftTick}${shortId}${rightTick}`;
+            case "song" /* AssetType.Song */:
+                return `assets.song${leftTick}${shortId}${rightTick}`;
         }
     }
     pxt.getTSReferenceForAsset = getTSReferenceForAsset;
     function parseAssetTSReference(ts) {
-        const match = /^\s*(?:(?:assets\s*\.\s*(image|tile|animation|tilemap))|(tilemap))\s*(?:`|\(""")([^`"]+)(?:`|"""\))\s*$/m.exec(ts);
+        const match = /^\s*(?:(?:assets\s*\.\s*(image|tile|animation|tilemap|song))|(tilemap))\s*(?:`|\(""")([^`"]+)(?:`|"""\))\s*$/m.exec(ts);
         if (match) {
             const type = match[1] || match[2];
             const name = match[3].trim();
@@ -18978,6 +20037,8 @@ var pxt;
                     return project.lookupAssetByName("tilemap" /* AssetType.Tilemap */, name) || project.lookupAsset("tilemap" /* AssetType.Tilemap */, name);
                 case "animation":
                     return project.lookupAssetByName("animation" /* AssetType.Animation */, name);
+                case "song":
+                    return project.lookupAssetByName("song" /* AssetType.Song */, name);
             }
         }
         return undefined;
@@ -18993,6 +20054,8 @@ var pxt;
                 return lf("level");
             case "animation" /* pxt.AssetType.Animation */:
                 return lf("myAnim");
+            case "song" /* pxt.AssetType.Song */:
+                return lf("mySong");
             default:
                 return lf("asset");
         }
@@ -19017,6 +20080,9 @@ var pxt;
             case "animation" /* AssetType.Animation */:
                 prefix = pxt.sprite.ANIMATION_NAMESPACE + ".";
                 break;
+            case "song" /* AssetType.Song */:
+                prefix = pxt.sprite.SONG_NAMESPACE + ".";
+                break;
         }
         if (prefix) {
             if (id.startsWith(prefix)) {
@@ -19101,6 +20167,15 @@ var pxt;
     function read16Bit(buf, offset) {
         return buf[offset] | (buf[offset + 1] << 8);
     }
+    function getAssetCollection(snapshot, type) {
+        switch (type) {
+            case "animation" /* AssetType.Animation */: return snapshot.animations;
+            case "image" /* AssetType.Image */: return snapshot.images;
+            case "tile" /* AssetType.Tile */: return snapshot.tiles;
+            case "tilemap" /* AssetType.Tilemap */: return snapshot.tilemaps;
+            case "song" /* AssetType.Song */: return snapshot.songs;
+        }
+    }
 })(pxt || (pxt = {}));
 var pxt;
 (function (pxt) {