pxt-core 8.2.2 → 8.2.5

package/built/pxtlib.js

@@ -8713,14 +8713,32 @@ var pxt;
         docs.prepTemplate = prepTemplate;
         function setupRenderer(renderer) {
             renderer.image = function (href, title, text) {
-                const endpointName = "makecode-lucas-testing-makecodetempmediaservice-usea";
+                var _a, _b;
+                const endpointName = "makecodeprodmediaeastus-usea";
                 if (href.startsWith("youtube:")) {
-                    let out = '<div class="tutorial-video-embed"><iframe src="https://www.youtube.com/embed/' + href.split(":").pop()
-                        + '" title="' + title + '" frameborder="0" ' + 'allowFullScreen ' + 'allow="autoplay; picture-in-picture"></iframe></div>';
+                    let out = '<div class="tutorial-video-embed"><iframe class="yt-embed" src="https://www.youtube.com/embed/' + href.split(":").pop()
+                        + '" title="' + text + '" frameborder="0" ' + 'allowFullScreen ' + 'allow="autoplay; picture-in-picture"></iframe></div>';
                     return out;
                 }
                 else if (href.startsWith("azuremedia:")) {
-                    let out = `<div class="tutorial-video-embed"><video class="ams-embed" controls src="https://${endpointName}.streaming.media.azure.net/` + href.split(":").pop() + '/manifest(format=mpd-time-cmaf)" /></div>';
+                    let videoID = href.split(":")[1];
+                    const flagsSplit = videoID.split("?");
+                    let startTime;
+                    let endTime;
+                    if (flagsSplit[1]) {
+                        videoID = flagsSplit[0];
+                        const passedParameters = flagsSplit[1];
+                        startTime = (_a = /start(?:time)?=(\d+)/i.exec(passedParameters)) === null || _a === void 0 ? void 0 : _a[1];
+                        endTime = (_b = /end(?:time)?=(\d+)/i.exec(passedParameters)) === null || _b === void 0 ? void 0 : _b[1];
+                    }
+                    const url = new URL(`https://${endpointName}.streaming.media.azure.net/${videoID}/manifest(format=mpd-time-csf).mpd`);
+                    if (startTime) {
+                        url.hash = `t=${startTime}`;
+                    }
+                    if (endTime) {
+                        url.searchParams.append("endTime", endTime);
+                    }
+                    let out = `<div class="tutorial-video-embed"><video class="ams-embed" controls src="${url.toString()}" /></div>`;
                     return out;
                 }
                 else {
@@ -10500,14 +10518,17 @@ var pxt;
             return false;
         }
         function isRepoBanned(repo, config) {
+            var _a, _b;
             if (isOrgBanned(repo, config))
                 return true;
             if (!config)
                 return false; // don't know
-            if (!repo || !repo.fullName)
+            if (!repo)
                 return true;
+            const repoFull = (_a = repo.fullName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const repoSlug = (_b = repo.slug) === null || _b === void 0 ? void 0 : _b.toLowerCase();
             if (config.bannedRepos
-                && config.bannedRepos.some(fn => fn.toLowerCase() == repo.fullName.toLowerCase()))
+                && config.bannedRepos.some(fn => fn && (fn.toLowerCase() == repoFull || fn.toLowerCase() == repoSlug)))
                 return true;
             return false;
         }
@@ -10521,13 +10542,15 @@ var pxt;
             return false;
         }
         function isRepoApproved(repo, config) {
-            var _a;
+            var _a, _b;
             if (isOrgApproved(repo, config))
                 return true;
-            if (!repo || !config)
+            const repoFull = (_a = repo === null || repo === void 0 ? void 0 : repo.fullName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const repoSlug = (_b = repo === null || repo === void 0 ? void 0 : repo.slug) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+            if (!(config === null || config === void 0 ? void 0 : config.approvedRepoLib) || !(repoFull || repoSlug))
                 return false;
-            if (repo.fullName
-                && ((_a = config.approvedRepoLib) === null || _a === void 0 ? void 0 : _a[repo.fullName.toLowerCase()]))
+            if (config.approvedRepoLib[repoFull]
+                || config.approvedRepoLib[repoSlug])
                 return true;
             return false;
         }
@@ -14270,7 +14293,7 @@ var pxt;
                         // and pulls from master
                         const modtag = (modid === null || modid === void 0 ? void 0 : modid.tag) || ((_a = mod.config) === null || _a === void 0 ? void 0 : _a.version);
                         const vertag = verid.tag;
-                        // if there is no tag on the current dependency, 
+                        // if there is no tag on the current dependency,
                         // assume same as existing module version if any
                         if (modtag && !vertag) {
                             pxt.debug(`unversioned ${ver}, using ${modtag}`);
@@ -14729,6 +14752,8 @@ var pxt;
                     opts.otherMultiVariants.push(etarget);
                 }
                 else {
+                    etarget.target.isNative = opts.target.isNative;
+                    opts.target = etarget.target;
                     ext = einfo;
                     opts.otherMultiVariants = [];
                 }
@@ -15684,7 +15709,12 @@ var ts;
                 const left = param.substr(0, dotIdx);
                 let right = param.substr(dotIdx + 1);
                 right = pxtc.U.snakify(right).toUpperCase();
-                return `${left}.${right}`;
+                if (left) {
+                    return `${left}.${right}`;
+                }
+                else {
+                    return right;
+                }
             }
             return param;
         }
@@ -16905,6 +16935,97 @@ var pxt;
                     return outParts.join(" ");
             }
         }
+        function soundToInstructionBuffer(sound, fxSteps, fxRange) {
+            const { startFrequency, endFrequency, startVolume, endVolume, interpolation, duration } = sound;
+            const steps = [];
+            // Optimize the simple case
+            if (sound.interpolation === "linear" && sound.effect === "none") {
+                steps.push({
+                    frequency: startFrequency,
+                    volume: (startVolume / assets.MAX_VOLUME) * 1024,
+                });
+                steps.push({
+                    frequency: endFrequency,
+                    volume: (endVolume / assets.MAX_VOLUME) * 1024,
+                });
+            }
+            else {
+                fxSteps = Math.min(fxSteps, Math.floor(duration / 5));
+                const getVolumeAt = (t) => ((startVolume + t * (endVolume - startVolume) / duration) / assets.MAX_VOLUME) * 1024;
+                let getFrequencyAt;
+                switch (interpolation) {
+                    case "linear":
+                        getFrequencyAt = t => startFrequency + t * (endFrequency - startFrequency) / duration;
+                        break;
+                    case "curve":
+                        getFrequencyAt = t => startFrequency + (endFrequency - startFrequency) * Math.sin(t / duration * (Math.PI / 2));
+                        break;
+                    case "logarithmic":
+                        getFrequencyAt = t => startFrequency + Math.log10(1 + 9 * (t / duration)) * (endFrequency - startFrequency);
+                        break;
+                }
+                const timeSlice = duration / fxSteps;
+                for (let i = 0; i < fxSteps; i++) {
+                    const newStep = {
+                        frequency: Math.max(getFrequencyAt(i * timeSlice), 1),
+                        volume: getVolumeAt(i * timeSlice)
+                    };
+                    if (sound.effect === "tremolo") {
+                        if (i % 2 === 0) {
+                            newStep.volume = Math.max(newStep.volume - fxRange * 500, 0);
+                        }
+                        else {
+                            newStep.volume = Math.min(newStep.volume + fxRange * 500, 1023);
+                        }
+                    }
+                    else if (sound.effect === "vibrato") {
+                        if (i % 2 === 0) {
+                            newStep.frequency = Math.max(newStep.frequency - fxRange * 100, 1);
+                        }
+                        else {
+                            newStep.frequency = newStep.frequency + fxRange * 100;
+                        }
+                    }
+                    else if (sound.effect === "warble") {
+                        if (i % 2 === 0) {
+                            newStep.frequency = Math.max(newStep.frequency - fxRange * 1000, 1);
+                        }
+                        else {
+                            newStep.frequency = newStep.frequency + fxRange * 1000;
+                        }
+                    }
+                    steps.push(newStep);
+                }
+            }
+            const out = new Uint8Array(12 * (steps.length - 1));
+            const stepDuration = Math.floor(duration / (steps.length - 1));
+            for (let i = 0; i < steps.length - 1; i++) {
+                const offset = i * 12;
+                out[offset] = waveToValue(sound.wave);
+                set16BitNumber(out, offset + 2, steps[i].frequency);
+                set16BitNumber(out, offset + 4, stepDuration);
+                set16BitNumber(out, offset + 6, steps[i].volume);
+                set16BitNumber(out, offset + 8, steps[i + 1].volume);
+                set16BitNumber(out, offset + 10, steps[i + 1].frequency);
+            }
+            return out;
+        }
+        assets.soundToInstructionBuffer = soundToInstructionBuffer;
+        function waveToValue(wave) {
+            switch (wave) {
+                case "square": return 15;
+                case "sine": return 3;
+                case "triangle": return 1;
+                case "noise": return 18;
+                case "sawtooth": return 2;
+            }
+        }
+        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];
+        }
     })(assets = pxt.assets || (pxt.assets = {}));
 })(pxt || (pxt = {}));
 // See https://github.com/microsoft/TouchDevelop-backend/blob/master/docs/streams.md
@@ -21507,6 +21628,18 @@ var ts;
                 }
             }
             assembler.Line = Line;
+            const MAX_OBJ_USERS = 5;
+            class AsmObject {
+                constructor(id, description) {
+                    this.id = id;
+                    this.description = description;
+                    this.sizeAdj = 0;
+                    this.users = [];
+                }
+                get size() {
+                    return (this.endLocation - this.startLocation) - this.sizeAdj;
+                }
+            }
             // File is the center of the action: parsing a file into a sequence of Lines
             // and also emitting the binary (buf)
             class File {
@@ -21531,6 +21664,11 @@ var ts;
                     this.throwOnError = false;
                     this.disablePeepHole = false;
                     this.stackAtLabel = {};
+                    this.codeSizeStats = false;
+                    this.labelToObject = {};
+                    this.idToObject = {};
+                    this.objSuspendStart = 0;
+                    this.labelsToObjectDone = false;
                     this.currLine = new Line(this, "<start>");
                     this.currLine.lineNo = 0;
                     this.ei = ei;
@@ -21550,6 +21688,15 @@ var ts;
                 pc() {
                     return this.location() + this.baseOffset;
                 }
+                useLabel(name) {
+                    if (!this.currObject || name[0] == '.' || this.objSuspendStart)
+                        return;
+                    const obj = pxtc.U.lookup(this.labelToObject, name);
+                    if (!obj || obj == this.currObject)
+                        return;
+                    if (obj.users.length < MAX_OBJ_USERS && obj.users.indexOf(this.currObject) < 0)
+                        obj.users.push(this.currObject);
+                }
                 // parsing of an "integer", well actually much more than
                 // just that
                 parseOneInt(s) {
@@ -21679,6 +21826,7 @@ var ts;
                         return name;
                 }
                 lookupLabel(name, direct = false) {
+                    this.useLabel(name);
                     let v = null;
                     let scoped = this.scopedName(name);
                     if (this.labels.hasOwnProperty(scoped)) {
@@ -21837,6 +21985,37 @@ var ts;
                     };
                     let num0;
                     switch (words[0]) {
+                        case ".object":
+                            if (!this.codeSizeStats) {
+                                // do nothing
+                            }
+                            else if (words[1] == "PUSH") {
+                                this.objSuspendStart = this.location();
+                            }
+                            else if (words[1] == "POP") {
+                                if (this.objSuspendStart)
+                                    this.currObject.sizeAdj += this.location() - this.objSuspendStart;
+                                this.objSuspendStart = 0;
+                            }
+                            else {
+                                if (this.currObject)
+                                    this.currObject.endLocation = this.location();
+                                this.currObject = pxtc.U.lookup(this.idToObject, words[1]);
+                                if (!this.currObject) {
+                                    const str = l.text.replace(/^[^"]*/, "");
+                                    let parsed = words[1];
+                                    if (words.length > 2) {
+                                        parsed = parseString(str.trim());
+                                        if (parsed == null)
+                                            this.directiveError(lf("expecting string in .object"));
+                                    }
+                                    this.currObject = new AsmObject(words[1], parsed);
+                                    this.idToObject[words[1]] = this.currObject;
+                                }
+                                this.currObject.sizeAdj = 0;
+                                this.currObject.startLocation = this.location();
+                            }
+                            break;
                         case ".ascii":
                         case ".asciz":
                         case ".string":
@@ -22031,6 +22210,8 @@ var ts;
                     }
                 }
                 handleOneInstruction(ln, instr) {
+                    if (this.codeSizeStats && ln.ldlitLabel)
+                        this.useLabel(ln.ldlitLabel);
                     let op = instr.emit(ln);
                     if (!op.error) {
                         this.stack += op.stack;
@@ -22139,6 +22320,8 @@ var ts;
                         if (l.words.length == 0)
                             return;
                         if (l.type == "label") {
+                            if (this.currObject && !this.labelsToObjectDone && l.words[0][0] != '.')
+                                this.labelToObject[l.words[0]] = this.currObject;
                             let lblname = this.scopedName(l.words[0]);
                             this.prevLabel = lblname;
                             if (this.finalEmit) {
@@ -22179,6 +22362,8 @@ var ts;
                             pxtc.oops();
                         }
                     });
+                    this.labelsToObjectDone = true;
+                    this.currObject = null;
                 }
                 getSourceMap() {
                     const sourceMap = {};
@@ -22211,6 +22396,22 @@ var ts;
                     }
                     return sourceMap;
                 }
+                getCodeSizeStats() {
+                    if (!this.codeSizeStats)
+                        return "";
+                    const objs = pxtc.U.values(this.idToObject);
+                    objs.sort((a, b) => b.size - a.size);
+                    let r = ";\n; Code size:\n;\n";
+                    for (const obj of objs) {
+                        r += `; ${("         " + obj.size).slice(-6)} ${obj.description} [${obj.id}]\n`;
+                        if (obj.users.length >= MAX_OBJ_USERS)
+                            r += `;        by many, including ${obj.users[0].description}\n`;
+                        else
+                            for (const x of obj.users)
+                                r += `;        by ${x.description} [${x.id}]\n`;
+                    }
+                    return r;
+                }
                 getSource(clean, numStmts = 1, flashSize = 0) {
                     let lenPrev = 0;
                     let size = (lbl) => {
@@ -22226,8 +22427,11 @@ var ts;
                     let lenLiterals = size("_literals_end");
                     let lenAllCode = lenPrev;
                     let totalSize = (lenTotal + this.baseOffset) & 0xffffff;
-                    if (flashSize && totalSize > flashSize)
-                        pxtc.U.userError(lf("program too big by {0} bytes!", totalSize - flashSize));
+                    if (flashSize && totalSize > flashSize) {
+                        const e = new Error(lf("program too big by {0} bytes!", totalSize - flashSize));
+                        e.ksErrorCode = 9283;
+                        throw e;
+                    }
                     flashSize = flashSize || 128 * 1024;
                     let totalInfo = lf("; total bytes: {0} ({1}% of {2}k flash with {3} free)", totalSize, (100 * totalSize / flashSize).toFixed(1), (flashSize / 1024).toFixed(1), flashSize - totalSize);
                     let res = 
@@ -22235,7 +22439,7 @@ var ts;
                     lf("; generated code sizes (bytes): {0} (incl. {1} user, {2} helpers, {3} vtables, {4} lits); src size {5}\n", lenAllCode, lenCode, lenHelpers, lenVtables, lenLiterals, lenTotal - lenAllCode) +
                         lf("; assembly: {0} lines; density: {1} bytes/stmt; ({2} stmts)\n", this.lines.length, Math.round(100 * lenCode / numStmts) / 100, numStmts) +
                         totalInfo + "\n" +
-                        this.stats + "\n\n";
+                        this.stats + this.getCodeSizeStats() + "\n\n";
                     let skipOne = false;
                     this.lines.forEach((ln, i) => {
                         if (ln.words[0] == "_stored_program") {

package/built/pxtsim.d.ts

@@ -1424,11 +1424,11 @@ declare namespace pxsim {
         function frequency(): number;
         function muteAllChannels(): void;
         function queuePlayInstructions(when: number, b: RefBuffer): void;
-        function playInstructionsAsync(b: RefBuffer): Promise<void>;
         function tone(frequency: number, gain: number): void;
         function setCurrentToneGain(gain: number): void;
         function playBufferAsync(buf: RefBuffer): Promise<void>;
         function playPCMBufferStreamAsync(pull: () => Float32Array, sampleRate: number, volume?: number, isCancelled?: () => boolean): Promise<void>;
+        function playInstructionsAsync(instructions: Uint8Array, isCancelled?: () => boolean, onPull?: (freq: number, volume: number) => void): Promise<void>;
         function sendMidiMessage(buf: RefBuffer): void;
     }
     interface IPointerEvents {

package/built/pxtsim.js

@@ -6295,7 +6295,7 @@ var pxsim;
             }
         }
         createFrame(url) {
-            var _a;
+            var _a, _b;
             const wrapper = document.createElement("div");
             wrapper.className = `simframe ui embed`;
             const frame = document.createElement('iframe');
@@ -6306,7 +6306,7 @@ var pxsim;
             frame.setAttribute('sandbox', 'allow-same-origin allow-scripts');
             frame.className = 'no-select';
             let furl = url || this.getSimUrl().toString();
-            if (this._runOptions.hideSimButtons) {
+            if ((_a = this._runOptions) === null || _a === void 0 ? void 0 : _a.hideSimButtons) {
                 const urlObject = new URL(furl);
                 urlObject.searchParams.append("hideSimButtons", "1");
                 furl = urlObject.toString();
@@ -6316,7 +6316,7 @@ var pxsim;
             frame.frameBorder = "0";
             frame.dataset['runid'] = this.runId;
             frame.dataset['origin'] = new URL(furl).origin || "*";
-            if ((_a = this._runOptions) === null || _a === void 0 ? void 0 : _a.autofocus)
+            if ((_b = this._runOptions) === null || _b === void 0 ? void 0 : _b.autofocus)
                 frame.setAttribute("autofocus", "true");
             wrapper.appendChild(frame);
             const i = document.createElement("i");
@@ -7250,92 +7250,10 @@ var pxsim;
                 .then(() => {
                 if (prevStop != instrStopId)
                     return Promise.resolve();
-                return playInstructionsAsync(b);
+                return playInstructionsAsync(b.data);
             });
         }
         AudioContextManager.queuePlayInstructions = queuePlayInstructions;
-        function playInstructionsAsync(b) {
-            const prevStop = instrStopId;
-            let ctx = context();
-            let idx = 0;
-            let ch = new Channel();
-            let currWave = -1;
-            let currFreq = -1;
-            let timeOff = 0;
-            if (channels.length > 5)
-                channels[0].remove();
-            channels.push(ch);
-            /** Square waves are perceved as much louder than other sounds, so scale it down a bit to make it less jarring **/
-            const scaleVol = (n, isSqWave) => (n / 1024) / 4 * (isSqWave ? .5 : 1);
-            const finish = () => {
-                ch.disconnectNodes();
-                timeOff = 0;
-                currWave = -1;
-                currFreq = -1;
-            };
-            const loopAsync = () => {
-                if (idx >= b.data.length || !b.data[idx])
-                    return pxsim.U.delay(timeOff).then(finish);
-                const soundWaveIdx = b.data[idx];
-                const freq = pxsim.BufferMethods.getNumber(b, pxsim.BufferMethods.NumberFormat.UInt16LE, idx + 2);
-                const duration = pxsim.BufferMethods.getNumber(b, pxsim.BufferMethods.NumberFormat.UInt16LE, idx + 4);
-                const startVol = pxsim.BufferMethods.getNumber(b, pxsim.BufferMethods.NumberFormat.UInt16LE, idx + 6);
-                const endVol = pxsim.BufferMethods.getNumber(b, pxsim.BufferMethods.NumberFormat.UInt16LE, idx + 8);
-                const endFreq = pxsim.BufferMethods.getNumber(b, pxsim.BufferMethods.NumberFormat.UInt16LE, idx + 10);
-                const isSquareWave = 11 <= soundWaveIdx && soundWaveIdx <= 15;
-                const isFilteredNoise = soundWaveIdx == 4 || (16 <= soundWaveIdx && soundWaveIdx <= 18);
-                const scaledStart = scaleVol(startVol, isSquareWave);
-                const scaledEnd = scaleVol(endVol, isSquareWave);
-                if (!ctx || prevStop != instrStopId)
-                    return pxsim.U.delay(duration);
-                if (currWave != soundWaveIdx || currFreq != freq || freq != endFreq) {
-                    if (ch.generator) {
-                        return pxsim.U.delay(timeOff)
-                            .then(() => {
-                            finish();
-                            return loopAsync();
-                        });
-                    }
-                    ch.generator = getGenerator(soundWaveIdx, freq);
-                    if (!ch.generator)
-                        return pxsim.U.delay(duration);
-                    currWave = soundWaveIdx;
-                    currFreq = freq;
-                    ch.gain = ctx.createGain();
-                    ch.gain.gain.value = 0;
-                    ch.gain.gain.setTargetAtTime(scaledStart, _context.currentTime, 0.015);
-                    if (endFreq != freq) {
-                        if (ch.generator.frequency != undefined) {
-                            // If generator is an OscillatorNode
-                            const param = ch.generator.frequency;
-                            param.linearRampToValueAtTime(endFreq, ctx.currentTime + ((timeOff + duration) / 1000));
-                        }
-                        else if (ch.generator.playbackRate != undefined) {
-                            // If generator is an AudioBufferSourceNode
-                            const param = ch.generator.playbackRate;
-                            const bufferSamplesPerWave = isFilteredNoise ? 4 : 1024;
-                            param.linearRampToValueAtTime(endFreq / (context().sampleRate / bufferSamplesPerWave), ctx.currentTime + ((timeOff + duration) / 1000));
-                        }
-                    }
-                    ch.generator.connect(ch.gain);
-                    ch.gain.connect(destination);
-                    ch.generator.start();
-                }
-                idx += 12;
-                ch.gain.gain.setValueAtTime(scaledStart, ctx.currentTime + (timeOff / 1000));
-                timeOff += duration;
-                // To prevent clipping, we ramp to this value slightly earlier than intended. This is so that we
-                // can go for a smooth ramp to 0 in ch.mute() without this operation interrupting it. If we had
-                // more accurate timing this would not be necessary, but we'd probably have to do something like
-                // running a metronome in a webworker to get the level of precision we need
-                const endTime = scaledEnd !== 0 && duration > 50 ? ((timeOff - 50) / 1000) : ((timeOff - 10) / 1000);
-                ch.gain.gain.linearRampToValueAtTime(scaledEnd, ctx.currentTime + endTime);
-                return loopAsync();
-            };
-            return loopAsync()
-                .then(() => ch.remove());
-        }
-        AudioContextManager.playInstructionsAsync = playInstructionsAsync;
         function tone(frequency, gain) {
             if (frequency < 0)
                 return;
@@ -7474,6 +7392,126 @@ var pxsim;
         function frequencyFromMidiNoteNumber(note) {
             return 440 * Math.pow(2, (note - 69) / 12);
         }
+        function playInstructionsAsync(instructions, isCancelled, onPull) {
+            return new Promise(async (resolve) => {
+                let resolved = false;
+                let ctx = context();
+                let channel = new Channel();
+                if (channels.length > 5)
+                    channels[0].remove();
+                channels.push(channel);
+                channel.gain = ctx.createGain();
+                channel.gain.gain.value = 1;
+                channel.gain.connect(destination);
+                const oscillators = {};
+                const gains = {};
+                let startTime = ctx.currentTime;
+                let currentTime = startTime;
+                let currentWave = 0;
+                let totalDuration = 0;
+                /** Square waves are perceved as much louder than other sounds, so scale it down a bit to make it less jarring **/
+                const scaleVol = (n, isSqWave) => (n / 1024) / 4 * (isSqWave ? .5 : 1);
+                const disconnectNodes = () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    channel.disconnectNodes();
+                    for (const wave of Object.keys(oscillators)) {
+                        oscillators[wave].stop();
+                        oscillators[wave].disconnect();
+                        gains[wave].disconnect();
+                    }
+                    resolve();
+                };
+                for (let i = 0; i < instructions.length; i += 12) {
+                    const wave = instructions[i];
+                    const startFrequency = readUint16(instructions, i + 2);
+                    const duration = readUint16(instructions, i + 4) / 1000;
+                    const startVolume = readUint16(instructions, i + 6);
+                    const endVolume = readUint16(instructions, i + 8);
+                    const endFrequency = readUint16(instructions, i + 10);
+                    totalDuration += duration;
+                    const isSquareWave = 11 <= wave && wave <= 15;
+                    if (!oscillators[wave]) {
+                        oscillators[wave] = getGenerator(wave, startFrequency);
+                        gains[wave] = ctx.createGain();
+                        gains[wave].gain.value = 0;
+                        gains[wave].connect(channel.gain);
+                        oscillators[wave].connect(gains[wave]);
+                        oscillators[wave].start();
+                    }
+                    if (currentWave && wave !== currentWave) {
+                        gains[currentWave].gain.setTargetAtTime(0, currentTime, 0.015);
+                    }
+                    const osc = oscillators[wave];
+                    const gain = gains[wave];
+                    if (osc instanceof OscillatorNode) {
+                        osc.frequency.setValueAtTime(startFrequency, currentTime);
+                        osc.frequency.linearRampToValueAtTime(endFrequency, currentTime + duration);
+                    }
+                    else {
+                        const isFilteredNoise = wave == 4 || (16 <= wave && wave <= 18);
+                        if (isFilteredNoise)
+                            osc.playbackRate.linearRampToValueAtTime(endFrequency / (ctx.sampleRate / 4), currentTime + duration);
+                        else if (wave != 5)
+                            osc.playbackRate.linearRampToValueAtTime(endFrequency / (ctx.sampleRate / 1024), currentTime + duration);
+                    }
+                    gain.gain.setValueAtTime(scaleVol(startVolume, isSquareWave), currentTime);
+                    gain.gain.linearRampToValueAtTime(scaleVol(endVolume, isSquareWave), currentTime + duration);
+                    currentWave = wave;
+                    currentTime += duration;
+                }
+                channel.gain.gain.setTargetAtTime(0, currentTime, 0.015);
+                if (isCancelled || onPull) {
+                    const handleAnimationFrame = () => {
+                        const time = ctx.currentTime;
+                        if (time > startTime + totalDuration) {
+                            return;
+                        }
+                        if (isCancelled && isCancelled()) {
+                            disconnectNodes();
+                            return;
+                        }
+                        const { frequency, volume } = findFrequencyAndVolumeAtTime((time - startTime) * 1000, instructions);
+                        onPull(frequency, volume / 1024);
+                        requestAnimationFrame(handleAnimationFrame);
+                    };
+                    requestAnimationFrame(handleAnimationFrame);
+                }
+                await pxsim.U.delay(totalDuration * 1000);
+                disconnectNodes();
+            });
+        }
+        AudioContextManager.playInstructionsAsync = playInstructionsAsync;
+        function readUint16(buf, offset) {
+            const temp = new Uint8Array(2);
+            temp[0] = buf[offset];
+            temp[1] = buf[offset + 1];
+            return new Uint16Array(temp.buffer)[0];
+        }
+        function findFrequencyAndVolumeAtTime(millis, instructions) {
+            let currentTime = 0;
+            for (let i = 0; i < instructions.length; i += 12) {
+                const startFrequency = readUint16(instructions, i + 2);
+                const duration = readUint16(instructions, i + 4);
+                const startVolume = readUint16(instructions, i + 6);
+                const endVolume = readUint16(instructions, i + 8);
+                const endFrequency = readUint16(instructions, i + 10);
+                if (currentTime + duration < millis) {
+                    currentTime += duration;
+                    continue;
+                }
+                const offset = (millis - currentTime) / duration;
+                return {
+                    frequency: startFrequency + (endFrequency - startFrequency) * offset,
+                    volume: startVolume + (endVolume - startVolume) * offset,
+                };
+            }
+            return {
+                frequency: -1,
+                volume: -1
+            };
+        }
         function sendMidiMessage(buf) {
             const data = buf.data;
             if (!data.length) // garbage.