Upload 819 files

.browserslistrc

@@ -0,0 +1,6 @@
+chrome >= 70
+chromeandroid >= 70
+ios >= 12
+safari >= 12
+edge >= 17
+firefox >= 68

.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_size = 4
+trim_trailing_whitespace = true
+
+[*.{js,html}]
+indent_style = space

.eslintignore

@@ -0,0 +1,5 @@
+coverage/*
+dist/*
+node_modules/*
+playground/*
+benchmark/*

.eslintrc.js

@@ -0,0 +1,3 @@
+module.exports = {
+    extends: ['scratch', 'scratch/node', 'scratch/es6']
+};

.gitattributes

@@ -1,59 +1,47 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto
+
+# Explicitly specify line endings for as many files as possible.
+# People who (for example) rsync between Windows and Linux need this.
+
+# File types which we know are binary
+*.sb2 binary
+
+# Prefer LF for most file types
+*.css text eol=lf
+*.frag text eol=lf
+*.htm text eol=lf
+*.html text eol=lf
+*.iml text eol=lf
+*.js text eol=lf
+*.js.map text eol=lf
+*.json text eol=lf
+*.json5 text eol=lf
+*.md text eol=lf
+*.vert text eol=lf
+*.xml text eol=lf
+*.yml text eol=lf
+
+# Prefer LF for these files
+.editorconfig text eol=lf
+.eslintignore text eol=lf
+.eslintrc text eol=lf
+.gitattributes text eol=lf
+.gitignore text eol=lf
+.gitmodules text eol=lf
+.npmignore text eol=lf
+LICENSE text eol=lf
+Makefile text eol=lf
+README text eol=lf
+TRADEMARK text eol=lf
+
+# Use CRLF for Windows-specific file types
+src/extensions/jg_3dVr/headset.pdn filter=lfs diff=lfs merge=lfs -text
+test/fixtures/complex.sb2 filter=lfs diff=lfs merge=lfs -text
+test/fixtures/event.sb2 filter=lfs diff=lfs merge=lfs -text
+test/fixtures/execute/sprite-number-name.sb2 filter=lfs diff=lfs merge=lfs -text
+test/fixtures/load-extensions/confirm-load/pen-dolphin-3d.sb2 filter=lfs diff=lfs merge=lfs -text
+test/fixtures/load-extensions/confirm-load/pen-dolphin-3d.sb3 filter=lfs diff=lfs merge=lfs -text
+test/fixtures/looks.sb2 filter=lfs diff=lfs merge=lfs -text
+test/fixtures/ordering.sb2 filter=lfs diff=lfs merge=lfs -text
+test/fixtures/pen.sb2 filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,15 @@
+### Expected Behavior
+
+_Please describe what should happen_
+
+### Actual Behavior
+
+_Describe what actually happens_
+
+### Steps to Reproduce
+
+_Explain what someone needs to do in order to see what's described in *Actual behavior* above_
+
+### Operating System and Browser
+
+_e.g. Mac OS 10.11.6 Safari 10.0_

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+### Resolves
+
+_What Github issue does this resolve (please include link)?_
+
+### Proposed Changes
+
+_Describe what this Pull Request does_
+
+### Reason for Changes
+
+_Explain why these changes should be made_
+
+### Test Coverage
+
+_Please show how you have added tests to cover your changes_

.github/workflows/nodejs.yml

@@ -0,0 +1,20 @@
+name: Remote Dispatch Action Initiator
+#test
+on: [push]
+
+jobs:
+  ping-pong:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Repository Dispatch
+        uses: peter-evans/[email protected]
+        with:
+          token: ${{ secrets.t }}
+          event-type: update
+          repository: PenguinMod/penguinmod.github.io
+      - name: Repository Dispatch2
+        uses: peter-evans/[email protected]
+        with:
+          token: ${{ secrets.t }}
+          event-type: update
+          repository: PenguinMod/PenguinMod-Packager

.gitignore

@@ -0,0 +1,22 @@
+# Mac OS
+.DS_Store
+
+# NPM
+/node_modules
+npm-*
+
+# Testing
+/.nyc_output
+/coverage
+
+# Editor
+/.idea
+/.vscode
+
+# Build
+/dist
+/playground
+/benchmark
+
+# Localization
+/translations

.gitpod.yml

@@ -0,0 +1,11 @@
+# This configuration file was automatically generated by Gitpod.
+# Please adjust to your needs (see https://www.gitpod.io/docs/introduction/learn-gitpod/gitpod-yaml)
+# and commit this file to your remote git repository to share the goodness with others.
+
+# Learn more from ready-to-use templates: https://www.gitpod.io/docs/introduction/getting-started/quickstart
+
+tasks:
+  - init: npm install && npm run build
+    command: npm run start
+
+

.idx/dev.nix

@@ -0,0 +1,50 @@
+# To learn more about how to use Nix to configure your environment
+# see: https://developers.google.com/idx/guides/customize-idx-env
+{ pkgs, ... }: {
+  # Which nixpkgs channel to use.
+  channel = "stable-24.05"; # or "unstable"
+
+  # Use https://search.nixos.org/packages to find packages
+  packages = [
+    pkgs.nodejs_20
+  ];
+
+  # Sets environment variables in the workspace
+  env = {};
+  idx = {
+    # Search for the extensions you want on https://open-vsx.org/ and use "publisher.id"
+    extensions = [
+      # "vscodevim.vim"
+    ];
+
+    # Enable previews
+    previews = {
+      enable = true;
+      previews = {
+        # web = {
+        #   # Example: run "npm run dev" with PORT set to IDX's defined port for previews,
+        #   # and show it in IDX's web preview panel
+        #   command = ["npm" "run" "dev"];
+        #   manager = "web";
+        #   env = {
+        #     # Environment variables to set for your server
+        #     PORT = "$PORT";
+        #   };
+        # };
+      };
+    };
+
+    # Workspace lifecycle hooks
+    workspace = {
+      # Runs when a workspace is first created
+      onCreate = {
+        npm-install = "npm install";
+      };
+      # Runs when the workspace is (re)started
+      onStart = {
+        # Example: start a background task to watch and re-build backend code
+        # watch-backend = "npm run watch-backend";
+      };
+    };
+  };
+}

.jsdoc.json

@@ -0,0 +1,20 @@
+{
+    "plugins": ["plugins/markdown"],
+    "templates": {
+        "default": {
+            "includeDate": false,
+            "outputSourceFiles": false
+        }
+    },
+    "source": {
+        "include": ["src"]
+    },
+    "opts": {
+        "destination": "playground/docs",
+        "pedantic": true,
+        "private": true,
+        "readme": "README.md",
+        "recurse": true,
+        "template": "node_modules/docdash"
+    }
+}

.npmignore

@@ -0,0 +1,19 @@
+# Development files
+.eslintrc.js
+/.editorconfig
+/.eslintignore
+/.gitattributes
+/.github
+/.travis.yml
+/.tx
+/test
+
+# Build created files
+/playground
+
+# Coverage created files
+/.nyc_output
+/coverage
+
+# Exclude already built packages from testing with npm pack
+/scratch-vm-*.{tar,tgz}

.travis.yml

@@ -0,0 +1,74 @@
+language: node_js
+node_js:
+- lts/*
+env:
+  global:
+  - NODE_ENV=production
+  - NPM_TAG=latest
+  - RELEASE_TIMESTAMP="$(date +'%Y%m%d%H%M%S')"
+  matrix:
+  - NPM_SCRIPT="tap:unit -- --jobs=4"
+  - NPM_SCRIPT="tap:integration -- --jobs=4"
+cache:
+  directories:
+  - "$HOME/.npm"
+install:
+- npm ci --production=false
+script: npm run $NPM_SCRIPT
+jobs:
+    include:
+    - env: NPM_SCRIPT=lint
+    - env: NPM_SCRIPT=build
+      if: not (type != pull_request AND (branch =~ /^(develop|master|hotfix\/)/))
+    - stage: release
+      env: NPM_SCRIPT=build
+      before_deploy:
+      - >
+        if [ -z "$BEFORE_DEPLOY_RAN" ]; then
+          VPKG=$($(npm bin)/json -f package.json version)
+          export RELEASE_VERSION=${VPKG}-prerelease.${RELEASE_TIMESTAMP}
+          npm --no-git-tag-version version $RELEASE_VERSION
+          if [[ "$TRAVIS_BRANCH" == hotfix/* ]]; then # double brackets are important for matching the wildcard
+            export NPM_TAG=hotfix
+          fi
+          git config --global user.email "$(git log --pretty=format:"%ae" -n1)"
+          git config --global user.name "$(git log --pretty=format:"%an" -n1)"
+          export BEFORE_DEPLOY_RAN=true
+        fi
+      deploy:
+      - provider: npm
+        on:
+          branch:
+          - master
+          - develop
+          - hotfix/*
+          condition: $TRAVIS_EVENT_TYPE != cron
+        skip_cleanup: true
+        email: $NPM_EMAIL
+        api_key: $NPM_TOKEN
+        tag: $NPM_TAG
+      - provider: script
+        on:
+          branch:
+          - master
+          - develop
+          - hotfix/*
+          condition: $TRAVIS_EVENT_TYPE != cron
+        skip_cleanup: true
+        script: if npm info | grep -q $RELEASE_VERSION; then git tag $RELEASE_VERSION && git push https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git $RELEASE_VERSION; fi
+      - provider: script
+        on:
+          all_branches: true
+          condition: $TRAVIS_EVENT_TYPE != cron
+        skip_cleanup: true
+        script: npm run --silent deploy -- -x -r $GH_PAGES_REPO
+      - provider: script
+        on:
+          branch: develop
+          condition: $TRAVIS_EVENT_TYPE == cron
+        skip_cleanup: true
+        script: npm run i18n:src && npm run i18n:push
+stages:
+- test
+- name: release
+  if: type != pull_request AND (branch =~ /^(develop|master|hotfix\/)/)

.tx/config

@@ -0,0 +1,8 @@
+[main]
+host = https://www.transifex.com
+
+[scratch-editor.extensions]
+file_filter = translations/core/<lang>.json
+source_file = translations/core/en.json
+source_lang = en
+type = CHROME

LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2016, Massachusetts Institute of Technology
+Copyright (c) 2020-2022, Thomas Weber
+Copyright (c) 2023-2024 Penguinmod
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,152 @@
+## PenguinMod/PenguinMod-Vm
+
+Modified Scratch VM with a JIT compiler and more features.
+
+This is a drop-in replacement for LLK/scratch-vm.
+
+## Setup
+
+See https://github.com/TurboWarp/scratch-gui/wiki/Getting-Started to setup the complete TurboWarp environment.
+
+If you just want to play with the VM then it's the same process as upstream scratch-vm.
+
+## Extension authors
+
+If you only use the standard reporter, boolean, and command block types, everything should just work without any changes.
+
+## Compiler Overview
+
+For a high-level overview of how the compiler works, see https://docs.turbowarp.org/how
+
+For more technical information, read the code in src/compiler.
+
+## Public API
+
+This section was too out of date to be useful. We hope to re-add it as some point.
+
+<!--
+
+## scratch-vm
+#### Scratch VM is a library for representing, running, and maintaining the state of computer programs written using [Scratch Blocks](https://github.com/LLK/scratch-blocks).
+
+[![Build Status](https://travis-ci.org/LLK/scratch-vm.svg?branch=develop)](https://travis-ci.org/LLK/scratch-vm)
+[![Coverage Status](https://coveralls.io/repos/github/LLK/scratch-vm/badge.svg?branch=develop)](https://coveralls.io/github/LLK/scratch-vm?branch=develop)
+
+## Installation
+This requires you to have Git and Node.js installed.
+
+To install as a dependency for your own application:
+```bash
+npm install scratch-vm
+```
+To set up a development environment to edit scratch-vm yourself:
+```bash
+git clone https://github.com/LLK/scratch-vm.git
+cd scratch-vm
+npm install
+```
+
+## Development Server
+This requires Node.js to be installed.
+
+For convenience, we've included a development server with the VM. This is sometimes useful when running in an environment that's loading remote resources (e.g., SVGs from the Scratch server). If you would like to use your modified VM with the full Scratch 3.0 GUI, [follow the instructions to link the VM to the GUI](https://github.com/LLK/scratch-gui/wiki/Getting-Started).
+
+## Running the Development Server
+Open a Command Prompt or Terminal in the repository and run:
+```bash
+npm start
+```
+
+## Playground
+To view the Playground, make sure the dev server's running and go to [http://localhost:8073/playground/](http://localhost:8073/playground/) - you will be directed to the playground, which demonstrates various tools and internal state.
+
+![VM Playground Screenshot](https://i.imgur.com/nOCNqEc.gif)
+
+
+## Standalone Build
+```bash
+npm run build
+```
+
+```html
+<script src="/path/to/dist/web/scratch-vm.js"></script>
+<script>
+    var vm = new window.VirtualMachine();
+    // do things
+</script>
+```
+
+## How to include in a Node.js App
+For an extended setup example, check out the /src/playground directory, which includes a fully running VM instance.
+```js
+var VirtualMachine = require('scratch-vm');
+var vm = new VirtualMachine();
+
+// Block events
+Scratch.workspace.addChangeListener(vm.blockListener);
+
+// Run threads
+vm.start();
+```
+
+## Abstract Syntax Tree
+
+#### Overview
+The Virtual Machine constructs and maintains the state of an [Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) (AST) by listening to events emitted by the [scratch-blocks](https://github.com/LLK/scratch-blocks) workspace via the `blockListener`. Each target (code-running object, for example, a sprite) keeps an AST for its blocks. At any time, the current state of an AST can be viewed by inspecting the `vm.runtime.targets[...].blocks` object.
+
+#### Anatomy of a Block
+The VM's block representation contains all the important information for execution and storage. Here's an example representing the "when key pressed" script on a workspace:
+```json
+{
+  "_blocks": {
+    "Q]PK~yJ@BTV8Y~FfISeo": {
+      "id": "Q]PK~yJ@BTV8Y~FfISeo",
+      "opcode": "event_whenkeypressed",
+      "inputs": {
+      },
+      "fields": {
+        "KEY_OPTION": {
+          "name": "KEY_OPTION",
+          "value": "space"
+        }
+      },
+      "next": null,
+      "topLevel": true,
+      "parent": null,
+      "shadow": false,
+      "x": -69.333333333333,
+      "y": 174
+    }
+  },
+  "_scripts": [
+    "Q]PK~yJ@BTV8Y~FfISeo"
+  ]
+}
+```
+
+## Testing
+```bash
+npm test
+```
+
+```bash
+npm run coverage
+```
+
+## Publishing to GitHub Pages
+```bash
+npm run deploy
+```
+
+This will push the currently built playground to the gh-pages branch of the
+currently tracked remote.  If you would like to change where to push to, add
+a repo url argument:
+```bash
+npm run deploy -- -r <your repo url>
+```
+
+## Donate
+We provide [Scratch](https://scratch.mit.edu) free of charge, and want to keep it that way! Please consider making a [donation](https://secure.donationpay.org/scratchfoundation/) to support our continued engineering, design, community, and resource development efforts. Donations of any size are appreciated. Thank you!
+
+-->
+e

TRADEMARK

@@ -0,0 +1 @@
+The Scratch trademarks, including the Scratch name, logo, the Scratch Cat, Gobo, Pico, Nano, Tera and Giga graphics (the "Marks"), are property of the Massachusetts Institute of Technology (MIT). Marks may not be used to endorse or promote products derived from this software without specific prior written permission.

docs/extensions.md

@@ -0,0 +1,527 @@
+# Scratch 3.0 Extensions
+
+This document describes technical topics related to Scratch 3.0 extension development, including the Scratch 3.0
+extension specification.
+
+## Types of Extensions
+
+There are four types of extensions that can define everything from the Scratch's core library (such as the "Looks" and
+"Operators" categories) to unofficial extensions that can be loaded from a remote URL.
+
+**Scratch 3.0 does not yet support unofficial extensions.**
+
+|                                | Core | Team | Official | Unofficial |
+| ------------------------------ | ---- | ---- | -------- | ---------- |
+| Developed by Scratch Team      | √    | √    | O        | X          |
+| Maintained by Scratch Team     | √    | √    | O        | X          |
+| Shown in Library               | X    | √    | √        | X          |
+| Sandboxed                      | X    | X    | √        | √          |
+| Can save projects to community | √    | √    | √        | X          |
+
+## JavaScript Environment
+
+Most Scratch 3.0 is written using JavaScript features not yet commonly supported by browsers. For compatibility we
+transpile the code to ES5 before publishing or deploying. Any extension included in the `scratch-vm` repository may
+use ES6+ features and may use `require` to reference other code within the `scratch-vm` repository.
+
+Unofficial extensions must be self-contained. Authors of unofficial extensions are responsible for ensuring browser
+compatibility for those extensions, including transpiling if necessary.
+
+## Translation
+
+Scratch extensions use the [ICU message format](http://userguide.icu-project.org/formatparse/messages) to handle
+translation across languages. For **core, team, and official** extensions, the function `formatMessage` is used to
+wrap any ICU messages that need to be exported to the [Scratch Transifex group](https://www.transifex.com/llk/public/)
+for translation.
+
+**All extensions** may additionally define a `translation_map` object within the `getInfo` function which can provide
+translations within an extension itself. The "Annotated Example" below provides a more complete illustration of how
+translation within an extension can be managed. **WARNING:** the `translation_map` feature is currently in the
+proposal phase and may change before implementation.
+
+## Backwards Compatibility
+
+Scratch is designed to be fully backwards compatible. Because of this, block definitions and opcodes should *never*
+change in a way that could cause previously saved projects to fail to load or to act in unexpected / inconsistent
+ways.
+
+## Defining an Extension
+
+Scratch extensions are defined as a single Javascript class which accepts either a reference to the Scratch
+[VM](https://github.com/llk/scratch-vm) runtime or a "runtime proxy" which handles communication with the Scratch VM
+across a well defined worker boundary (i.e. the sandbox).
+
+```js
+class SomeBlocks {
+    constructor (runtime) {
+        /**
+         * Store this for later communication with the Scratch VM runtime.
+         * If this extension is running in a sandbox then `runtime` is an async proxy object.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    // ...
+}
+```
+
+All extensions must define a function called `getInfo` which returns an object that contains the information needed to
+render both the blocks and the extension itself.
+
+```js
+// Core, Team, and Official extensions can `require` VM code:
+const ArgumentType = require('../../extension-support/argument-type');
+const BlockType = require('../../extension-support/block-type');
+
+class SomeBlocks {
+    // ...
+    getInfo () {
+        return {
+            id: 'someBlocks',
+            name: 'Some Blocks',
+            blocks: [
+                {
+                    opcode: 'myReporter',
+                    blockType: BlockType.REPORTER,
+                    text: 'letter [LETTER_NUM] of [TEXT]',
+                    arguments: {
+                        LETTER_NUM: {
+                            type: ArgumentType.STRING,
+                            defaultValue: '1'
+                        },
+                        TEXT: {
+                            type: ArgumentType.STRING,
+                            defaultValue: 'text'
+                        }
+                    }
+                }
+            ]
+        };
+    }
+    // ...
+}
+```
+
+Finally the extension must define a function for any "opcode" defined in the blocks. For example:
+
+```js
+class SomeBlocks {
+    // ...
+    myReporter (args) {
+        return args.TEXT.charAt(args.LETTER_NUM);
+    };
+    // ...
+}
+```
+### Block Arguments
+In addition to displaying text, blocks can have arguments in the form of slots to take other blocks getting plugged in, or dropdown menus to select an argument value from a list of possible values.
+
+The possible types of block arguments are as follows:
+
+- String - a string input, this is a type-able field which also accepts other reporter blocks to be plugged in
+- Number - an input similar to the string input, but the type-able values are constrained to numbers.
+- Angle - an input similar to the number input, but it has an additional UI to be able to pick an angle from a
+circular dial
+- Boolean - an input for a boolean (hexagonal shaped) reporter block. This field is not type-able.
+- Color - an input which displays a color swatch. This field has additional UI to pick a color by choosing values for the color's hue, saturation and brightness. Optionally, the defaultValue for the color picker can also be chosen if the extension developer wishes to display the same color every time the extension is added. If the defaultValue is left out, the default behavior of picking a random color when the extension is loaded will be used.
+- Matrix - an input which displays a 5 x 5 matrix of cells, where each cell can be filled in or clear.
+- Note - a numeric input which can select a musical note. This field has additional UI to select a note from a
+visual keyboard.
+- Image - an inline image displayed on a block. This is a special argument type in that it does not represent a value and does not accept other blocks to be plugged-in in place of this block field. See the section below about "Adding an Inline Image".
+
+#### Adding an Inline Image
+In addition to specifying block arguments (an example of string arguments shown in the code snippet above),
+you can also specify an inline image for the block. You must include a dataURI for the image. If left unspecified, blank space will be allocated for the image and a warning will be logged in the console.
+You can optionally also specify `flipRTL`, a property indicating whether the image should be flipped horizontally when the editor has a right to left language selected as its locale. By default, the image is not flipped.
+
+```js
+return {
+    // ...
+    blocks: [
+        {
+            //...
+            arguments: {
+                MY_IMAGE: {
+                    type: ArgumentType.IMAGE,
+                    dataURI: 'myImageData',
+                    alt: 'This is an image',
+                    flipRTL: true
+                }
+            }
+        }
+    ]
+}
+```
+
+
+
+
+#### Defining a Menu
+
+To display a drop-down menu for a block argument, specify the `menu` property of that argument and a matching item in
+the `menus` section of your extension's definition:
+
+```js
+return {
+    // ...
+    blocks: [
+        {
+            // ...
+            arguments: {
+                FOO: {
+                    type: ArgumentType.NUMBER,
+                    menu: 'fooMenu'
+                }
+            }
+        }
+    ],
+    menus: {
+        fooMenu: {
+            items: ['a', 'b', 'c']
+        }
+    }
+}
+```
+
+The items in a menu may be specified with an array or with the name of a function which returns an array. The two
+simplest forms for menu definitions are:
+
+```js
+getInfo () {
+    return {
+        menus: {
+            staticMenu: ['static 1', 'static 2', 'static 3'],
+            dynamicMenu: 'getDynamicMenuItems'
+        }
+    };
+}
+// this member function will be called each time the menu opens
+getDynamicMenuItems () {
+    return ['dynamic 1', 'dynamic 2', 'dynamic 3'];
+}
+```
+
+The examples above are shorthand for these equivalent definitions:
+
+```js
+getInfo () {
+    return {
+        menus: {
+            staticMenu: {
+                items: ['static 1', 'static 2', 'static 3']
+            },
+            dynamicMenu: {
+                items: 'getDynamicMenuItems'
+            }
+        }
+    };
+}
+// this member function will be called each time the menu opens
+getDynamicMenuItems () {
+    return ['dynamic 1', 'dynamic 2', 'dynamic 3'];
+}
+```
+
+If a menu item needs a label that doesn't match its value -- for example, if the label needs to be displayed in the
+user's language but the value needs to stay constant -- the menu item may be an object instead of a string. This works
+for both static and dynamic menu items:
+
+```js
+menus: {
+    staticMenu: [
+        {
+            text: formatMessage(/* ... */),
+            value: 42
+        }
+    ]
+}
+```
+
+##### Accepting reporters ("droppable" menus)
+
+By default it is not possible to specify the value of a dropdown menu by inserting a reporter block. While we
+encourage extension authors to make their menus accept reporters when possible, doing so requires careful
+consideration to avoid confusion and frustration on the part of those using the extension.
+
+A few of these considerations include:
+
+* The valid values for the menu should not change when the user changes the Scratch language setting.
+  * In particular, changing languages should never break a working project.
+* The average Scratch user should be able to figure out the valid values for this input without referring to extension
+  documentation.
+  * One way to ensure this is to make an item's text match or include the item's value. For example, the official Music
+    extension contains menu items with names like "(1) Piano" with value 1, "(8) Cello" with value 8, and so on.
+* The block should accept any value as input, even "invalid" values.
+  * Scratch has no concept of a runtime error!
+  * For a command block, sometimes the best option is to do nothing.
+  * For a reporter, returning zero or the empty string might make sense.
+* The block should be forgiving in its interpretation of inputs.
+  * For example, if the block expects a string and receives a number it may make sense to interpret the number as a
+    string instead of treating it as invalid input.
+
+The `acceptReporters` flag indicates that the user can drop a reporter onto the menu input:
+
+```js
+menus: {
+    staticMenu: {
+        acceptReporters: true,
+        items: [/*...*/]
+    },
+    dynamicMenu: {
+        acceptReporters: true,
+        items: 'getDynamicMenuItems'
+    }
+}
+```
+
+## Annotated Example
+
+```js
+// Core, Team, and Official extensions can `require` VM code:
+const ArgumentType = require('../../extension-support/argument-type');
+const BlockType = require('../../extension-support/block-type');
+const TargetType = require('../../extension-support/target-type');
+
+// ...or VM dependencies:
+const formatMessage = require('format-message');
+
+// Core, Team, and Official extension classes should be registered statically with the Extension Manager.
+// See: scratch-vm/src/extension-support/extension-manager.js
+class SomeBlocks {
+    constructor (runtime) {
+        /**
+         * Store this for later communication with the Scratch VM runtime.
+         * If this extension is running in a sandbox then `runtime` is an async proxy object.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * @return {object} This extension's metadata.
+     */
+    getInfo () {
+        return {
+            // Required: the machine-readable name of this extension.
+            // Will be used as the extension's namespace.
+            // Allowed characters are those matching the regular expression [\w-]: A-Z, a-z, 0-9, and hyphen ("-").
+            id: 'someBlocks',
+
+            // Core extensions only: override the default extension block colors.
+            color1: '#FF8C1A',
+            color2: '#DB6E00',
+
+            // Optional: the human-readable name of this extension as string.
+            // This and any other string to be displayed in the Scratch UI may either be
+            // a string or a call to `formatMessage`; a plain string will not be
+            // translated whereas a call to `formatMessage` will connect the string
+            // to the translation map (see below). The `formatMessage` call is
+            // similar to `formatMessage` from `react-intl` in form, but will actually
+            // call some extension support code to do its magic. For example, we will
+            // internally namespace the messages such that two extensions could have
+            // messages with the same ID without colliding.
+            // See also: https://github.com/yahoo/react-intl/wiki/API#formatmessage
+            name: formatMessage({
+                id: 'extensionName',
+                defaultMessage: 'Some Blocks',
+                description: 'The name of the "Some Blocks" extension'
+            }),
+
+            // Optional: URI for a block icon, to display at the edge of each block for this
+            // extension. Data URI OK.
+            // TODO: what file types are OK? All web images? Just PNG?
+            blockIconURI: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAkAAAAFCAAAAACyOJm3AAAAFklEQVQYV2P4DwMMEMgAI/+DEUIMBgAEWB7i7uidhAAAAABJRU5ErkJggg==',
+
+            // Optional: URI for an icon to be displayed in the blocks category menu.
+            // If not present, the menu will display the block icon, if one is present.
+            // Otherwise, the category menu shows its default filled circle.
+            // Data URI OK.
+            // TODO: what file types are OK? All web images? Just PNG?
+            menuIconURI: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAkAAAAFCAAAAACyOJm3AAAAFklEQVQYV2P4DwMMEMgAI/+DEUIMBgAEWB7i7uidhAAAAABJRU5ErkJggg==',
+
+            // Optional: Link to documentation content for this extension.
+            // If not present, offer no link.
+            docsURI: 'https://....',
+
+            // Required: the list of blocks implemented by this extension,
+            // in the order intended for display.
+            blocks: [
+                {
+                    // Required: the machine-readable name of this operation.
+                    // This will appear in project JSON.
+                    opcode: 'myReporter', // becomes 'someBlocks.myReporter'
+
+                    // Required: the kind of block we're defining, from a predefined list.
+                    // Fully supported block types:
+                    //   BlockType.BOOLEAN - same as REPORTER but returns a Boolean value
+                    //   BlockType.COMMAND - a normal command block, like "move {} steps"
+                    //   BlockType.HAT - starts a stack if its value changes from falsy to truthy ("edge triggered")
+                    //   BlockType.REPORTER - returns a value, like "direction"
+                    // Block types in development or for internal use only:
+                    //   BlockType.BUTTON - place a button in the block palette
+                    //   BlockType.CONDITIONAL - control flow, like "if {}" or "if {} else {}"
+                    //     A CONDITIONAL block may return the one-based index of a branch to
+                    //     run, or it may return zero/falsy to run no branch.
+                    //   BlockType.EVENT - starts a stack in response to an event (full spec TBD)
+                    //   BlockType.LOOP - control flow, like "repeat {} {}" or "forever {}"
+                    //     A LOOP block is like a CONDITIONAL block with two differences:
+                    //     - the block is assumed to have exactly one child branch, and
+                    //     - each time a child branch finishes, the loop block is called again.
+                    blockType: BlockType.REPORTER,
+
+                    // Required for CONDITIONAL blocks, ignored for others: the number of
+                    // child branches this block controls. An "if" or "repeat" block would
+                    // specify a branch count of 1; an "if-else" block would specify a
+                    // branch count of 2.
+                    // TODO: should we support dynamic branch count for "switch"-likes?
+                    branchCount: 0,
+
+                    // Optional, default false: whether or not this block ends a stack.
+                    // The "forever" and "stop all" blocks would specify true here.
+                    terminal: true,
+
+                    // Optional, default false: whether or not to block all threads while
+                    // this block is busy. This is for things like the "touching color"
+                    // block in compatibility mode, and is only needed if the VM runs in a
+                    // worker. We might even consider omitting it from extension docs...
+                    blockAllThreads: false,
+
+                    // Required: the human-readable text on this block, including argument
+                    // placeholders. Argument placeholders should be in [MACRO_CASE] and
+                    // must be [ENCLOSED_WITHIN_SQUARE_BRACKETS].
+                    text: formatMessage({
+                        id: 'myReporter',
+                        defaultMessage: 'letter [LETTER_NUM] of [TEXT]',
+                        description: 'Label on the "myReporter" block'
+                    }),
+
+                    // Required: describe each argument.
+                    // Argument order may change during translation, so arguments are
+                    // identified by their placeholder name. In those situations where
+                    // arguments must be ordered or assigned an ordinal, such as interaction
+                    // with Scratch Blocks, arguments are ordered as they are in the default
+                    // translation (probably English).
+                    arguments: {
+                        // Required: the ID of the argument, which will be the name in the
+                        // args object passed to the implementation function.
+                        LETTER_NUM: {
+                            // Required: type of the argument / shape of the block input
+                            type: ArgumentType.NUMBER,
+
+                            // Optional: the default value of the argument
+                            default: 1
+                        },
+
+                        // Required: the ID of the argument, which will be the name in the
+                        // args object passed to the implementation function.
+                        TEXT: {
+                            // Required: type of the argument / shape of the block input
+                            type: ArgumentType.STRING,
+
+                                // Optional: the default value of the argument
+                            default: formatMessage({
+                                id: 'myReporter.TEXT_default',
+                                defaultMessage: 'text',
+                                description: 'Default for "TEXT" argument of "someBlocks.myReporter"'
+                            })
+                        }
+                    },
+
+                    // Optional: the function implementing this block.
+                    // If absent, assume `func` is the same as `opcode`.
+                    func: 'myReporter',
+
+                    // Optional: list of target types for which this block should appear.
+                    // If absent, assume it applies to all builtin targets -- that is:
+                    // [TargetType.SPRITE, TargetType.STAGE]
+                    filter: [TargetType.SPRITE]
+                },
+                {
+                    // Another block...
+                }
+            ],
+
+            // Optional: define extension-specific menus here.
+            menus: {
+                // Required: an identifier for this menu, unique within this extension.
+                menuA: [
+                    // Static menu: list items which should appear in the menu.
+                    {
+                        // Required: the value of the menu item when it is chosen.
+                        value: 'itemId1',
+
+                        // Optional: the human-readable label for this item.
+                        // Use `value` as the text if this is absent.
+                        text: formatMessage({
+                            id: 'menuA_item1',
+                            defaultMessage: 'Item One',
+                            description: 'Label for item 1 of menu A in "Some Blocks" extension'
+                        })
+                    },
+
+                    // The simplest form of a list item is a string which will be used as
+                    // both value and text.
+                    'itemId2'
+                ],
+
+                // Dynamic menu: returns an array as above.
+                // Called each time the menu is opened.
+                menuB: 'getItemsForMenuB',
+
+                // The examples above are shorthand for setting only the `items` property in this full form:
+                menuC: {
+                    // This flag makes a "droppable" menu: the menu will allow dropping a reporter in for the input.
+                    acceptReporters: true,
+
+                    // The `item` property may be an array or function name as in previous menu examples.
+                    items: [/*...*/] || 'getItemsForMenuC'
+                }
+            },
+
+            // Optional: translations (UNSTABLE - NOT YET SUPPORTED)
+            translation_map: {
+                de: {
+                    'extensionName': 'Einige Blöcke',
+                    'myReporter': 'Buchstabe [LETTER_NUM] von [TEXT]',
+                    'myReporter.TEXT_default': 'Text',
+                    'menuA_item1': 'Artikel eins',
+
+                    // Dynamic menus can be translated too
+                    'menuB_example': 'Beispiel',
+
+                    // This message contains ICU placeholders (see `myReporter()` below)
+                    'myReporter.result': 'Buchstabe {LETTER_NUM} von {TEXT} ist {LETTER}.'
+                },
+                it: {
+                    // ...
+                }
+            }
+        };
+    };
+
+    /**
+     * Implement myReporter.
+     * @param {object} args - the block's arguments.
+     * @property {string} MY_ARG - the string value of the argument.
+     * @returns {string} a string which includes the block argument value.
+     */
+    myReporter (args) {
+        // This message contains ICU placeholders, not Scratch placeholders
+        const message = formatMessage({
+            id: 'myReporter.result',
+            defaultMessage: 'Letter {LETTER_NUM} of {TEXT} is {LETTER}.',
+            description: 'The text template for the "myReporter" block result'
+        });
+
+        // Note: this implementation is not Unicode-clean; it's just here as an example.
+        const result = args.TEXT.charAt(args.LETTER_NUM);
+
+        return message.format({
+            LETTER_NUM: args.LETTER_NUM,
+            TEXT: args.TEXT,
+            LETTER: result
+        });
+    };
+}
+```

package.json

@@ -0,0 +1,105 @@
+{
+  "name": "scratch-vm",
+  "version": "0.2.0",
+  "description": "Virtual Machine for Scratch 3.0",
+  "author": "Massachusetts Institute of Technology",
+  "license": "BSD-3-Clause",
+  "homepage": "https://github.com/LLK/scratch-vm#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://[email protected]/LLK/scratch-vm.git"
+  },
+  "main": "./src/index.js",
+  "browser": "./src/index.js",
+  "scripts": {
+    "build": "npm run docs && webpack --progress --colors --bail",
+    "coverage": "tap ./test/{unit,integration}/*.js --coverage --coverage-report=lcov",
+    "deploy": "touch playground/.nojekyll && gh-pages -t -d playground -m \"Build for $(git log --pretty=format:%H -n1)\"",
+    "docs": "exit 0 || jsdoc -c .jsdoc.json",
+    "i18n:src": "mkdirp translations/core && format-message extract --out-file translations/core/en.json src/extensions/**/index.js",
+    "i18n:push": "tx-push-src scratch-editor extensions translations/core/en.json",
+    "lint": "exit 0 || eslint . && format-message lint src/**/*.js",
+    "prepublishOnly": "in-publish && npm run build || not-in-publish",
+    "start": "webpack-dev-server",
+    "tap": "tap ./test/{unit,integration}/*.js",
+    "tap:unit": "tap ./test/unit/*.js",
+    "tap:integration": "tap ./test/integration/*.js",
+    "test": "npm run lint && npm run docs && npm run tap",
+    "watch": "webpack --progress --colors --watch",
+    "version": "json -f package.json -I -e \"this.repository.sha = '$(git log -n1 --pretty=format:%H)'\""
+  },
+  "dependencies": {
+    "@turbowarp/json": "^0.1.2",
+    "@vernier/godirect": "1.5.0",
+    "arraybuffer-loader": "^1.0.6",
+    "atob": "2.1.2",
+    "btoa": "1.2.1",
+    "cannon-es": "0.20.0",
+    "canvas-toBlob": "1.0.0",
+    "decode-html": "2.0.0",
+    "diff-match-patch": "1.0.4",
+    "dompurify": "^3.0.9",
+    "format-message": "6.2.1",
+    "htmlparser2": "^3.10.0",
+    "immutable": "3.8.2",
+    "jszip": "^3.1.5",
+    "lz-string": "^1.5.0",
+    "mathjs": "11.11.1",
+    "matter-js": "^0.20.0",
+    "mersenne-twister": "^1.1.0",
+    "minilog": "3.1.0",
+    "pathfinding": "^0.4.18",
+    "schema-utils": "^2.7.1",
+    "scratch-parser": "git+https://github.com/PenguinMod/PenguinMod-Parser.git#master",
+    "scratch-sb1-converter": "0.2.7",
+    "scratch-translate-extension-languages": "0.0.20191118205314",
+    "simplex-noise": "^4.0.1",
+    "text-encoding": "0.7.0",
+    "three": "0.153.0",
+    "three-mesh-bvh": "0.6.0",
+    "tone": "^14.7.77",
+    "worker-loader": "^1.1.1"
+  },
+  "peerDependencies": {
+    "scratch-svg-renderer": "^0.2.0-prerelease"
+  },
+  "devDependencies": {
+    "@babel/core": "7.13.10",
+    "@babel/preset-env": "7.14.8",
+    "adm-zip": "0.4.11",
+    "babel-eslint": "10.1.0",
+    "babel-loader": "8.2.2",
+    "callsite": "1.0.0",
+    "copy-webpack-plugin": "4.5.4",
+    "docdash": "1.2.0",
+    "eslint": "5.3.0",
+    "eslint-config-scratch": "5.1.0",
+    "expose-loader": "0.7.5",
+    "file-loader": "2.0.0",
+    "format-message-cli": "6.2.0",
+    "gh-pages": "1.2.0",
+    "in-publish": "2.0.1",
+    "js-md5": "0.7.3",
+    "jsdoc": "3.6.6",
+    "json": "^9.0.4",
+    "lodash.defaultsdeep": "4.6.1",
+    "pngjs": "3.3.3",
+    "ml5": "^0.12.2",
+    "scratch-audio": "0.1.0-prerelease.20200528195344",
+    "scratch-blocks": "git+https://github.com/PenguinMod/PenguinMod-Blocks.git#develop-builds",
+    "scratch-l10n": "3.14.20220526031602",
+    "scratch-render": "0.1.0-prerelease.20211028200436",
+    "scratch-render-fonts": "github:PenguinMod/penguinmod-render-fonts#master",
+    "scratch-storage": "git+https://github.com/PenguinMod/PenguinMod-Storage.git#develop",
+    "scratch-svg-renderer": "0.2.0-prerelease.20210727023023",
+    "script-loader": "0.7.2",
+    "stats.js": "0.17.0",
+    "tap": "12.0.1",
+    "tiny-worker": "2.3.0",
+    "uglifyjs-webpack-plugin": "1.2.7",
+    "webpack": "4.46.0",
+    "webpack-cli": "3.1.0",
+    "webpack-dev-server": "3.11.2"
+  },
+  "private": true
+}

renovate.json5

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+
+  "extends": [
+    "github>LLK/scratch-renovate-config:conservative"
+  ]
+}

src/.eslintrc.js

@@ -0,0 +1,32 @@
+module.exports = {
+    root: true,
+    extends: ['scratch', 'scratch/es6'],
+    env: {
+        browser: true
+    },
+    rules: {
+        'no-case-declarations': 'off',
+        'no-console': 'off',
+        'no-shadow': 'off',
+        'quotes': 'off',
+        'prefer-template': 'warn',
+        'linebreak-style': 'off',
+        'no-alert': 'off',
+        'quote-props': 'off',
+        'no-trailing-spaces': 'off',
+        'object-curly-spacing': 'off',
+        'curly': 'off',
+        'operator-linebreak': 'off',
+        'one-var': 'off',
+        'brace-style': 'off',
+        'camelcase': 'off',
+        'comma-spacing': 'off',
+        'no-negated-condition': 'off',
+        // @todo please jg, stop having your formater REMOVE THE SPACES
+        'space-before-function-paren': 'off',
+        'no-throw-literal': 'off'
+    },
+    "globals": {
+        "vm": true
+    },
+};

src/blocks/pm_live tests.js

@@ -0,0 +1,38 @@
+/*
+compiled blocks:
+    sensing_set_of: jsgen.js@1195, irgen.js@1420
+*/
+const Cast = require('../util/cast');
+
+class pmLiveTests {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            looks_setVertTransform: this.setVerticalTransform,
+            looks_setHorizTransform: this.setHorizontalTransform
+        };
+    }
+
+    setVerticalTransform (args, {target}) {
+        const percent = Cast.toNumber(args.PERCENT) / 100;
+        target.setTransform([percent, target.transform[1]]);
+    }
+
+    setHorizontalTransform (args, {target}) {
+        const percent = Cast.toNumber(args.PERCENT) / 100;
+        target.setTransform([target.transform[0], percent]);
+    }
+}
+
+module.exports = pmLiveTests;

src/blocks/scratch3_control.js

@@ -0,0 +1,345 @@
+const Cast = require('../util/cast');
+const SandboxRunner = require('../util/sandboxed-javascript-runner.js');
+
+class Scratch3ControlBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+
+        /**
+         * The "counter" block value. For compatibility with 2.0.
+         * @type {number}
+         */
+        this._counter = 0; // used by compiler
+
+        /**
+         * The "error" block value.
+         * @type {string}
+         */
+        this._error = ''; // used by compiler
+
+        this.runtime.on('RUNTIME_DISPOSED', this.clearCounter.bind(this));
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            control_repeat: this.repeat,
+            control_repeat_until: this.repeatUntil,
+            control_while: this.repeatWhile,
+            control_for_each: this.forEach,
+            control_forever: this.forever,
+            control_wait: this.wait,
+            control_repeatForSeconds: this.repeatForSeconds,
+            control_waittick: this.waitTick,
+            control_waitsecondsoruntil: this.waitOrUntil,
+            control_wait_until: this.waitUntil,
+            control_if: this.if,
+            control_if_else: this.ifElse,
+            control_stop: this.stop,
+            control_stop_sprite: this.stopSprite,
+            control_create_clone_of: this.createClone,
+            control_delete_this_clone: this.deleteClone,
+            control_delete_clones_of: this.deleteClonesOf,
+            control_get_counter: this.getCounter,
+            control_incr_counter: this.incrCounter,
+            control_decr_counter: this.decrCounter,
+            control_set_counter: this.setCounter,
+            control_clear_counter: this.clearCounter,
+            control_all_at_once: this.allAtOnce,
+            control_backToGreenFlag: this.backToGreenFlag,
+            control_if_return_else_return: this.if_return_else_return,
+            control_javascript_command: this.runJavascript
+        };
+    }
+
+    getMonitored () {
+        return {
+            control_get_counter: {
+                getId: () => 'get_counter'
+            }
+        };
+    }
+
+    backToGreenFlag(_, util) {
+        const thisThread = util.thread.topBlock;
+        this.runtime.emit("PROJECT_START_BEFORE_RESET");
+        this.runtime.threads
+            .filter(thread => thread.topBlock !== thisThread)
+            .forEach(thread => thread.stopThisScript());
+        // green flag behaviour
+        this.runtime.emit("PROJECT_START");
+        this.runtime.updateCurrentMSecs();
+        this.runtime.ioDevices.clock.resetProjectTimer();
+        this.runtime.targets.forEach(target => target.clearEdgeActivatedValues());
+        for (let i = this.runtime.targets.length - 1; i >= 0; i--) {
+            const thisTarget = this.runtime.targets[i];
+            thisTarget.onGreenFlag();
+            if (!thisTarget.isOriginal) {
+                this.runtime.disposeTarget(thisTarget);
+                this.runtime.stopForTarget(thisTarget);
+            }
+        }
+        this.runtime.startHats("event_whenflagclicked");
+    }
+
+    if_return_else_return (args) {
+        return Cast.toBoolean(args.boolean) ? args.TEXT1 : args.TEXT2;
+    }
+
+    getHats () {
+        return {
+            control_start_as_clone: {
+                restartExistingThreads: false
+            }
+        };
+    }
+
+    runJavascript(args) {
+        return new Promise((resolve) => {
+            const js = Cast.toString(args.JS);
+            SandboxRunner.execute(js).then(result => {
+                resolve(result.value);
+            });
+        });
+    }
+
+    repeat (args, util) {
+        const times = Math.round(Cast.toNumber(args.TIMES));
+        // Initialize loop
+        if (typeof util.stackFrame.loopCounter === 'undefined') {
+            util.stackFrame.loopCounter = times;
+        }
+        // Only execute once per frame.
+        // When the branch finishes, `repeat` will be executed again and
+        // the second branch will be taken, yielding for the rest of the frame.
+        // Decrease counter
+        util.stackFrame.loopCounter--;
+        // If we still have some left, start the branch.
+        if (util.stackFrame.loopCounter >= 0) {
+            util.startBranch(1, true);
+        }
+    }
+
+    repeatUntil (args, util) {
+        const condition = Cast.toBoolean(args.CONDITION);
+        // If the condition is false (repeat UNTIL), start the branch.
+        if (!condition) {
+            util.startBranch(1, true);
+        }
+    }
+
+    repeatWhile (args, util) {
+        const condition = Cast.toBoolean(args.CONDITION);
+        // If the condition is true (repeat WHILE), start the branch.
+        if (condition) {
+            util.startBranch(1, true);
+        }
+    }
+
+    forEach (args, util) {
+        const variable = util.target.lookupOrCreateVariable(
+            args.VARIABLE.id, args.VARIABLE.name);
+
+        if (typeof util.stackFrame.index === 'undefined') {
+            util.stackFrame.index = 0;
+        }
+
+        if (util.stackFrame.index < Number(args.VALUE)) {
+            util.stackFrame.index++;
+            variable.value = util.stackFrame.index;
+            util.startBranch(1, true);
+        }
+    }
+
+    waitUntil (args, util) {
+        const condition = Cast.toBoolean(args.CONDITION);
+        if (!condition) {
+            util.yield();
+        }
+    }
+
+    forever (args, util) {
+        util.startBranch(1, true);
+    }
+
+    wait (args, util) {
+        if (util.stackTimerNeedsInit()) {
+            const duration = Math.max(0, 1000 * Cast.toNumber(args.DURATION));
+
+            util.startStackTimer(duration);
+            this.runtime.requestRedraw();
+            util.yield();
+        } else if (!util.stackTimerFinished()) {
+            util.yield();
+        }
+    }
+    
+    repeatForSeconds (args, util) {
+        if (util.stackTimerNeedsInit()) {
+            const duration = Math.max(0, 1000 * Cast.toNumber(args.TIMES));
+
+            util.startStackTimer(duration);
+            this.runtime.requestRedraw();
+            util.startBranch(1, true);
+            util.yield();
+        } else if (!util.stackTimerFinished()) {
+            util.startBranch(1, true);
+            util.yield();
+        }
+    }
+    
+    waitTick (_, util) {
+        util.yieldTick();
+    }
+
+    waitOrUntil (args, util) {
+        const condition = Cast.toBoolean(args.CONDITION);
+        if (!condition) {
+            if (util.stackTimerNeedsInit()) {
+                const duration = Math.max(0, 1000 * Cast.toNumber(args.DURATION));
+
+                util.startStackTimer(duration);
+                this.runtime.requestRedraw();
+                util.yield();
+                return;
+            }
+            if (!util.stackTimerFinished()) {
+                util.yield();
+            }
+        }
+    }
+
+    if (args, util) {
+        const condition = Cast.toBoolean(args.CONDITION);
+        if (condition) {
+            util.startBranch(1, false);
+        }
+    }
+
+    ifElse (args, util) {
+        const condition = Cast.toBoolean(args.CONDITION);
+        if (condition) {
+            util.startBranch(1, false);
+        } else {
+            util.startBranch(2, false);
+        }
+    }
+
+    stop (args, util) {
+        const option = args.STOP_OPTION;
+        if (option === 'all') {
+            util.stopAll();
+        } else if (option === 'other scripts in sprite' ||
+            option === 'other scripts in stage') {
+            util.stopOtherTargetThreads();
+        } else if (option === 'this script') {
+            util.stopThisScript();
+        }
+    }
+
+    stopSprite (args, util) {
+        const option = args.STOP_OPTION;
+        // Set target
+        let target;
+        if (option === '_myself_') {
+            target = util.target;
+        } else if (option === '_stage_') {
+            target = this.runtime.getTargetForStage();
+        } else {
+            target = this.runtime.getSpriteTargetByName(option);
+        }
+        if (!target) return;
+        this.runtime.stopForTarget(target);
+    }
+
+    createClone (args, util) {
+        this._createClone(Cast.toString(args.CLONE_OPTION), util.target);
+    }
+    _createClone (cloneOption, target) { // used by compiler
+        // Set clone target
+        let cloneTarget;
+        if (cloneOption === '_myself_') {
+            cloneTarget = target;
+        } else {
+            cloneTarget = this.runtime.getSpriteTargetByName(cloneOption);
+        }
+
+        // If clone target is not found, return
+        if (!cloneTarget) return;
+
+        // Create clone
+        const newClone = cloneTarget.makeClone();
+        if (newClone) {
+            this.runtime.addTarget(newClone);
+
+            // Place behind the original target.
+            newClone.goBehindOther(cloneTarget);
+        }
+    }
+
+    deleteClone (args, util) {
+        if (util.target.isOriginal) return;
+        this.runtime.disposeTarget(util.target);
+        this.runtime.stopForTarget(util.target);
+    }
+
+    deleteClonesOf (args, util) {
+        const cloneOption = Cast.toString(args.CLONE_OPTION);
+        // Set clone target
+        let cloneTarget;
+        if (cloneOption === '_myself_') {
+            cloneTarget = util.target;
+        } else {
+            cloneTarget = this.runtime.getSpriteTargetByName(cloneOption);
+        }
+
+        // If clone target is not found, return
+        if (!cloneTarget) return;
+        const sprite = cloneTarget.sprite;
+        if (!sprite) return;
+        if (!sprite.clones) return;
+        const cloneList = [].concat(sprite.clones);
+        cloneList.forEach(clone => {
+            if (clone.isOriginal) return;
+            if (clone.isStage) return;
+            this.runtime.disposeTarget(clone);
+            this.runtime.stopForTarget(clone);
+        })
+    }
+
+    getCounter () {
+        return this._counter;
+    }
+
+    setCounter (args) {
+        const num = Cast.toNumber(args.VALUE);
+        this._counter = num;
+    }
+
+    clearCounter () {
+        this._counter = 0;
+    }
+
+    incrCounter () {
+        this._counter++;
+    }
+    
+    decrCounter () {
+        this._counter--;
+    }
+
+    allAtOnce (util) {
+        util.thread.peekStackFrame().warpMode = false;
+        util.startBranch(1, false);
+        util.thread.peekStackFrame().warpMode = true;
+    }
+}
+
+module.exports = Scratch3ControlBlocks;

src/blocks/scratch3_core_example.js

@@ -0,0 +1,86 @@
+const BlockType = require('../extension-support/block-type');
+const ArgumentType = require('../extension-support/argument-type');
+
+/* eslint-disable-next-line max-len */
+const blockIconURI = 'data:image/svg+xml,%3Csvg id="rotate-counter-clockwise" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"%3E%3Cdefs%3E%3Cstyle%3E.cls-1%7Bfill:%233d79cc;%7D.cls-2%7Bfill:%23fff;%7D%3C/style%3E%3C/defs%3E%3Ctitle%3Erotate-counter-clockwise%3C/title%3E%3Cpath class="cls-1" d="M22.68,12.2a1.6,1.6,0,0,1-1.27.63H13.72a1.59,1.59,0,0,1-1.16-2.58l1.12-1.41a4.82,4.82,0,0,0-3.14-.77,4.31,4.31,0,0,0-2,.8,4.25,4.25,0,0,0-1.34,1.73,5.06,5.06,0,0,0,.54,4.62A5.58,5.58,0,0,0,12,17.74h0a2.26,2.26,0,0,1-.16,4.52A10.25,10.25,0,0,1,3.74,18,10.14,10.14,0,0,1,2.25,8.78,9.7,9.7,0,0,1,5.08,4.64,9.92,9.92,0,0,1,9.66,2.5a10.66,10.66,0,0,1,7.72,1.68l1.08-1.35a1.57,1.57,0,0,1,1.24-.6,1.6,1.6,0,0,1,1.54,1.21l1.7,7.37A1.57,1.57,0,0,1,22.68,12.2Z"/%3E%3Cpath class="cls-2" d="M21.38,11.83H13.77a.59.59,0,0,1-.43-1l1.75-2.19a5.9,5.9,0,0,0-4.7-1.58,5.07,5.07,0,0,0-4.11,3.17A6,6,0,0,0,7,15.77a6.51,6.51,0,0,0,5,2.92,1.31,1.31,0,0,1-.08,2.62,9.3,9.3,0,0,1-7.35-3.82A9.16,9.16,0,0,1,3.17,9.12,8.51,8.51,0,0,1,5.71,5.4,8.76,8.76,0,0,1,9.82,3.48a9.71,9.71,0,0,1,7.75,2.07l1.67-2.1a.59.59,0,0,1,1,.21L22,11.08A.59.59,0,0,1,21.38,11.83Z"/%3E%3C/svg%3E';
+
+/**
+ * An example core block implemented using the extension spec.
+ * This is not loaded as part of the core blocks in the VM but it is provided
+ * and used as part of tests.
+ */
+class Scratch3CoreExample {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * @returns {object} metadata for this extension and its blocks.
+     */
+    getInfo () {
+        return {
+            id: 'coreExample',
+            name: 'CoreEx', // This string does not need to be translated as this extension is only used as an example.
+            blocks: [
+                {
+                    opcode: 'exampleOpcode',
+                    blockType: BlockType.REPORTER,
+                    text: 'example block'
+                },
+                {
+                    opcode: 'exampleWithInlineImage',
+                    blockType: BlockType.COMMAND,
+                    text: 'block with image [CLOCKWISE] inline',
+                    arguments: {
+                        CLOCKWISE: {
+                            type: ArgumentType.IMAGE,
+                            dataURI: blockIconURI
+                        }
+                    }
+                },
+                {
+                    opcode: 'exampleNodeInputs',
+                    blockType: BlockType.COMMAND,
+                    text: 'block with some node inputs [CLOCKWISE]',
+                    arguments: {
+                        CLOCKWISE: {
+                            type: ArgumentType.POLYGON,
+                            nodes: 3
+                        }
+                    }
+                }
+            ]
+        };
+    }
+
+    /**
+     * Example opcode just returns the name of the stage target.
+     * @returns {string} The name of the first target in the project.
+     */
+    exampleOpcode () {
+        const stage = this.runtime.getTargetForStage();
+        return stage ? stage.getName() : 'no stage yet';
+    }
+
+    exampleWithInlineImage () {
+        return;
+    }
+
+    exampleNodeInputs (args, util) {
+        const nodes = args.CLOCKWISE;
+        this.runtime.ext_pen._penUp(util.target);
+        this.runtime.ext_pen.clear();
+        util.target.setXY(nodes[0].x, nodes[0].y);
+        this.runtime.ext_pen._penDown(util.target);
+        nodes.forEach(node => {
+            util.target.setXY(node.x, node.y);
+        });
+        util.target.setXY(nodes[0].x, nodes[0].y);
+    }
+}
+
+module.exports = Scratch3CoreExample;

src/blocks/scratch3_data.js

@@ -0,0 +1,327 @@
+const Cast = require('../util/cast');
+const { validateArray } = require('../util/json-block-utilities');
+
+class Scratch3DataBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            data_variable: this.getVariable,
+            data_setvariableto: this.setVariableTo,
+            data_changevariableby: this.changeVariableBy,
+            data_hidevariable: this.hideVariable,
+            data_showvariable: this.showVariable,
+            data_listcontents: this.getListContents,
+            data_addtolist: this.addToList,
+            data_deleteoflist: this.deleteOfList,
+            data_deletealloflist: this.deleteAllOfList,
+            data_insertatlist: this.insertAtList,
+            data_replaceitemoflist: this.replaceItemOfList,
+            data_itemoflist: this.getItemOfList,
+            data_itemnumoflist: this.getItemNumOfList,
+            data_lengthoflist: this.lengthOfList,
+            data_listcontainsitem: this.listContainsItem,
+            data_hidelist: this.hideList,
+            data_showlist: this.showList,
+            data_reverselist: this.data_reverselist,
+            data_itemexistslist: this.data_itemexistslist,
+            data_listisempty: this.data_listisempty,
+            data_listarray: this.data_listarray,
+            data_arraylist: this.data_arraylist,
+            data_listforeachnum: this.data_listforeachnum,
+            data_listforeachitem: this.data_listforeachitem
+        };
+    }
+
+    data_reverselist (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        list.value.reverse();
+        list._monitorUpToDate = false;
+    }
+    data_itemexistslist (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        const index = Cast.toListIndex(args.INDEX, list.value.length, false);
+        if (index === Cast.LIST_INVALID) {
+            return false;
+        }
+        return true;
+    }
+    data_listisempty (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        return list.value.length < 1;
+    }
+    data_listarray (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        return JSON.stringify(list.value);
+    }
+    data_arraylist (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        const array = validateArray(args.VALUE).array
+            .map(v => {
+                if (typeof v === 'object') return JSON.stringify(v);
+                return String(v);
+            });
+        list.value = array;
+    }
+    data_listforeachnum (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        if (typeof util.stackFrame.loopCounter === 'undefined') {
+            util.stackFrame.loopCounter = list.value.length;
+        }
+        // Only execute once per frame.
+        // When the branch finishes, `repeat` will be executed again and
+        // the second branch will be taken, yielding for the rest of the frame.
+        // Decrease counter
+        util.stackFrame.loopCounter--;
+        // If we still have some left, start the branch.
+        if (util.stackFrame.loopCounter >= 0) {
+            this.setVariableTo({
+                VARIABLE: args.INDEX,
+                VALUE: util.stackFrame.loopCounter
+            }, util);
+            util.startBranch(1, true);
+        }
+    }
+    data_listforeachitem (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        if (typeof util.stackFrame.loopCounter === 'undefined') {
+            util.stackFrame.loopCounter = list.value.length;
+        }
+        // Only execute once per frame.
+        // When the branch finishes, `repeat` will be executed again and
+        // the second branch will be taken, yielding for the rest of the frame.
+        // Decrease counter
+        util.stackFrame.loopCounter--;
+        // If we still have some left, start the branch.
+        if (util.stackFrame.loopCounter >= 0) {
+            this.setVariableTo({
+                VARIABLE: args.INDEX,
+                VALUE: list.value[util.stackFrame.loopCounter]
+            }, util);
+            util.startBranch(1, true);
+        }
+    }
+
+    getVariable (args, util) {
+        const variable = util.target.lookupOrCreateVariable(
+            args.VARIABLE.id, args.VARIABLE.name);
+        return variable.value;
+    }
+
+    setVariableTo (args, util) {
+        const variable = util.target.lookupOrCreateVariable(
+            args.VARIABLE.id, args.VARIABLE.name);
+        variable.value = args.VALUE;
+
+        if (variable.isCloud) {
+            util.ioQuery('cloud', 'requestUpdateVariable', [variable.name, args.VALUE]);
+        }
+    }
+
+    changeVariableBy (args, util) {
+        const variable = util.target.lookupOrCreateVariable(
+            args.VARIABLE.id, args.VARIABLE.name);
+        const castedValue = Cast.toNumber(variable.value);
+        const dValue = Cast.toNumber(args.VALUE);
+        const newValue = castedValue + dValue;
+        variable.value = newValue;
+
+        if (variable.isCloud) {
+            util.ioQuery('cloud', 'requestUpdateVariable', [variable.name, newValue]);
+        }
+    }
+
+    changeMonitorVisibility (id, visible) {
+        // Send the monitor blocks an event like the flyout checkbox event.
+        // This both updates the monitor state and changes the isMonitored block flag.
+        this.runtime.monitorBlocks.changeBlock({
+            id: id, // Monitor blocks for variables are the variable ID.
+            element: 'checkbox', // Mimic checkbox event from flyout.
+            value: visible
+        }, this.runtime);
+    }
+
+    showVariable (args) {
+        this.changeMonitorVisibility(args.VARIABLE.id, true);
+    }
+
+    hideVariable (args) {
+        this.changeMonitorVisibility(args.VARIABLE.id, false);
+    }
+
+    showList (args) {
+        this.changeMonitorVisibility(args.LIST.id, true);
+    }
+
+    hideList (args) {
+        this.changeMonitorVisibility(args.LIST.id, false);
+    }
+
+    getListContents (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+
+        // If block is running for monitors, return copy of list as an array if changed.
+        if (util.thread.updateMonitor) {
+            // Return original list value if up-to-date, which doesn't trigger monitor update.
+            if (list._monitorUpToDate) return list.value;
+            // If value changed, reset the flag and return a copy to trigger monitor update.
+            // Because monitors use Immutable data structures, only new objects trigger updates.
+            list._monitorUpToDate = true;
+            return list.value.slice();
+        }
+
+        // Determine if the list is all single letters.
+        // If it is, report contents joined together with no separator.
+        // If it's not, report contents joined together with a space.
+        let allSingleLetters = true;
+        for (let i = 0; i < list.value.length; i++) {
+            const listItem = list.value[i];
+            if (!((typeof listItem === 'string') &&
+                  (listItem.length === 1))) {
+                allSingleLetters = false;
+                break;
+            }
+        }
+        if (allSingleLetters) {
+            return list.value.join('');
+        }
+        return list.value.join(' ');
+
+    }
+
+    addToList (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        list.value.push(args.ITEM);
+        list._monitorUpToDate = false;
+    }
+
+    deleteOfList (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        const index = Cast.toListIndex(args.INDEX, list.value.length, true);
+        if (index === Cast.LIST_INVALID) {
+            return;
+        } else if (index === Cast.LIST_ALL) {
+            list.value = [];
+            return;
+        }
+        list.value.splice(index - 1, 1);
+        list._monitorUpToDate = false;
+    }
+
+    deleteAllOfList (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        list.value = [];
+        return;
+    }
+
+    insertAtList (args, util) {
+        const item = args.ITEM;
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        const index = Cast.toListIndex(args.INDEX, list.value.length + 1, false);
+        if (index === Cast.LIST_INVALID) {
+            return;
+        }
+        list.value.splice(index - 1, 0, item);
+        list._monitorUpToDate = false;
+    }
+
+    replaceItemOfList (args, util) {
+        const item = args.ITEM;
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        const index = Cast.toListIndex(args.INDEX, list.value.length, false);
+        if (index === Cast.LIST_INVALID) {
+            return;
+        }
+        list.value[index - 1] = item;
+        list._monitorUpToDate = false;
+    }
+
+    getItemOfList (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        const index = Cast.toListIndex(args.INDEX, list.value.length, false);
+        if (index === Cast.LIST_INVALID) {
+            return '';
+        }
+        return list.value[index - 1];
+    }
+
+    getItemNumOfList (args, util) {
+        const item = args.ITEM;
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+
+        // Go through the list items one-by-one using Cast.compare. This is for
+        // cases like checking if 123 is contained in a list [4, 7, '123'] --
+        // Scratch considers 123 and '123' to be equal.
+        for (let i = 0; i < list.value.length; i++) {
+            if (Cast.compare(list.value[i], item) === 0) {
+                return i + 1;
+            }
+        }
+
+        // We don't bother using .indexOf() at all, because it would end up with
+        // edge cases such as the index of '123' in [4, 7, 123, '123', 9].
+        // If we use indexOf(), this block would return 4 instead of 3, because
+        // indexOf() sees the first occurence of the string 123 as the fourth
+        // item in the list. With Scratch, this would be confusing -- after all,
+        // '123' and 123 look the same, so one would expect the block to say
+        // that the first occurrence of '123' (or 123) to be the third item.
+
+        // Default to 0 if there's no match. Since Scratch lists are 1-indexed,
+        // we don't have to worry about this conflicting with the "this item is
+        // the first value" number (in JS that is 0, but in Scratch it's 1).
+        return 0;
+    }
+
+    lengthOfList (args, util) {
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        return list.value.length;
+    }
+
+    listContainsItem (args, util) {
+        const item = args.ITEM;
+        const list = util.target.lookupOrCreateList(
+            args.LIST.id, args.LIST.name);
+        if (list.value.indexOf(item) >= 0) {
+            return true;
+        }
+        // Try using Scratch comparison operator on each item.
+        // (Scratch considers the string '123' equal to the number 123).
+        for (let i = 0; i < list.value.length; i++) {
+            if (Cast.compare(list.value[i], item) === 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    _listFilterItem = ""
+    _listFilterIndex = 0
+}
+
+module.exports = Scratch3DataBlocks;

src/blocks/scratch3_event.js

@@ -0,0 +1,219 @@
+const Cast = require('../util/cast');
+const SandboxRunner = require('../util/sandboxed-javascript-runner.js');
+
+class Scratch3EventBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+
+        this.runtime.on('KEY_PRESSED', key => {
+            this.runtime.startHats('event_whenkeypressed', {
+                KEY_OPTION: key
+            });
+            this.runtime.startHats('event_whenkeypressed', {
+                KEY_OPTION: 'any'
+            });
+        });
+
+        this.runtime.on('KEY_HIT', key => {
+            this.runtime.startHats('event_whenkeyhit', {
+                KEY_OPTION: key
+            });
+            this.runtime.startHats('event_whenkeyhit', {
+                KEY_OPTION: 'any'
+            });
+        });
+
+        this.isStarting = false;
+        this.runtime.on('PROJECT_START_BEFORE_RESET', () => {
+            // we need to remember that the project is starting
+            // otherwise the stop block will run when flag is clicked
+            this.isStarting = true;
+        });
+        this.runtime.on('PROJECT_STOP_ALL', () => {
+            // if green flag is clicked, dont bother starting the hat
+            if (this.isStarting) {
+                this.isStarting = false;
+                return;
+            }
+            // we need to wait for runtime to step once
+            // otherwise the hat will be stopped as soon as it starts
+            this.runtime.once('RUNTIME_STEP_START', () => {
+                this.runtime.startHats('event_whenstopclicked');
+            })
+            this.isStarting = false;
+        });
+        this.runtime.on('RUNTIME_STEP_START', () => {
+            this.runtime.startHats('event_always');
+        });
+
+        this.runtime.on("AFTER_EXECUTE", () => {
+            // Use a timeout as regular Block Threads and Events Blocks dont run at the Same Speed
+            setTimeout(() => {
+                const stage = this.runtime.getTargetForStage();
+                if (!stage) return; // happens when project is loading
+                const stageVars = stage.variables;
+                for (const key in stageVars) {
+                    if (stageVars[key].isSent !== undefined) stageVars[key].isSent = false;
+                }
+            }, 10);
+        });
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            event_whenanything: this.whenanything,
+            event_whenjavascript: this.whenjavascript,
+            event_whentouchingobject: this.touchingObject,
+            event_broadcast: this.broadcast,
+            event_broadcastandwait: this.broadcastAndWait,
+            event_whengreaterthan: this.hatGreaterThanPredicate
+        };
+    }
+
+    whenanything (args) {
+        return Cast.toBoolean(args.ANYTHING);
+    }
+
+    whenjavascript (args) {
+        return new Promise((resolve) => {
+            const js = Cast.toString(args.JS);
+            SandboxRunner.execute(js).then(result => {
+                resolve(result.value === true);
+            })
+        })
+    }
+
+    getHats () {
+        return {
+            event_whenflagclicked: {
+                restartExistingThreads: true
+            },
+            event_whenstopclicked: {
+                restartExistingThreads: true
+            },
+            event_always: {
+                restartExistingThreads: false
+            },
+            event_whenkeypressed: {
+                restartExistingThreads: false
+            },
+            event_whenkeyhit: {
+                restartExistingThreads: false
+            },
+            event_whenmousescrolled: {
+                restartExistingThreads: false
+            },
+            event_whenanything: {
+                restartExistingThreads: false,
+                edgeActivated: true
+            },
+            event_whenjavascript: {
+                restartExistingThreads: false,
+                edgeActivated: true
+            },
+            event_whenthisspriteclicked: {
+                restartExistingThreads: true
+            },
+            event_whentouchingobject: {
+                restartExistingThreads: false,
+                edgeActivated: true
+            },
+            event_whenstageclicked: {
+                restartExistingThreads: true
+            },
+            event_whenbackdropswitchesto: {
+                restartExistingThreads: true
+            },
+            event_whengreaterthan: {
+                restartExistingThreads: false,
+                edgeActivated: true
+            },
+            event_whenbroadcastreceived: {
+                restartExistingThreads: true
+            }
+        };
+    }
+
+    touchingObject (args, util) {
+        return util.target.isTouchingObject(args.TOUCHINGOBJECTMENU);
+    }
+
+    hatGreaterThanPredicate (args, util) {
+        const option = Cast.toString(args.WHENGREATERTHANMENU).toLowerCase();
+        const value = Cast.toNumber(args.VALUE);
+        switch (option) {
+        case 'timer':
+            return util.ioQuery('clock', 'projectTimer') > value;
+        case 'loudness':
+            return this.runtime.audioEngine && this.runtime.audioEngine.getLoudness() > value;
+        }
+        return false;
+    }
+
+    broadcast (args, util) {
+        const broadcastVar = util.runtime.getTargetForStage().lookupBroadcastMsg(
+            args.BROADCAST_OPTION.id, args.BROADCAST_OPTION.name);
+        if (broadcastVar) {
+            const broadcastOption = broadcastVar.name;
+            broadcastVar.isSent = true;
+            util.startHats('event_whenbroadcastreceived', {
+                BROADCAST_OPTION: broadcastOption
+            });
+        }
+    }
+
+    broadcastAndWait (args, util) {
+        if (!util.stackFrame.broadcastVar) {
+            util.stackFrame.broadcastVar = util.runtime.getTargetForStage().lookupBroadcastMsg(
+                args.BROADCAST_OPTION.id, args.BROADCAST_OPTION.name);
+        }
+        if (util.stackFrame.broadcastVar) {
+            const broadcastOption = util.stackFrame.broadcastVar.name;
+            // Have we run before, starting threads?
+            if (!util.stackFrame.startedThreads) {
+                broadcastVar.isSent = true;
+                // No - start hats for this broadcast.
+                util.stackFrame.startedThreads = util.startHats(
+                    'event_whenbroadcastreceived', {
+                        BROADCAST_OPTION: broadcastOption
+                    }
+                );
+                if (util.stackFrame.startedThreads.length === 0) {
+                    // Nothing was started.
+                    return;
+                }
+            }
+            // We've run before; check if the wait is still going on.
+            const instance = this;
+            // Scratch 2 considers threads to be waiting if they are still in
+            // runtime.threads. Threads that have run all their blocks, or are
+            // marked done but still in runtime.threads are still considered to
+            // be waiting.
+            const waiting = util.stackFrame.startedThreads
+                .some(thread => instance.runtime.threads.indexOf(thread) !== -1);
+            if (waiting) {
+                // If all threads are waiting for the next tick or later yield
+                // for a tick as well. Otherwise yield until the next loop of
+                // the threads.
+                if (
+                    util.stackFrame.startedThreads
+                        .every(thread => instance.runtime.isWaitingThread(thread))
+                ) {
+                    util.yieldTick();
+                } else {
+                    util.yield();
+                }
+            }
+        }
+    }
+}
+
+module.exports = Scratch3EventBlocks;

src/blocks/scratch3_looks.js

@@ -0,0 +1,996 @@
+const Cast = require('../util/cast');
+const Color = require('../util/color');
+const Clone = require('../util/clone');
+const uid = require('../util/uid');
+const StageLayering = require('../engine/stage-layering');
+const getMonitorIdForBlockWithArgs = require('../util/get-monitor-id');
+const MathUtil = require('../util/math-util');
+
+/**
+ * @typedef {object} BubbleState - the bubble state associated with a particular target.
+ * @property {Boolean} onSpriteRight - tracks whether the bubble is right or left of the sprite.
+ * @property {?int} drawableId - the ID of the associated bubble Drawable, null if none.
+ * @property {string} text - the text of the bubble.
+ * @property {string} type - the type of the bubble, "say" or "think"
+ * @property {?string} usageId - ID indicating the most recent usage of the say/think bubble.
+ *      Used for comparison when determining whether to clear a say/think bubble.
+ */
+
+class Scratch3LooksBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+
+        this._onTargetChanged = this._onTargetChanged.bind(this);
+        this._onResetBubbles = this._onResetBubbles.bind(this);
+        this._onTargetWillExit = this._onTargetWillExit.bind(this);
+        this._updateBubble = this._updateBubble.bind(this);
+
+        this.SAY_BUBBLE_LIMITdefault = 330;
+        this.SAY_BUBBLE_LIMIT = this.SAY_BUBBLE_LIMITdefault;
+        this.defaultBubble = {
+            MAX_LINE_WIDTH: 170, // Maximum width, in Scratch pixels, of a single line of text
+
+            MIN_WIDTH: 50, // Minimum width, in Scratch pixels, of a text bubble
+            STROKE_WIDTH: 4, // Thickness of the stroke around the bubble.
+            // Only half's visible because it's drawn under the fill
+            PADDING: 10, // Padding around the text area
+            CORNER_RADIUS: 16, // Radius of the rounded corners
+            TAIL_HEIGHT: 12, // Height of the speech bubble's "tail". Probably should be a constant.
+
+            FONT: 'Helvetica', // Font to render the text with
+            FONT_SIZE: 14, // Font size, in Scratch pixels
+            FONT_HEIGHT_RATIO: 0.9, // Height, in Scratch pixels, of the text, as a proportion of the font's size
+            LINE_HEIGHT: 16, // Spacing between each line of text
+
+            COLORS: {
+                BUBBLE_FILL: 'white',
+                BUBBLE_STROKE: 'rgba(0, 0, 0, 0.15)',
+                TEXT_FILL: '#575E75'
+            }
+        };
+
+        // Reset all bubbles on start/stop
+        this.runtime.on('PROJECT_STOP_ALL', this._onResetBubbles);
+        this.runtime.on('targetWasRemoved', this._onTargetWillExit);
+
+        // Enable other blocks to use bubbles like ask/answer
+        this.runtime.on(Scratch3LooksBlocks.SAY_OR_THINK, this._updateBubble);
+    }
+
+    /**
+     * The default bubble state, to be used when a target has no existing bubble state.
+     * @type {BubbleState}
+     */
+    static get DEFAULT_BUBBLE_STATE () {
+        return {
+            drawableId: null,
+            onSpriteRight: true,
+            skinId: null,
+            text: '',
+            type: 'say',
+            usageId: null,
+            // @todo make this read from renderer
+            props: this.defaultBubble
+        };
+    }
+
+    /**
+     * The key to load & store a target's bubble-related state.
+     * @type {string}
+     */
+    static get STATE_KEY () {
+        return 'Scratch.looks';
+    }
+
+    /**
+     * Event name for a text bubble being created or updated.
+     * @const {string}
+     */
+    static get SAY_OR_THINK () {
+        // There are currently many places in the codebase which explicitly refer to this event by the string 'SAY',
+        // so keep this as the string 'SAY' for now rather than changing it to 'SAY_OR_THINK' and breaking things.
+        return 'SAY';
+    }
+
+    /**
+     * Limit for ghost effect
+     * @const {object}
+     */
+    static get EFFECT_GHOST_LIMIT (){
+        return {min: 0, max: 100};
+    }
+
+    /**
+     * Limit for brightness effect
+     * @const {object}
+     */
+    static get EFFECT_BRIGHTNESS_LIMIT (){
+        return {min: -100, max: 100};
+    }
+
+    /**
+     * @param {Target} target - collect bubble state for this target. Probably, but not necessarily, a RenderedTarget.
+     * @returns {BubbleState} the mutable bubble state associated with that target. This will be created if necessary.
+     * @private
+     */
+    _getBubbleState (target) {
+        let bubbleState = target.getCustomState(Scratch3LooksBlocks.STATE_KEY);
+        if (!bubbleState) {
+            bubbleState = Clone.simple(Scratch3LooksBlocks.DEFAULT_BUBBLE_STATE);
+            target.setCustomState(Scratch3LooksBlocks.STATE_KEY, bubbleState);
+        }
+        return bubbleState;
+    }
+
+    /**
+     * resets the text bubble of a sprite
+     * @param {Target} target the target to reset
+     */
+    _resetBubbles (target) {
+        const state = this._getBubbleState(target);
+        this.SAY_BUBBLE_LIMIT = this.SAY_BUBBLE_LIMITdefault;
+        state.props = this.defaultBubble;
+    }
+
+    /**
+     * set any property of the text bubble of any given target
+     * @param {Target} target the target to modify
+     * @param {array} props the property names to change
+     * @param {array} value the values the set the properties to
+     */
+    _setBubbleProperty (target, props, value) {
+        const object = this._getBubbleState(target);
+        if (!object.props) object.props = this.defaultBubble;
+        props.forEach((prop, index) => {
+            if (prop.startsWith('COLORS')) {
+                object.props.COLORS[prop.split('.')[1]] = value[index];
+            } else {
+                object.props[prop] = value[index];
+            }
+        });
+
+        target.setCustomState(Scratch3LooksBlocks.STATE_KEY, object);
+    }
+
+    /**
+     * Handle a target which has moved.
+     * @param {RenderedTarget} target - the target which has moved.
+     * @private
+     */
+    _onTargetChanged (target) {
+        const bubbleState = this._getBubbleState(target);
+        if (bubbleState.drawableId) {
+            this._positionBubble(target);
+        }
+    }
+
+    /**
+     * Handle a target which is exiting.
+     * @param {RenderedTarget} target - the target.
+     * @private
+     */
+    _onTargetWillExit (target) {
+        const bubbleState = this._getBubbleState(target);
+        if (bubbleState.drawableId && bubbleState.skinId) {
+            this.runtime.renderer.destroyDrawable(bubbleState.drawableId, StageLayering.SPRITE_LAYER);
+            this.runtime.renderer.destroySkin(bubbleState.skinId);
+            bubbleState.drawableId = null;
+            bubbleState.skinId = null;
+            this.runtime.requestRedraw();
+        }
+        target.onTargetVisualChange = null;
+    }
+
+    /**
+     * Handle project start/stop by clearing all visible bubbles.
+     * @private
+     */
+    _onResetBubbles () {
+        for (let n = 0; n < this.runtime.targets.length; n++) {
+            const bubbleState = this._getBubbleState(this.runtime.targets[n]);
+            bubbleState.text = '';
+            this._onTargetWillExit(this.runtime.targets[n]);
+        }
+        clearTimeout(this._bubbleTimeout);
+    }
+
+    /**
+     * Position the bubble of a target. If it doesn't fit on the specified side, flip and rerender.
+     * @param {!Target} target Target whose bubble needs positioning.
+     * @private
+     */
+    _positionBubble (target) {
+        if (!target.visible) return;
+        const bubbleState = this._getBubbleState(target);
+        const [bubbleWidth, bubbleHeight] = this.runtime.renderer.getCurrentSkinSize(bubbleState.drawableId);
+        let targetBounds;
+        try {
+            targetBounds = target.getBoundsForBubble();
+        } catch (error_) {
+            // Bounds calculation could fail (e.g. on empty costumes), in that case
+            // use the x/y position of the target.
+            targetBounds = {
+                left: target.x,
+                right: target.x,
+                top: target.y,
+                bottom: target.y
+            };
+        }
+        const stageSize = this.runtime.renderer.getNativeSize();
+        const stageBounds = {
+            left: -stageSize[0] / 2,
+            right: stageSize[0] / 2,
+            top: stageSize[1] / 2,
+            bottom: -stageSize[1] / 2
+        };
+        if (bubbleState.onSpriteRight && bubbleWidth + targetBounds.right > stageBounds.right &&
+            (targetBounds.left - bubbleWidth > stageBounds.left)) { // Only flip if it would fit
+            bubbleState.onSpriteRight = false;
+            this._renderBubble(target);
+        } else if (!bubbleState.onSpriteRight && targetBounds.left - bubbleWidth < stageBounds.left &&
+            (bubbleWidth + targetBounds.right < stageBounds.right)) { // Only flip if it would fit
+            bubbleState.onSpriteRight = true;
+            this._renderBubble(target);
+        } else {
+            this.runtime.renderer.updateDrawablePosition(bubbleState.drawableId, [
+                bubbleState.onSpriteRight ? (
+                    Math.max(
+                        stageBounds.left, // Bubble should not extend past left edge of stage
+                        Math.min(stageBounds.right - bubbleWidth, targetBounds.right)
+                    )
+                ) : (
+                    Math.min(
+                        stageBounds.right - bubbleWidth, // Bubble should not extend past right edge of stage
+                        Math.max(stageBounds.left, targetBounds.left - bubbleWidth)
+                    )
+                ),
+                // Bubble should not extend past the top of the stage
+                Math.min(stageBounds.top, targetBounds.bottom + bubbleHeight)
+            ]);
+            this.runtime.requestRedraw();
+        }
+    }
+
+    /**
+     * Create a visible bubble for a target. If a bubble exists for the target,
+     * just set it to visible and update the type/text. Otherwise create a new
+     * bubble and update the relevant custom state.
+     * @param {!Target} target Target who needs a bubble.
+     * @return {undefined} Early return if text is empty string.
+     * @private
+     */
+    _renderBubble (target) { // used by compiler
+        if (!this.runtime.renderer) return;
+
+        const bubbleState = this._getBubbleState(target);
+        const {type, text, onSpriteRight} = bubbleState;
+
+        // Remove the bubble if target is not visible, or text is being set to blank.
+        if (!target.visible || text === '') {
+            this._onTargetWillExit(target);
+            return;
+        }
+
+        if (bubbleState.skinId) {
+            this.runtime.renderer.updateTextSkin(bubbleState.skinId, type, text, onSpriteRight, bubbleState.props);
+        } else {
+            target.onTargetVisualChange = this._onTargetChanged;
+            bubbleState.drawableId = this.runtime.renderer.createDrawable(StageLayering.SPRITE_LAYER);
+            bubbleState.skinId = this.runtime.renderer.createTextSkin(type, text,
+                bubbleState.onSpriteRight, bubbleState.props);
+            this.runtime.renderer.updateDrawableSkinId(bubbleState.drawableId, bubbleState.skinId);
+        }
+
+        this._positionBubble(target);
+    }
+
+    /**
+     * Properly format text for a text bubble.
+     * @param {string} text The text to be formatted
+     * @return {string} The formatted text
+     * @private
+     */
+    _formatBubbleText (text) {
+        if (text === '') return text;
+
+        // Non-integers should be rounded to 2 decimal places (no more, no less), unless they're small enough that
+        // rounding would display them as 0.00. This matches 2.0's behavior:
+        // https://github.com/LLK/scratch-flash/blob/2e4a402ceb205a042887f54b26eebe1c2e6da6c0/src/scratch/ScratchSprite.as#L579-L585
+        if (typeof text === 'number' &&
+            Math.abs(text) >= 0.01 && text % 1 !== 0) {
+            text = text.toFixed(2);
+        }
+
+        // Limit the length of the string.
+        text = String(text).slice(0, this.SAY_BUBBLE_LIMIT);
+
+        return text;
+    }
+
+    /**
+     * The entry point for say/think blocks. Clears existing bubble if the text is empty.
+     * Set the bubble custom state and then call _renderBubble.
+     * @param {!Target} target Target that say/think blocks are being called on.
+     * @param {!string} type Either "say" or "think"
+     * @param {!string} text The text for the bubble, empty string clears the bubble.
+     * @private
+     */
+    _updateBubble (target, type, text) {
+        const bubbleState = this._getBubbleState(target);
+        bubbleState.type = type;
+        bubbleState.text = this._formatBubbleText(text);
+        bubbleState.usageId = uid();
+        this._renderBubble(target);
+    }
+    _percentToRatio (percent) {
+        return percent / 100;
+    }
+    _doesFontSuport (size, font) {
+        const check = size + 'px ' + font;
+        return document.fonts.check(check);
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            looks_say: this.say,
+            looks_sayforsecs: this.sayforsecs,
+            looks_think: this.think,
+            looks_thinkforsecs: this.thinkforsecs,
+            looks_setFont: this.setFont,
+            looks_setColor: this.setColor,
+            looks_setShape: this.setShape,
+            looks_show: this.show,
+            looks_hide: this.hide,
+            looks_getSpriteVisible: this.getSpriteVisible,
+            looks_getOtherSpriteVisible: this.getOtherSpriteVisible,
+            looks_hideallsprites: () => {}, // legacy no-op block
+            looks_switchcostumeto: this.switchCostume,
+            looks_switchbackdropto: this.switchBackdrop,
+            looks_switchbackdroptoandwait: this.switchBackdropAndWait,
+            looks_nextcostume: this.nextCostume,
+            looks_nextbackdrop: this.nextBackdrop,
+            looks_previouscostume: this.previousCostume,
+            looks_previousbackdrop: this.previousBackdrop,
+            looks_changeeffectby: this.changeEffect,
+            looks_seteffectto: this.setEffect,
+            looks_cleargraphiceffects: this.clearEffects,
+            looks_getEffectValue: this.getEffectValue,
+            looks_changesizeby: this.changeSize,
+            looks_setsizeto: this.setSize,
+            looks_changestretchby: () => {},
+            looks_setstretchto: this.stretchSet,
+            looks_gotofrontback: this.goToFrontBack,
+            looks_goforwardbackwardlayers: this.goForwardBackwardLayers,
+            looks_goTargetLayer: this.goTargetLayer,
+            looks_layersSetLayer: this.setSpriteLayer,
+            looks_layersGetLayer: this.getSpriteLayer,
+            looks_size: this.getSize,
+            looks_costumenumbername: this.getCostumeNumberName,
+            looks_backdropnumbername: this.getBackdropNumberName,
+            looks_setStretch: this.stretchSet,
+            looks_changeStretch: this.changeStretch,
+            looks_stretchGetX: this.getStretchX,
+            looks_stretchGetY: this.getStretchY,
+            looks_sayWidth: this.getBubbleWidth,
+            looks_sayHeight: this.getBubbleHeight,
+            looks_changeVisibilityOfSprite: this.showOrHideSprite,
+            looks_changeVisibilityOfSpriteShow: this.showSprite,
+            looks_changeVisibilityOfSpriteHide: this.hideSprite,
+            looks_stoptalking: this.stopTalking,
+            looks_getinputofcostume: this.getCostumeValue,
+            looks_tintColor: this.getTintColor,
+            looks_setTintColor: this.setTintColor
+        };
+    }
+
+    getSpriteLayer (_, util) {
+        const target = util.target;
+        return target.getLayerOrder();
+    }
+
+    setSpriteLayer (args, util) {
+        const target = util.target;
+        const targetLayer = Cast.toNumber(args.NUM);
+        const currentLayer = target.getLayerOrder();
+        // i dont know how to set layer lol
+        target.goForwardLayers(targetLayer - currentLayer);
+    }
+
+    _getBubbleSize (target) {
+        const bubbleState = this._getBubbleState(target);
+        return this.runtime.renderer.getSkinSize(bubbleState.skinId);
+    }
+
+    getBubbleWidth (_, util) {
+        const target = util.target;
+        let val = 0;
+        try {
+            val = this._getBubbleSize(target)[0];
+        } catch {
+            val = 0;
+        }
+        return val;
+    }
+
+    getBubbleHeight (_, util) {
+        const target = util.target;
+        let val = 0;
+        try {
+            val = this._getBubbleSize(target)[1];
+        } catch {
+            val = 0;
+        }
+        return val;
+    }
+
+    getStretchY (args, util) {
+        return util.target._getRenderedDirectionAndScale().stretch[1];
+    }
+    getStretchX (args, util) {
+        return util.target._getRenderedDirectionAndScale().stretch[0];
+    }
+
+    stretchSet (args, util) {
+        util.target.setStretch(args.X, args.Y);
+    }
+
+    changeStretch(args, util) {
+        let [x, y] = util.target._getRenderedDirectionAndScale().stretch;
+        let new_x = x + Cast.toNumber(args.X)
+        let new_y = y + Cast.toNumber(args.Y)
+        util.target.setStretch(new_x, new_y)
+    }
+
+    setFont (args, util) {
+        this._setBubbleProperty(
+            util.target,
+            ['FONT', 'FONT_SIZE'],
+            [args.font, args.size]
+        );
+    }
+    setColor (args, util) {
+        const numColor = Number(args.color);
+        if (!isNaN(numColor)) {
+            args.color = Color.decimalToHex(numColor);
+        }
+        this._setBubbleProperty(
+            util.target,
+            ['COLORS.' + args.prop],
+            [args.color]
+        );
+    }
+    setShape (args, util) {
+        if (args.prop === 'texlim') {
+            this.SAY_BUBBLE_LIMIT = Math.max(args.color, 1);
+            return;
+        }
+        this._setBubbleProperty(
+            util.target,
+            [args.prop],
+            [args.color]
+        );
+    }
+
+    getMonitored () {
+        return {
+            looks_size: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_size`
+            },
+            looks_stretchGetX: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_stretchX`
+            },
+            looks_stretchGetY: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_stretchY`
+            },
+            looks_sayWidth: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_sayWidth`
+            },
+            looks_sayHeight: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_sayHeight`
+            },
+            looks_getEffectValue: {
+                isSpriteSpecific: true,
+                getId: (targetId, fields) => getMonitorIdForBlockWithArgs(`${targetId}_getEffectValue`, fields)
+            },
+            looks_tintColor: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_tintColor`
+            },
+            looks_getSpriteVisible: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_getSpriteVisible`
+            },
+            looks_layersGetLayer: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_layersGetLayer`
+            },
+            looks_costumenumbername: {
+                isSpriteSpecific: true,
+                getId: (targetId, fields) => getMonitorIdForBlockWithArgs(`${targetId}_costumenumbername`, fields)
+            },
+            looks_backdropnumbername: {
+                getId: (_, fields) => getMonitorIdForBlockWithArgs('backdropnumbername', fields)
+            }
+        };
+    }
+
+    say (args, util) {
+        // @TODO in 2.0 calling say/think resets the right/left bias of the bubble
+        const message = args.MESSAGE;
+        this._say(message, util.target);
+    }
+    _say (message, target) { // used by compiler
+        this.runtime.emit(Scratch3LooksBlocks.SAY_OR_THINK, target, 'say', message);
+    }
+
+    stopTalking (_, util) {
+        this.say({ MESSAGE: '' }, util);
+    }
+
+    sayforsecs (args, util) {
+        this.say(args, util);
+        const target = util.target;
+        const usageId = this._getBubbleState(target).usageId;
+        return new Promise(resolve => {
+            this._bubbleTimeout = setTimeout(() => {
+                this._bubbleTimeout = null;
+                // Clear say bubble if it hasn't been changed and proceed.
+                if (this._getBubbleState(target).usageId === usageId) {
+                    this._updateBubble(target, 'say', '');
+                }
+                resolve();
+            }, 1000 * args.SECS);
+        });
+    }
+
+    think (args, util) {
+        this.runtime.emit(Scratch3LooksBlocks.SAY_OR_THINK, util.target, 'think', args.MESSAGE);
+    }
+
+    thinkforsecs (args, util) {
+        this.think(args, util);
+        const target = util.target;
+        const usageId = this._getBubbleState(target).usageId;
+        return new Promise(resolve => {
+            this._bubbleTimeout = setTimeout(() => {
+                this._bubbleTimeout = null;
+                // Clear think bubble if it hasn't been changed and proceed.
+                if (this._getBubbleState(target).usageId === usageId) {
+                    this._updateBubble(target, 'think', '');
+                }
+                resolve();
+            }, 1000 * args.SECS);
+        });
+    }
+
+    show (args, util) {
+        util.target.setVisible(true);
+        this._renderBubble(util.target);
+    }
+
+    hide (args, util) {
+        util.target.setVisible(false);
+        this._renderBubble(util.target);
+    }
+
+    showOrHideSprite (args, util) {
+        const option = args.VISIBLE_OPTION;
+        const visibleOption = Cast.toString(args.VISIBLE_TYPE).toLowerCase();
+        // Set target
+        let target;
+        if (option === '_myself_') {
+            target = util.target;
+        } else if (option === '_stage_') {
+            target = this.runtime.getTargetForStage();
+        } else {
+            target = this.runtime.getSpriteTargetByName(option);
+        }
+        if (!target) return;
+        target.setVisible(visibleOption === 'show');
+        this._renderBubble(target);
+    }
+
+    showSprite (args, util) {
+        this.showOrHideSprite({ VISIBLE_OPTION: args.VISIBLE_OPTION, VISIBLE_TYPE: "show" }, util);
+    }
+    hideSprite (args, util) {
+        this.showOrHideSprite({ VISIBLE_OPTION: args.VISIBLE_OPTION, VISIBLE_TYPE: "hide" }, util);
+    }
+
+    getSpriteVisible (args, util) {
+        return util.target.visible;
+    }
+
+    getOtherSpriteVisible (args, util) {
+        const option = args.VISIBLE_OPTION;
+        // Set target
+        let target;
+        if (option === '_myself_') {
+            target = util.target;
+        } else if (option === '_stage_') {
+            target = this.runtime.getTargetForStage();
+        } else {
+            target = this.runtime.getSpriteTargetByName(option);
+        }
+        if (!target) return;
+        return target.visible;
+    }
+
+    getEffectValue (args, util) {
+        const effect = Cast.toString(args.EFFECT).toLowerCase();
+        const effects = util.target.effects;
+        if (!effects.hasOwnProperty(effect)) return 0;
+        const value = Cast.toNumber(effects[effect]);
+        return value;
+    }
+
+    getTintColor (_, util) {
+        const effects = util.target.effects;
+        if (typeof effects.tintColor !== 'number') return '#ffffff';
+        return Color.decimalToHex(effects.tintColor - 1);
+    }
+    setTintColor (args, util) { // used by compiler
+        const rgb = Cast.toRgbColorObject(args.color);
+        const decimal = Color.rgbToDecimal(rgb);
+        util.target.setEffect("tintColor", decimal + 1);
+    }
+
+    /**
+     * Utility function to set the costume of a target.
+     * Matches the behavior of Scratch 2.0 for different types of arguments.
+     * @param {!Target} target Target to set costume to.
+     * @param {Any} requestedCostume Costume requested, e.g., 0, 'name', etc.
+     * @param {boolean=} optZeroIndex Set to zero-index the requestedCostume.
+     * @return {Array.<!Thread>} Any threads started by this switch.
+     */
+    _setCostume (target, requestedCostume, optZeroIndex) { // used by compiler
+        if (typeof requestedCostume === 'number') {
+            // Numbers should be treated as costume indices, always
+            target.setCostume(optZeroIndex ? requestedCostume : requestedCostume - 1);
+        } else {
+            // Strings should be treated as costume names, where possible
+            const costumeIndex = target.getCostumeIndexByName(requestedCostume.toString());
+
+            if (costumeIndex !== -1) {
+                target.setCostume(costumeIndex);
+            } else if (requestedCostume === 'next costume') {
+                target.setCostume(target.currentCostume + 1);
+            } else if (requestedCostume === 'previous costume') {
+                target.setCostume(target.currentCostume - 1);
+            // Try to cast the string to a number (and treat it as a costume index)
+            // Pure whitespace should not be treated as a number
+            // Note: isNaN will cast the string to a number before checking if it's NaN
+            } else if (requestedCostume === 'random costume') {
+                let randomIndex = MathUtil.inclusiveRandIntWithout(
+                    0,
+                    target.sprite.costumes_.length - 1,
+                    target.currentCostume
+                )
+                if (randomIndex >= target.sprite.costumes_.length) {
+                    randomIndex = 0;
+                    // This really only accounts for if there's only 1
+                    // costume.
+                }
+                target.setCostume(randomIndex);
+            } else if (!(isNaN(requestedCostume) || Cast.isWhiteSpace(requestedCostume))) {
+                target.setCostume(optZeroIndex ? Number(requestedCostume) : Number(requestedCostume) - 1);
+            }
+        }
+
+        // Per 2.0, 'switch costume' can't start threads even in the Stage.
+        return [];
+    }
+
+    costumeValueToDefaultNone (value) {
+        switch (value) {
+            case 'width':
+            case 'height':
+            case 'rotation center x':
+            case 'rotation center y':
+                return 0;
+            default:
+                return '';
+        }
+    }
+    getCostumeValue (args, util) {
+        let costumeIndex = 0;
+        const target = util.target
+        const requestedCostume = args.COSTUME;
+        const requestedValue = Cast.toString(args.INPUT);
+        if (typeof requestedCostume === 'number') {
+            // Numbers should be treated as costume indices, always
+            costumeIndex = (requestedCostume === 0) ? 0 : requestedCostume - 1;
+        } else {
+            let noun = target.isStage ? "backdrop" : "costume";
+            switch (Cast.toString(requestedCostume)) {
+                case "next " + noun:
+                    costumeIndex = target.currentCostume + 1;
+                    if (costumeIndex >= target.sprite.costumes_.length) {
+                        costumeIndex = 0
+                        // loop around to front
+                    }
+                    break;
+                case "previous " + noun:
+                    costumeIndex = target.currentCostume - 1;
+                    if (costumeIndex < 0) {
+                        costumeIndex = target.sprite.costumes_.length - 1;
+                        // Loop around to back
+                    }
+                    break;
+                case "random " + noun:
+                    costumeIndex = MathUtil.inclusiveRandIntWithout(
+                        0,
+                        target.sprite.costumes_.length - 1,
+                        target.currentCostume
+                    )
+                    if (costumeIndex >= target.sprite.costumes_.length) {
+                        costumeIndex = 0;
+                        // This really only accounts for if there's only 1
+                        // costume.
+                    }
+                    break;
+                default:
+                    costumeIndex = target.getCostumeIndexByName(Cast.toString(requestedCostume));
+            }
+        }
+        if (costumeIndex < 0) return this.costumeValueToDefaultNone(requestedValue);
+        if (!target.sprite) return this.costumeValueToDefaultNone(requestedValue);
+        if (!target.sprite.costumes_) return this.costumeValueToDefaultNone(requestedValue);
+        const costume = target.sprite.costumes_[costumeIndex];
+        if (!costume) return this.costumeValueToDefaultNone(requestedValue);
+        switch (requestedValue) {
+            case 'width':
+                return costume.size[0];
+            case 'height':
+                return costume.size[1];
+            case 'rotation center x':
+                return costume.rotationCenterX;
+            case 'rotation center y':
+                return costume.rotationCenterY;
+            case 'drawing mode':
+                return ((costume.dataFormat === "svg") ? "Vector" : "Bitmap");
+            default:
+                return '';
+        }
+    }
+
+    /**
+     * Utility function to set the backdrop of a target.
+     * Matches the behavior of Scratch 2.0 for different types of arguments.
+     * @param {!Target} stage Target to set backdrop to.
+     * @param {Any} requestedBackdrop Backdrop requested, e.g., 0, 'name', etc.
+     * @param {boolean=} optZeroIndex Set to zero-index the requestedBackdrop.
+     * @return {Array.<!Thread>} Any threads started by this switch.
+     */
+    _setBackdrop (stage, requestedBackdrop, optZeroIndex) { // used by compiler
+        if (typeof requestedBackdrop === 'number') {
+            // Numbers should be treated as backdrop indices, always
+            stage.setCostume(optZeroIndex ? requestedBackdrop : requestedBackdrop - 1);
+        } else {
+            // Strings should be treated as backdrop names where possible
+            const costumeIndex = stage.getCostumeIndexByName(requestedBackdrop.toString());
+
+            if (costumeIndex !== -1) {
+                stage.setCostume(costumeIndex);
+            } else if (requestedBackdrop === 'next backdrop') {
+                stage.setCostume(stage.currentCostume + 1);
+            } else if (requestedBackdrop === 'previous backdrop') {
+                stage.setCostume(stage.currentCostume - 1);
+            } else if (requestedBackdrop === 'random backdrop') {
+                const numCostumes = stage.getCostumes().length;
+                if (numCostumes > 1) {
+                    // Don't pick the current backdrop, so that the block
+                    // will always have an observable effect.
+                    const lowerBound = 0;
+                    const upperBound = numCostumes - 1;
+                    const costumeToExclude = stage.currentCostume;
+
+                    const nextCostume = MathUtil.inclusiveRandIntWithout(lowerBound, upperBound, costumeToExclude);
+
+                    stage.setCostume(nextCostume);
+                }
+            // Try to cast the string to a number (and treat it as a costume index)
+            // Pure whitespace should not be treated as a number
+            // Note: isNaN will cast the string to a number before checking if it's NaN
+            } else if (!(isNaN(requestedBackdrop) || Cast.isWhiteSpace(requestedBackdrop))) {
+                stage.setCostume(optZeroIndex ? Number(requestedBackdrop) : Number(requestedBackdrop) - 1);
+            }
+        }
+
+        const newName = stage.getCostumes()[stage.currentCostume].name;
+        return this.runtime.startHats('event_whenbackdropswitchesto', {
+            BACKDROP: newName
+        });
+    }
+
+    switchCostume (args, util) {
+        this._setCostume(util.target, args.COSTUME); // used by compiler
+    }
+
+    nextCostume (args, util) {
+        this._setCostume(
+            util.target, util.target.currentCostume + 1, true
+        );
+    }
+
+    previousCostume (args, util) {
+        this._setCostume(
+            util.target, util.target.currentCostume - 1, true
+        );
+    }
+
+    switchBackdrop (args) {
+        this._setBackdrop(this.runtime.getTargetForStage(), args.BACKDROP);
+    }
+
+    switchBackdropAndWait (args, util) {
+        // Have we run before, starting threads?
+        if (!util.stackFrame.startedThreads) {
+            // No - switch the backdrop.
+            util.stackFrame.startedThreads = (
+                this._setBackdrop(
+                    this.runtime.getTargetForStage(),
+                    args.BACKDROP
+                )
+            );
+            if (util.stackFrame.startedThreads.length === 0) {
+                // Nothing was started.
+                return;
+            }
+        }
+        // We've run before; check if the wait is still going on.
+        const instance = this;
+        // Scratch 2 considers threads to be waiting if they are still in
+        // runtime.threads. Threads that have run all their blocks, or are
+        // marked done but still in runtime.threads are still considered to
+        // be waiting.
+        const waiting = util.stackFrame.startedThreads
+            .some(thread => instance.runtime.threads.indexOf(thread) !== -1);
+        if (waiting) {
+            // If all threads are waiting for the next tick or later yield
+            // for a tick as well. Otherwise yield until the next loop of
+            // the threads.
+            if (
+                util.stackFrame.startedThreads
+                    .every(thread => instance.runtime.isWaitingThread(thread))
+            ) {
+                util.yieldTick();
+            } else {
+                util.yield();
+            }
+        }
+    }
+
+    nextBackdrop () {
+        const stage = this.runtime.getTargetForStage();
+        this._setBackdrop(
+            stage, stage.currentCostume + 1, true
+        );
+    }
+
+    previousBackdrop() {
+        const stage = this.runtime.getTargetForStage();
+        this._setBackdrop(
+            stage, stage.currentCostume - 1, true
+        );
+    }
+
+    clampEffect (effect, value) { // used by compiler
+        let clampedValue = value;
+        switch (effect) {
+        case 'ghost':
+            clampedValue = MathUtil.clamp(value,
+                Scratch3LooksBlocks.EFFECT_GHOST_LIMIT.min,
+                Scratch3LooksBlocks.EFFECT_GHOST_LIMIT.max);
+            break;
+        case 'brightness':
+            clampedValue = MathUtil.clamp(value,
+                Scratch3LooksBlocks.EFFECT_BRIGHTNESS_LIMIT.min,
+                Scratch3LooksBlocks.EFFECT_BRIGHTNESS_LIMIT.max);
+            break;
+        }
+        return clampedValue;
+    }
+
+    changeEffect (args, util) {
+        const effect = Cast.toString(args.EFFECT).toLowerCase();
+        const change = Cast.toNumber(args.CHANGE);
+        if (!util.target.effects.hasOwnProperty(effect)) return;
+        let newValue = change + util.target.effects[effect];
+        newValue = this.clampEffect(effect, newValue);
+        util.target.setEffect(effect, newValue);
+    }
+
+    setEffect (args, util) {
+        const effect = Cast.toString(args.EFFECT).toLowerCase();
+        let value = Cast.toNumber(args.VALUE);
+        value = this.clampEffect(effect, value);
+        util.target.setEffect(effect, value);
+    }
+
+    clearEffects (args, util) {
+        util.target.clearEffects();
+        this._resetBubbles(util.target);
+    }
+
+    changeSize (args, util) {
+        const change = Cast.toNumber(args.CHANGE);
+        util.target.setSize(util.target.size + change);
+    }
+
+    setSize (args, util) {
+        const size = Cast.toNumber(args.SIZE);
+        util.target.setSize(size);
+    }
+
+    goToFrontBack (args, util) {
+        if (!util.target.isStage) {
+            if (args.FRONT_BACK === 'front') {
+                util.target.goToFront();
+            } else {
+                util.target.goToBack();
+            }
+        }
+    }
+
+    goForwardBackwardLayers (args, util) {
+        if (!util.target.isStage) {
+            if (args.FORWARD_BACKWARD === 'forward') {
+                util.target.goForwardLayers(Cast.toNumber(args.NUM));
+            } else {
+                util.target.goBackwardLayers(Cast.toNumber(args.NUM));
+            }
+        }
+    }
+
+    goTargetLayer (args, util) {
+        let target;
+        const option = args.VISIBLE_OPTION;
+        if (option === '_stage_') target = this.runtime.getTargetForStage();
+        else target = this.runtime.getSpriteTargetByName(option);
+        if (!util.target.isStage && target) {
+            if (args.FORWARD_BACKWARD === 'infront') {
+                util.target.goBehindOther(target);
+                util.target.goForwardLayers(1);
+            } else {
+                util.target.goBehindOther(target);
+            }
+        }
+    }
+
+    getSize (args, util) {
+        return Math.round(util.target.size);
+    }
+
+    getBackdropNumberName (args) {
+        const stage = this.runtime.getTargetForStage();
+        if (args.NUMBER_NAME === 'number') {
+            return stage.currentCostume + 1;
+        }
+        // Else return name
+        return stage.getCostumes()[stage.currentCostume].name;
+    }
+
+    getCostumeNumberName (args, util) {
+        if (args.NUMBER_NAME === 'number') {
+            return util.target.currentCostume + 1;
+        }
+        // Else return name
+        return util.target.getCostumes()[util.target.currentCostume].name;
+    }
+}
+
+module.exports = Scratch3LooksBlocks;

src/blocks/scratch3_motion.js

@@ -0,0 +1,532 @@
+const Cast = require('../util/cast');
+const MathUtil = require('../util/math-util');
+const Timer = require('../util/timer');
+
+const STAGE_ALIGNMENT = {
+    TOP_LEFT: 'top-left',
+    TOP_RIGHT: 'top-right',
+    BOTTOM_LEFT: 'bottom-left',
+    BOTTOM_RIGHT: 'bottom-right',
+    TOP: 'top',
+    LEFT: 'left',
+    RIGHT: 'right',
+    MIDDLE: 'middle',
+    BOTTOM: 'bottom'
+};
+
+class Scratch3MotionBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            motion_movesteps: this.moveSteps,
+            motion_movebacksteps: this.moveStepsBack,
+            motion_moveupdownsteps: this.moveStepsUpDown,
+            motion_gotoxy: this.goToXY,
+            motion_goto: this.goTo,
+            motion_turnright: this.turnRight,
+            motion_turnleft: this.turnLeft,
+            motion_turnrightaroundxy: this.turnRightAround,
+            motion_turnleftaroundxy: this.turnLeftAround,
+            motion_turnaround: this.turnAround,
+            motion_pointinrandomdirection: this.pointInDirectionRandom,
+            motion_pointtowardsxy: this.pointTowardsXY,
+            motion_pointindirection: this.pointInDirection,
+            motion_pointtowards: this.pointTowards,
+            motion_glidesecstoxy: this.glide,
+            motion_glideto: this.glideTo,
+            motion_ifonedgebounce: this.ifOnEdgeBounce,
+            motion_ifonxybounce: this.ifOnXYBounce,
+            motion_ifonspritebounce: this.ifOnSpriteBounce,
+            motion_setrotationstyle: this.setRotationStyle,
+            motion_changexby: this.changeX,
+            motion_setx: this.setX,
+            motion_changeyby: this.changeY,
+            motion_sety: this.setY,
+            motion_changebyxy: this.changeXY,
+            motion_xposition: this.getX,
+            motion_yposition: this.getY,
+            motion_direction: this.getDirection,
+            motion_move_sprite_to_scene_side: this.moveToStageSide,
+            // Legacy no-op blocks:
+            motion_scroll_right: () => {},
+            motion_scroll_up: () => {},
+            motion_align_scene: () => {},
+            motion_xscroll: () => {},
+            motion_yscroll: () => {}
+        };
+    }
+
+    moveToStageSide(args, util) {
+        if (!this.runtime.renderer) return;
+        const side = Cast.toString(args.ALIGNMENT);
+        const stageWidth = this.runtime.stageWidth / 2;
+        const stageHeight = this.runtime.stageHeight / 2;
+        const snap = [];
+        switch (side) {
+        case STAGE_ALIGNMENT.TOP:
+            util.target.setXY(0, stageHeight);
+            snap.push('top');
+            break;
+        case STAGE_ALIGNMENT.LEFT:
+            util.target.setXY(0 - stageWidth, 0);
+            snap.push('left');
+            break;
+        case STAGE_ALIGNMENT.MIDDLE:
+            util.target.setXY(0, 0);
+            break;
+        case STAGE_ALIGNMENT.RIGHT:
+            util.target.setXY(stageWidth, 0);
+            snap.push('right');
+            break;
+        case STAGE_ALIGNMENT.BOTTOM:
+            util.target.setXY(0, 0 - stageHeight);
+            snap.push('bottom');
+            break;
+        case STAGE_ALIGNMENT.TOP_LEFT:
+            util.target.setXY(0 - stageWidth, stageHeight);
+            snap.push('top');
+            snap.push('left');
+            break;
+        case STAGE_ALIGNMENT.TOP_RIGHT:
+            util.target.setXY(stageWidth, stageHeight);
+            snap.push('top');
+            snap.push('right');
+            break;
+        case STAGE_ALIGNMENT.BOTTOM_LEFT:
+            util.target.setXY(0 - stageWidth, 0 - stageHeight);
+            snap.push('bottom');
+            snap.push('left');
+            break;
+        case STAGE_ALIGNMENT.BOTTOM_RIGHT:
+            util.target.setXY(stageWidth, 0 - stageHeight);
+            snap.push('bottom');
+            snap.push('right');
+            break;
+        }
+        const drawableID = util.target.drawableID;
+        const drawable = this.runtime.renderer._allDrawables[drawableID];
+        const boundingBox = drawable._skin.getFenceBounds(drawable);
+        snap.forEach(side => {
+            switch (side) {
+            case 'top':
+                util.target.setXY(util.target.x, boundingBox.bottom);
+                break;
+            case 'bottom':
+                util.target.setXY(util.target.x, boundingBox.top);
+                break;
+            case 'left':
+                util.target.setXY(boundingBox.right, util.target.y);
+                break;
+            case 'right':
+                util.target.setXY(boundingBox.left, util.target.y);
+                break;
+            }
+        });
+    }
+
+    getMonitored () {
+        return {
+            motion_xposition: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_xposition`
+            },
+            motion_yposition: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_yposition`
+            },
+            motion_direction: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_direction`
+            }
+        };
+    }
+
+    moveSteps (args, util) {
+        const steps = Cast.toNumber(args.STEPS);
+        this._moveSteps(steps, util.target);
+    }
+    moveStepsBack (args, util) {
+        const steps = Cast.toNumber(args.STEPS);
+        this._moveSteps(0 - steps, util.target);
+    }
+    moveStepsUpDown (args, util) {
+        const direction = Cast.toString(args.DIRECTION);
+        const steps = Cast.toNumber(args.STEPS);
+        this.turnLeft({ DEGREES: 90 }, util);
+        if (direction === 'up') {
+            this._moveSteps(steps, util.target);
+        } else if (direction === 'down') {
+            this._moveSteps(0 - steps, util.target);
+        }
+        this.turnRight({ DEGREES: 90 }, util);
+    }
+    _moveSteps (steps, target) { // used by compiler
+        const radians = MathUtil.degToRad(90 - target.direction);
+        const dx = steps * Math.cos(radians);
+        const dy = steps * Math.sin(radians);
+        target.setXY(target.x + dx, target.y + dy);
+    }
+
+    goToXY (args, util) {
+        const x = Cast.toNumber(args.X);
+        const y = Cast.toNumber(args.Y);
+        util.target.setXY(x, y);
+    }
+
+    getTargetXY (targetName, util) {
+        let targetX = 0;
+        let targetY = 0;
+        if (targetName === '_mouse_') {
+            targetX = util.ioQuery('mouse', 'getScratchX');
+            targetY = util.ioQuery('mouse', 'getScratchY');
+        } else if (targetName === '_random_') {
+            const stageWidth = this.runtime.stageWidth;
+            const stageHeight = this.runtime.stageHeight;
+            targetX = Math.round(stageWidth * (Math.random() - 0.5));
+            targetY = Math.round(stageHeight * (Math.random() - 0.5));
+        } else {
+            targetName = Cast.toString(targetName);
+            const goToTarget = this.runtime.getSpriteTargetByName(targetName);
+            if (!goToTarget) return;
+            targetX = goToTarget.x;
+            targetY = goToTarget.y;
+        }
+        return [targetX, targetY];
+    }
+
+    goTo (args, util) {
+        const targetXY = this.getTargetXY(args.TO, util);
+        if (targetXY) {
+            util.target.setXY(targetXY[0], targetXY[1]);
+        }
+    }
+
+    turnRight (args, util) {
+        const degrees = Cast.toNumber(args.DEGREES);
+        util.target.setDirection(util.target.direction + degrees);
+    }
+
+    turnLeft (args, util) {
+        const degrees = Cast.toNumber(args.DEGREES);
+        util.target.setDirection(util.target.direction - degrees);
+    }
+
+    turnRightAround (args, util) {
+        this.turnLeftAround({
+            DEGREES: -Cast.toNumber(args.DEGREES),
+            X: Cast.toNumber(args.X),
+            Y: Cast.toNumber(args.Y)
+        }, util);
+    }
+
+    turnLeftAround (args, util) {
+        const degrees = Cast.toNumber(args.DEGREES);
+
+        const center = {
+            x: Cast.toNumber(args.X),
+            y: Cast.toNumber(args.Y)
+        };
+        const radians = (Math.PI * degrees) / 180;
+        const cos = Math.cos(radians);
+        const sin = Math.sin(radians);
+        const dx = util.target.x - center.x;
+        const dy = util.target.y - center.y;
+        const newPosition = {
+            x: (cos * dx) - (sin * dy) + center.x,
+            y: (cos * dy) + (sin * dx) + center.y
+        };
+        util.target.setXY(newPosition.x, newPosition.y);
+    }
+
+    pointInDirection (args, util) {
+        const direction = Cast.toNumber(args.DIRECTION);
+        util.target.setDirection(direction);
+    }
+
+    turnAround (_, util) {
+        this.turnRight({ DEGREES: 180 }, util);
+    }
+
+    pointInDirectionRandom (_, util) {
+        this.pointTowards({ TOWARDS: '_random_' }, util);
+    }
+
+    pointTowardsXY (args, util) {
+        const targetX = Cast.toNumber(args.X);
+        const targetY = Cast.toNumber(args.Y);
+
+        const dx = targetX - util.target.x;
+        const dy = targetY - util.target.y;
+        const direction = 90 - MathUtil.radToDeg(Math.atan2(dy, dx));
+        util.target.setDirection(direction);
+    }
+
+    pointTowards (args, util) {
+        let targetX = 0;
+        let targetY = 0;
+        if (args.TOWARDS === '_mouse_') {
+            targetX = util.ioQuery('mouse', 'getScratchX');
+            targetY = util.ioQuery('mouse', 'getScratchY');
+        } else if (args.TOWARDS === '_random_') {
+            util.target.setDirection(Math.round(Math.random() * 360) - 180);
+            return;
+        } else {
+            args.TOWARDS = Cast.toString(args.TOWARDS);
+            const pointTarget = this.runtime.getSpriteTargetByName(args.TOWARDS);
+            if (!pointTarget) return;
+            targetX = pointTarget.x;
+            targetY = pointTarget.y;
+        }
+
+        const dx = targetX - util.target.x;
+        const dy = targetY - util.target.y;
+        const direction = 90 - MathUtil.radToDeg(Math.atan2(dy, dx));
+        util.target.setDirection(direction);
+    }
+
+    glide (args, util) {
+        if (util.stackFrame.timer) {
+            const timeElapsed = util.stackFrame.timer.timeElapsed();
+            if (timeElapsed < util.stackFrame.duration * 1000) {
+                // In progress: move to intermediate position.
+                const frac = timeElapsed / (util.stackFrame.duration * 1000);
+                const dx = frac * (util.stackFrame.endX - util.stackFrame.startX);
+                const dy = frac * (util.stackFrame.endY - util.stackFrame.startY);
+                util.target.setXY(
+                    util.stackFrame.startX + dx,
+                    util.stackFrame.startY + dy
+                );
+                util.yield();
+            } else {
+                // Finished: move to final position.
+                util.target.setXY(util.stackFrame.endX, util.stackFrame.endY);
+            }
+        } else {
+            // First time: save data for future use.
+            util.stackFrame.timer = new Timer();
+            util.stackFrame.timer.start();
+            util.stackFrame.duration = Cast.toNumber(args.SECS);
+            util.stackFrame.startX = util.target.x;
+            util.stackFrame.startY = util.target.y;
+            util.stackFrame.endX = Cast.toNumber(args.X);
+            util.stackFrame.endY = Cast.toNumber(args.Y);
+            if (util.stackFrame.duration <= 0) {
+                // Duration too short to glide.
+                util.target.setXY(util.stackFrame.endX, util.stackFrame.endY);
+                return;
+            }
+            util.yield();
+        }
+    }
+
+    glideTo (args, util) {
+        const targetXY = this.getTargetXY(args.TO, util);
+        if (targetXY) {
+            this.glide({SECS: args.SECS, X: targetXY[0], Y: targetXY[1]}, util);
+        }
+    }
+
+    ifOnEdgeBounce (args, util) {
+        this._ifOnEdgeBounce(util.target);
+    }
+    _ifOnEdgeBounce (target) { // used by compiler
+        const bounds = target.getBounds();
+        if (!bounds) {
+            return;
+        }
+        // Measure distance to edges.
+        // Values are positive when the sprite is far away,
+        // and clamped to zero when the sprite is beyond.
+        const stageWidth = this.runtime.stageWidth;
+        const stageHeight = this.runtime.stageHeight;
+        const distLeft = Math.max(0, (stageWidth / 2) + bounds.left);
+        const distTop = Math.max(0, (stageHeight / 2) - bounds.top);
+        const distRight = Math.max(0, (stageWidth / 2) - bounds.right);
+        const distBottom = Math.max(0, (stageHeight / 2) + bounds.bottom);
+        // Find the nearest edge.
+        let nearestEdge = '';
+        let minDist = Infinity;
+        if (distLeft < minDist) {
+            minDist = distLeft;
+            nearestEdge = 'left';
+        }
+        if (distTop < minDist) {
+            minDist = distTop;
+            nearestEdge = 'top';
+        }
+        if (distRight < minDist) {
+            minDist = distRight;
+            nearestEdge = 'right';
+        }
+        if (distBottom < minDist) {
+            minDist = distBottom;
+            nearestEdge = 'bottom';
+        }
+        if (minDist > 0) {
+            return; // Not touching any edge.
+        }
+        // Point away from the nearest edge.
+        const radians = MathUtil.degToRad(90 - target.direction);
+        let dx = Math.cos(radians);
+        let dy = -Math.sin(radians);
+        if (nearestEdge === 'left') {
+            dx = Math.max(0.2, Math.abs(dx));
+        } else if (nearestEdge === 'top') {
+            dy = Math.max(0.2, Math.abs(dy));
+        } else if (nearestEdge === 'right') {
+            dx = 0 - Math.max(0.2, Math.abs(dx));
+        } else if (nearestEdge === 'bottom') {
+            dy = 0 - Math.max(0.2, Math.abs(dy));
+        }
+        const newDirection = MathUtil.radToDeg(Math.atan2(dy, dx)) + 90;
+        target.setDirection(newDirection);
+        // Keep within the stage.
+        const fencedPosition = target.keepInFence(target.x, target.y);
+        target.setXY(fencedPosition[0], fencedPosition[1]);
+    }
+    ifOnXYBounce(args, util, _, __, ___, touchingCondition) {
+        const x = Cast.toNumber(args.X);
+        const y = Cast.toNumber(args.Y);
+        const target = util.target;
+        const bounds = target.getBounds();
+        if (!bounds) {
+            return;
+        }
+        // Check to see if the point is inside the bounding box.
+        const xInBounds = (x >= bounds.left) && (x <= bounds.right);
+        const yInBounds = (y >= bounds.bottom) && (y <= bounds.top);
+        if (touchingCondition !== true) {
+            if (!(xInBounds && yInBounds)) {
+                return; // Not inside the bounding box.
+            }
+        }
+        // Find the distance to the point for all sides.
+        // We use this to figure out which side to bounce on.
+        let nearestEdge = '';
+        let minDist = Infinity;
+        for (let i = 0; i < 4; i++) {
+            const sides = ['left', 'top', 'right', 'bottom'];
+            let distx;
+            let disty;
+            switch (sides[i]) {
+            case 'left':
+            case 'right':
+                distx = x - bounds[sides[i]];
+                disty = y - target.y;
+                break;
+            case 'top':
+            case 'bottom':
+                distx = x - target.x;
+                disty = y - bounds[sides[i]];
+                break;
+            }
+            const distance = Math.sqrt((distx * distx) + (disty * disty));
+            if (distance < minDist) {
+                minDist = distance;
+                nearestEdge = sides[i];
+            }
+        }
+        // Point away from the nearest edge.
+        const radians = MathUtil.degToRad(90 - target.direction);
+        let dx = Math.cos(radians);
+        let dy = -Math.sin(radians);
+        if (nearestEdge === 'left') {
+            dx = Math.max(0.2, Math.abs(dx));
+        } else if (nearestEdge === 'top') {
+            dy = Math.max(0.2, Math.abs(dy));
+        } else if (nearestEdge === 'right') {
+            dx = 0 - Math.max(0.2, Math.abs(dx));
+        } else if (nearestEdge === 'bottom') {
+            dy = 0 - Math.max(0.2, Math.abs(dy));
+        }
+        const newDirection = MathUtil.radToDeg(Math.atan2(dy, dx)) + 90;
+        target.setDirection(newDirection);
+        // Keep within the stage.
+        const fencedPosition = target.keepInFence(target.x, target.y);
+        target.setXY(fencedPosition[0], fencedPosition[1]);
+    }
+    ifOnSpriteBounce (args, util) {
+        if (args.SPRITE === '_mouse_') {
+            const x = util.ioQuery('mouse', 'getScratchX');
+            const y = util.ioQuery('mouse', 'getScratchY');
+            return this.ifOnXYBounce({ X: x, Y: y }, util);
+        } else if (args.SPRITE === '_random_') {
+            const stageWidth = this.runtime.stageWidth;
+            const stageHeight = this.runtime.stageHeight;
+            const x = Math.round(stageWidth * (Math.random() - 0.5));
+            const y = Math.round(stageHeight * (Math.random() - 0.5));
+            return this.ifOnXYBounce({ X: x, Y: y }, util);
+        } 
+        const spriteName = Cast.toString(args.SPRITE);
+        const bounceTarget = this.runtime.getSpriteTargetByName(spriteName);
+        if (!bounceTarget) return;
+        const point = util.target.spriteTouchingPoint(spriteName);
+        if (!point) return;
+        return this.ifOnXYBounce({ X: point[0], Y: point[1] }, util);
+        
+    }
+
+    setRotationStyle (args, util) {
+        util.target.setRotationStyle(args.STYLE);
+    }
+
+    changeX (args, util) {
+        const dx = Cast.toNumber(args.DX);
+        util.target.setXY(util.target.x + dx, util.target.y);
+    }
+
+    setX (args, util) {
+        const x = Cast.toNumber(args.X);
+        util.target.setXY(x, util.target.y);
+    }
+
+    changeY (args, util) {
+        const dy = Cast.toNumber(args.DY);
+        util.target.setXY(util.target.x, util.target.y + dy);
+    }
+
+    setY (args, util) {
+        const y = Cast.toNumber(args.Y);
+        util.target.setXY(util.target.x, y);
+    }
+
+    changeXY (args, util) {
+        const dx = Cast.toNumber(args.DX);
+        const dy = Cast.toNumber(args.DY);
+        util.target.setXY(util.target.x + dx, util.target.y + dy);
+    }
+
+    getX (args, util) {
+        return this.limitPrecision(util.target.x);
+    }
+
+    getY (args, util) {
+        return this.limitPrecision(util.target.y);
+    }
+
+    getDirection (args, util) {
+        return util.target.direction;
+    }
+
+    // This corresponds to snapToInteger in Scratch 2
+    limitPrecision (coordinate) {
+        const rounded = Math.round(coordinate);
+        const delta = coordinate - rounded;
+        const limitedCoord = (Math.abs(delta) < 1e-9) ? rounded : coordinate;
+
+        return limitedCoord;
+    }
+}
+
+module.exports = Scratch3MotionBlocks;

src/blocks/scratch3_operators.js

@@ -0,0 +1,412 @@
+const Cast = require('../util/cast.js');
+const MathUtil = require('../util/math-util.js');
+const SandboxRunner = require('../util/sandboxed-javascript-runner.js');
+const { validateRegex } = require('../util/json-block-utilities');
+
+class Scratch3OperatorsBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    //
+    getPrimitives () {
+        return {
+            operator_add: this.add,
+            operator_subtract: this.subtract,
+            operator_multiply: this.multiply,
+            operator_divide: this.divide,
+            operator_power: this.power,
+            operator_lt: this.lt,
+            operator_equals: this.equals,
+            operator_notequal: this.notequals,
+            operator_gt: this.gt,
+            operator_ltorequal: this.ltorequal,
+            operator_gtorequal: this.gtorequal,
+            operator_and: this.and,
+            operator_nand: this.nand,
+            operator_nor: this.nor,
+            operator_xor: this.xor,
+            operator_xnor: this.xnor,
+            operator_or: this.or,
+            operator_not: this.not,
+            operator_random: this.random,
+            operator_join: this.join,
+            operator_join3: this.join3,
+            operator_letter_of: this.letterOf,
+            operator_length: this.length,
+            operator_contains: this.contains,
+            operator_mod: this.mod,
+            operator_round: this.round,
+            operator_mathop: this.mathop,
+            operator_advlog: this.advlog,
+            operator_regexmatch: this.regexmatch,
+            operator_replaceAll: this.replaceAll,
+            operator_replaceFirst: this.replaceFirst,
+            operator_getLettersFromIndexToIndexInText: this.getLettersFromIndexToIndexInText,
+            operator_getLettersFromIndexToIndexInTextFixed: this.getLettersFromIndexToIndexInTextFixed,
+            operator_readLineInMultilineText: this.readLineInMultilineText,
+            operator_newLine: this.newLine,
+            operator_tabCharacter: this.tabCharacter,
+            operator_stringify: this.stringify,
+            operator_boolify: this.boolify,
+            operator_lerpFunc: this.lerpFunc,
+            operator_advMath: this.advMath,
+            operator_advMathExpanded: this.advMathExpanded,
+            operator_constrainnumber: this.constrainnumber,
+            operator_trueBoolean: this.true,
+            operator_falseBoolean: this.false,
+            operator_randomBoolean: this.randomBoolean,
+            operator_indexOfTextInText: this.indexOfTextInText,
+            operator_lastIndexOfTextInText: this.lastIndexOfTextInText,
+            operator_toUpperLowerCase: this.toCase,
+            operator_character_to_code: this.charToCode,
+            operator_code_to_character: this.codeToChar,
+            operator_textStartsOrEndsWith: this.textStartsOrEndsWith,
+            operator_countAppearTimes: this.countAppearTimes,
+            operator_textIncludesLetterFrom: this.textIncludesLetterFrom,
+            operator_javascript_output: this.javascriptOutput,
+            operator_javascript_boolean: this.javascriptBoolean
+        };
+    }
+    
+    
+    javascriptOutput (args) {
+        return new Promise((resolve, reject) => {
+            const js = Cast.toString(args.JS);
+            SandboxRunner.execute(js).then(result => {
+                resolve(result.value)
+            })
+        })
+    }
+    javascriptBoolean(args) {
+        return new Promise((resolve, reject) => {
+            const js = Cast.toString(args.JS);
+            SandboxRunner.execute(js).then(result => {
+                resolve(result.value === true)
+            })
+        })
+    }
+
+    charToCode (args) {
+        const char = Cast.toString(args.ONE);
+        if (!char) return NaN;
+        return char.charCodeAt(0);
+    }
+    codeToChar (args) {
+        const code = Cast.toNumber(args.ONE);
+        return String.fromCharCode(code);
+    }
+
+    toCase (args) {
+        const text = Cast.toString(args.TEXT);
+        switch (args.OPTION) {
+        case 'upper':
+            return text.toUpperCase();
+        case 'lower':
+            return text.toLowerCase();
+        }
+    }
+
+    indexOfTextInText (args) {
+        const lookfor = Cast.toString(args.TEXT1);
+        const searchin = Cast.toString(args.TEXT2);
+        let index = 0;
+        if (searchin.includes(lookfor)) {
+            index = searchin.indexOf(lookfor) + 1;
+        }
+        return index;
+    }
+
+    lastIndexOfTextInText (args) {
+        const lookfor = Cast.toString(args.TEXT1);
+        const searchin = Cast.toString(args.TEXT2);
+        let index = 0;
+        if (searchin.includes(lookfor)) {
+            index = searchin.lastIndexOf(lookfor) + 1;
+        }
+        return index;
+    }
+
+    textStartsOrEndsWith (args) {
+        const text = Cast.toString(args.TEXT1);
+        const startsOrEnds = Cast.toString(args.OPTION);
+        const withh = Cast.toString(args.TEXT2);
+        return (startsOrEnds === "starts") ? (text.startsWith(withh)) : (text.endsWith(withh));
+    }
+
+    countAppearTimes (args) {
+        const text = Cast.toString(args.TEXT2);
+        const otherText = Cast.toString(args.TEXT1);
+
+        const aray = text.split(otherText);
+        if (aray.length <= 1) {
+            return 0;
+        }
+
+        return aray.length - 1;
+    }
+
+    textIncludesLetterFrom (args) {
+        const text = Cast.toString(args.TEXT1);
+        const from = Cast.toString(args.TEXT2);
+
+        let includes = false;
+
+        const aray = from.split("");
+        aray.forEach(i => {
+            if (text.includes(i)) includes = true;
+        })
+
+        return includes;
+    }
+
+    true () { return true; }
+    false () { return false; }
+    randomBoolean () { return Boolean(Math.round(Math.random())); }
+
+    constrainnumber (args) {
+        return Math.min(Math.max(args.min, args.inp), args.max);
+    }
+
+    lerpFunc (args) {
+        const one = Cast.toNumber(args.ONE);
+        const two = Cast.toNumber(args.TWO);
+        const amount = Cast.toNumber(args.AMOUNT);
+        return ((two - one) * amount) + one;
+    }
+    advMath (args) {
+        const one = isNaN(Cast.toNumber(args.ONE)) ? 0 : Cast.toNumber(args.ONE);
+        const two = isNaN(Cast.toNumber(args.TWO)) ? 0 : Cast.toNumber(args.TWO);
+        const operator = Cast.toString(args.OPTION);
+        switch (operator) {
+        case "^": return one ** two;
+        case "root": return one ** 1 / two;
+        case "log": return Math.log(two) / Math.log(one);
+        default: return 0;
+        }
+    }
+    advMathExpanded (args) {
+        const one = Cast.toNumber(args.ONE);
+        const two = Cast.toNumber(args.TWO);
+        const three = Cast.toNumber(args.THREE);
+        const operator = Cast.toString(args.OPTION);
+        switch (operator) {
+            case "root": return one * Math.pow(three, 1 / two);
+            case "log": return one * Math.log(three) / Math.log(two);
+            default: return 0;
+        }
+    }
+
+    stringify (args) { return Cast.toString(args.ONE); }
+
+    boolify (args) { return Cast.toBoolean(args.ONE); }
+
+    newLine () { return "\n"; }
+
+    tabCharacter () { return "\t"; }
+
+    readLineInMultilineText (args) {
+        const line = (Cast.toNumber(args.LINE) ? Cast.toNumber(args.LINE) : 1) - 1;
+        const text = Cast.toString(args.TEXT);
+        const readline = text.split("\n")[line] || "";
+        return readline;
+    }
+
+    getLettersFromIndexToIndexInTextFixed (args) {
+        const index1 = (Cast.toNumber(args.INDEX1) ? Cast.toNumber(args.INDEX1) : 1) - 1;
+        const index2 = (Cast.toNumber(args.INDEX2) ? Cast.toNumber(args.INDEX2) : 1);
+        const string = Cast.toString(args.TEXT);
+        const substring = string.substring(index1, index2);
+        return substring;
+    }
+    getLettersFromIndexToIndexInText (args) {
+        const index1 = (Cast.toNumber(args.INDEX1) ? Cast.toNumber(args.INDEX1) : 1) - 1;
+        const index2 = (Cast.toNumber(args.INDEX2) ? Cast.toNumber(args.INDEX2) : 1) - 1;
+        const string = Cast.toString(args.TEXT);
+        const substring = string.substring(index1, index2);
+        return substring;
+    }
+
+    replaceAll (args) {
+        return Cast.toString(args.text).replaceAll(args.term, args.res);
+    }
+    replaceFirst (args) {
+        return Cast.toString(args.text).replace(args.term, args.res);
+    }
+
+    regexmatch (args) {
+        if (!validateRegex(args.reg, args.regrule)) return "[]";
+        const regex = new RegExp(args.reg, args.regrule);
+        const matches = args.text.match(regex);
+        return JSON.stringify(matches ? matches : []);
+    }
+
+    add (args) {
+        return Cast.toNumber(args.NUM1) + Cast.toNumber(args.NUM2);
+    }
+
+    subtract (args) {
+        return Cast.toNumber(args.NUM1) - Cast.toNumber(args.NUM2);
+    }
+
+    multiply (args) {
+        return Cast.toNumber(args.NUM1) * Cast.toNumber(args.NUM2);
+    }
+
+    divide (args) {
+        return Cast.toNumber(args.NUM1) / Cast.toNumber(args.NUM2);
+    }
+
+    power (args) {
+        return Math.pow(Cast.toNumber(args.NUM1), Cast.toNumber(args.NUM2));
+    }
+
+    lt (args) {
+        return Cast.compare(args.OPERAND1, args.OPERAND2) < 0;
+    }
+
+    equals (args) {
+        return Cast.compare(args.OPERAND1, args.OPERAND2) === 0;
+    }
+
+    notequals (args) {
+        return !this.equals(args);
+    }
+
+    gt (args) {
+        return Cast.compare(args.OPERAND1, args.OPERAND2) > 0;
+    }
+
+    gtorequal (args) {
+        return !this.lt(args);
+    }
+
+    ltorequal (args) {
+        return !this.gt(args);
+    }
+
+    and (args) {
+        return Cast.toBoolean(args.OPERAND1) && Cast.toBoolean(args.OPERAND2);
+    }
+    
+    nand (args) {
+        return !(Cast.toBoolean(args.OPERAND1) && Cast.toBoolean(args.OPERAND2));
+    }
+
+    nor (args) {
+        return !(Cast.toBoolean(args.OPERAND1) || Cast.toBoolean(args.OPERAND2));
+    }
+
+    xor (args) {
+        const op1 = Cast.toBoolean(args.OPERAND1);
+        const op2 = Cast.toBoolean(args.OPERAND2);
+        return (op1 ? !op2 : op2);
+    }
+
+    xnor (args) {
+        return !this.xor(args);
+    }
+
+    or (args) {
+        return Cast.toBoolean(args.OPERAND1) || Cast.toBoolean(args.OPERAND2);
+    }
+
+    not (args) {
+        return !Cast.toBoolean(args.OPERAND);
+    }
+
+    random (args) {
+        return this._random(args.FROM, args.TO);
+    }
+    _random (from, to) { // used by compiler
+        const nFrom = Cast.toNumber(from);
+        const nTo = Cast.toNumber(to);
+        const low = nFrom <= nTo ? nFrom : nTo;
+        const high = nFrom <= nTo ? nTo : nFrom;
+        if (low === high) return low;
+        // If both arguments are ints, truncate the result to an int.
+        if (Cast.isInt(from) && Cast.isInt(to)) {
+            return low + Math.floor(Math.random() * ((high + 1) - low));
+        }
+        return (Math.random() * (high - low)) + low;
+    }
+
+    join (args) {
+        return Cast.toString(args.STRING1) + Cast.toString(args.STRING2);
+    }
+
+    join3 (args) {
+        return Cast.toString(args.STRING1) + Cast.toString(args.STRING2) + Cast.toString(args.STRING3);
+    }
+
+    letterOf (args) {
+        const index = Cast.toNumber(args.LETTER) - 1;
+        const str = Cast.toString(args.STRING);
+        // Out of bounds?
+        if (index < 0 || index >= str.length) {
+            return '';
+        }
+        return str.charAt(index);
+    }
+
+    length (args) {
+        return Cast.toString(args.STRING).length;
+    }
+
+    contains (args) {
+        const format = function (string) {
+            return Cast.toString(string).toLowerCase();
+        };
+        return format(args.STRING1).includes(format(args.STRING2));
+    }
+
+    mod (args) {
+        const n = Cast.toNumber(args.NUM1);
+        const modulus = Cast.toNumber(args.NUM2);
+        let result = n % modulus;
+        // Scratch mod uses floored division instead of truncated division.
+        if (result / modulus < 0) result += modulus;
+        return result;
+    }
+
+    round (args) {
+        return Math.round(Cast.toNumber(args.NUM));
+    }
+
+    mathop (args) {
+        const operator = Cast.toString(args.OPERATOR).toLowerCase();
+        const n = Cast.toNumber(args.NUM);
+        switch (operator) {
+        case 'abs': return Math.abs(n);
+        case 'floor': return Math.floor(n);
+        case 'ceiling': return Math.ceil(n);
+        case 'sqrt': return Math.sqrt(n);
+        case 'sin': return Math.round(Math.sin((Math.PI * n) / 180) * 1e10) / 1e10;
+        case 'cos': return Math.round(Math.cos((Math.PI * n) / 180) * 1e10) / 1e10;
+        case 'tan': return MathUtil.tan(n);
+        case 'asin': return (Math.asin(n) * 180) / Math.PI;
+        case 'acos': return (Math.acos(n) * 180) / Math.PI;
+        case 'atan': return (Math.atan(n) * 180) / Math.PI;
+        case 'ln': return Math.log(n);
+        case 'log': return Math.log(n) / Math.LN10;
+        case 'log2': return Math.log2(n);
+        case 'e ^': return Math.exp(n);
+        case '10 ^': return Math.pow(10, n);
+        }
+        return 0;
+    }
+    
+    advlog (args) {
+        return (Math.log(Cast.toNumber(args.NUM2)) / Math.log(Cast.toNumber(args.NUM1)));
+    }
+}
+
+module.exports = Scratch3OperatorsBlocks;

src/blocks/scratch3_procedures.js

@@ -0,0 +1,124 @@
+const Cast = require('../util/cast');
+class Scratch3ProcedureBlocks {
+    constructor(runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives() {
+        return {
+            procedures_definition: this.definition,
+            procedures_call: this.call,
+            procedures_set: this.set,
+            argument_reporter_string_number: this.argumentReporterStringNumber,
+            argument_reporter_boolean: this.argumentReporterBoolean,
+            argument_reporter_command: this.argumentReporterCommand
+        };
+    }
+
+    definition() {
+        // No-op: execute the blocks.
+    }
+
+    call (args, util) {
+        if (!util.stackFrame.executed) {
+            const procedureCode = args.mutation.proccode;
+            const paramNamesIdsAndDefaults = util.getProcedureParamNamesIdsAndDefaults(procedureCode);
+
+            // If null, procedure could not be found, which can happen if custom
+            // block is dragged between sprites without the definition.
+            // Match Scratch 2.0 behavior and noop.
+            if (paramNamesIdsAndDefaults === null) {
+                return;
+            }
+
+            const [paramNames, paramIds, paramDefaults] = paramNamesIdsAndDefaults;
+
+            // Initialize params for the current stackFrame to {}, even if the procedure does
+            // not take any arguments. This is so that `getParam` down the line does not look
+            // at earlier stack frames for the values of a given parameter (#1729)
+            util.initParams();
+            for (let i = 0; i < paramIds.length; i++) {
+                if (args.hasOwnProperty(paramIds[i])) {
+                    util.pushParam(paramNames[i], args[paramIds[i]]);
+                } else {
+                    util.pushParam(paramNames[i], paramDefaults[i]);
+                }
+            }
+
+            const addonBlock = util.runtime.getAddonBlock(procedureCode);
+            if (addonBlock) {
+                const result = addonBlock.callback(util.thread.getAllparams(), util);
+                if (util.thread.status === 1 /* STATUS_PROMISE_WAIT */) {
+                    // If the addon block is using STATUS_PROMISE_WAIT to force us to sleep,
+                    // make sure to not re-run this block when we resume.
+                    util.stackFrame.executed = true;
+                }
+                return result;
+            }
+
+            util.stackFrame.executed = true;
+
+            util.startProcedure(procedureCode);
+        }
+    }
+
+    set(args, util) {
+      const contain = util.thread.blockContainer;
+      const block = contain.getBlock(util.thread.isCompiled ? util.thread.peekStack() : util.thread.peekStackFrame().op.id);
+      if (!block) return;
+      const thread = util.thread;
+      const param = contain.getBlock(block.inputs.PARAM?.block);
+      if (param) {
+        try {
+          const curParams = thread.stackFrames[0].params;
+          if (curParams !== null) thread.stackFrames[0].params[param.fields.VALUE.value] = args.VALUE;
+          else thread.stackFrames[0].params = { [param.fields.VALUE.value]: args.VALUE }
+        } catch { /* shouldn't happen */ }
+      }
+    }
+
+    argumentReporterStringNumber(args, util) {
+        const value = util.getParam(args.VALUE);
+        if (value === null) {
+            // When the parameter is not found in the most recent procedure
+            // call, the default is always 0.
+            return 0;
+        }
+        return value;
+    }
+
+    argumentReporterBoolean(args, util) {
+        const value = util.getParam(args.VALUE);
+        if (value === null) {
+            // When the parameter is not found in the most recent procedure
+            // call, the default is always 0.
+            return 0;
+        }
+        return value;
+    }
+
+    argumentReporterCommand(args, util) {
+        const branchInfo = util.getParam(args.VALUE) || {};
+        if (branchInfo.entry === null) return;
+        const [branchId, target] = util.getBranchAndTarget(
+            branchInfo.callerId,
+            branchInfo.entry
+        ) || [];
+        if (branchId) {
+            // Push branch ID to the thread's stack.
+            util.thread.pushStack(branchId, target);
+        } else {
+            util.thread.pushStack(null);
+        }
+    }
+}
+
+module.exports = Scratch3ProcedureBlocks;

src/blocks/scratch3_sensing.js

@@ -0,0 +1,659 @@
+const Cast = require('../util/cast');
+const Timer = require('../util/timer');
+const MathUtil = require('../util/math-util');
+const getMonitorIdForBlockWithArgs = require('../util/get-monitor-id');
+const { validateRegex } = require('../util/json-block-utilities');
+
+class Scratch3SensingBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+
+        /**
+         * The "answer" block value.
+         * @type {string}
+         */
+        this._answer = ''; // used by compiler
+
+        /**
+         * The timer utility.
+         * @type {Timer}
+         */
+        this._timer = new Timer();
+
+        /**
+         * The stored microphone loudness measurement.
+         * @type {number}
+         */
+        this._cachedLoudness = -1;
+
+        /**
+         * The time of the most recent microphone loudness measurement.
+         * @type {number}
+         */
+        this._cachedLoudnessTimestamp = 0;
+
+        /**
+         * The list of loudness values to determine the average.
+         * @type {!Array}
+         */
+        this._loudnessList = [];
+
+        /**
+         * The list of queued questions and respective `resolve` callbacks.
+         * @type {!Array}
+         */
+        this._questionList = [];
+
+        this.runtime.on('ANSWER', this._onAnswer.bind(this));
+        this.runtime.on('PROJECT_START', this._resetAnswer.bind(this));
+        this.runtime.on('PROJECT_STOP_ALL', this._clearAllQuestions.bind(this));
+        this.runtime.on('STOP_FOR_TARGET', this._clearTargetQuestions.bind(this));
+        this.runtime.on('RUNTIME_DISPOSED', this._resetAnswer.bind(this));
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            sensing_objecttouchingobject: this.objectTouchingObject,
+            sensing_objecttouchingclonesprite: this.objectTouchingCloneOfSprite,
+            sensing_touchingobject: this.touchingObject,
+            sensing_touchingcolor: this.touchingColor,
+            sensing_coloristouchingcolor: this.colorTouchingColor,
+            sensing_distanceto: this.distanceTo,
+            sensing_timer: this.getTimer,
+            sensing_resettimer: this.resetTimer,
+            sensing_of: this.getAttributeOf,
+            sensing_mousex: this.getMouseX,
+            sensing_mousey: this.getMouseY,
+            sensing_setdragmode: this.setDragMode,
+            sensing_mousedown: this.getMouseDown,
+            sensing_keypressed: this.getKeyPressed,
+            sensing_current: this.current,
+            sensing_dayssince2000: this.daysSince2000,
+            sensing_loudness: this.getLoudness,
+            sensing_loud: this.isLoud,
+            sensing_askandwait: this.askAndWait,
+            sensing_answer: this.getAnswer,
+            sensing_username: this.getUsername,
+            sensing_loggedin: this.getLoggedIn,
+            sensing_userid: () => {}, // legacy no-op block
+            sensing_regextest: this.regextest,
+            sensing_thing_is_number: this.thing_is_number,
+            sensing_thing_has_number: this.thing_has_number,
+            sensing_mobile: this.mobile,
+            sensing_thing_is_text: this.thing_is_text,
+            sensing_getspritewithattrib: this.getspritewithattrib,
+            sensing_directionTo: this.getDirectionToFrom,
+            sensing_distanceTo: this.getDistanceToFrom,
+            sensing_isUpperCase: this.isCharecterUppercase,
+            sensing_mouseclicked: this.mouseClicked,
+            sensing_keyhit: this.keyHit,
+            sensing_mousescrolling: this.mouseScrolling,
+            sensing_fingerdown: this.fingerDown,
+            sensing_fingertapped: this.fingerTapped,
+            sensing_fingerx: this.getFingerX,
+            sensing_fingery: this.getFingerY,
+            sensing_setclipboard: this.setClipboard,
+            sensing_getclipboard: this.getClipboard,
+            sensing_getdragmode: this.getDragMode,
+            sensing_getoperatingsystem: this.getOS,
+            sensing_getbrowser: this.getBrowser,
+            sensing_geturl: this.getUrl,
+            sensing_getxyoftouchingsprite: this.getXYOfTouchingSprite
+        };
+    }
+
+    getOS () {
+        if (!('userAgent' in navigator)) return 'Unknown';
+        const agent = navigator.userAgent;
+        if (agent.includes('Windows')) {
+            return 'Windows';
+        }
+        if (agent.includes('Android')) {
+            return 'Android';
+        }
+        if (agent.includes('iPad') || agent.includes('iPod') || agent.includes('iPhone')) {
+            return 'iOS';
+        }
+        if (agent.includes('Linux')) {
+            return 'Linux';
+        }
+        if (agent.includes('CrOS')) {
+            return 'ChromeOS';
+        }
+        if (agent.includes('Mac OS')) {
+            return 'MacOS';
+        }
+        return 'Unknown';
+    }
+    getBrowser () {
+        if (!('userAgent' in navigator)) return 'Unknown';
+        const agent = navigator.userAgent;
+        if ('userAgentData' in navigator) {
+            const agentData = JSON.stringify(navigator.userAgentData.brands);
+            if (agentData.includes('Google Chrome')) {
+                return 'Chrome';
+            }
+            if (agentData.includes('Opera')) {
+                return 'Opera';
+            }
+            if (agentData.includes('Microsoft Edge')) {
+                return 'Edge';
+            }
+        }
+        if (agent.includes('Chrome')) {
+            return 'Chrome';
+        }
+        if (agent.includes('Firefox')) {
+            return 'Firefox';
+        }
+        // PenguinMod cannot be loaded in IE 11 (the last supported version)
+        // if (agent.includes('MSIE') || agent.includes('rv:')) {
+        //     return 'Internet Explorer';
+        // }
+        if (agent.includes('Safari')) {
+            return 'Safari';
+        }
+        return 'Unknown';
+    }
+    getUrl () {
+        if (!('href' in location)) return '';
+        return location.href;
+    }
+
+    setClipboard (args) {
+        const text = Cast.toString(args.ITEM);
+        if (!navigator) return;
+        if (('clipboard' in navigator) && ('writeText' in navigator.clipboard)) {
+            navigator.clipboard.writeText(text);
+        }
+    }
+    getClipboard () {
+        if (!navigator) return '';
+        if (('clipboard' in navigator) && ('readText' in navigator.clipboard)) {
+            return navigator.clipboard.readText();
+        } else {
+            return '';
+        }
+    }
+
+    getDragMode (_, util) {
+        return util.target.draggable;
+    }
+
+    mouseClicked (_, util) {
+        return util.ioQuery('mouse', 'getIsClicked');
+    }
+    keyHit (args, util) {
+        return util.ioQuery('keyboard', 'getKeyIsHit', [args.KEY_OPTION]);
+    }
+    mouseScrolling (args, util) {
+        const delta = util.ioQuery('mouseWheel', 'getScrollDelta');
+        const option = args.SCROLL_OPTION;
+        switch (option) {
+            case "up":
+                return delta < 0;
+            case "down":
+                return delta > 0;
+            default:
+                return false;
+        }
+    }
+
+    isCharecterUppercase (args) {
+        return (/[A-Z]/g).test(args.text);
+    }
+
+    getDirectionToFrom (args) {
+        const dx = args.x2 - args.x1;
+        const dy = args.y2 - args.y1;
+        const direction = MathUtil.wrapClamp(90 - MathUtil.radToDeg(Math.atan2(dy, dx)), -179, 180);
+        return direction;
+    }
+
+    getDistanceToFrom (args) {
+        const dx = args.x2 - args.x1;
+        const dy = args.y2 - args.y1;
+        return Math.sqrt((dx * dx) + (dy * dy));
+    }
+
+    getspritewithattrib (args, util) {
+        // strip out usless data
+        const sprites = util.runtime.targets.map(x => ({
+            id: x.id, 
+            name: x.sprite ? x.sprite.name : "Unknown",
+            variables: Object.values(x.variables).reduce((obj, value) => {
+                if (!value.name) return obj;
+                obj[value.name] = String(value.value);
+                return obj;
+            }, {})
+        }));
+        // get the target with variable x set to y
+        let res = "No sprites found";
+        for (
+            // define the index and the sprite
+            let idx = 1, sprite = sprites[0]; 
+            // standard for loop thing
+            idx < sprites.length;
+            // set sprite to a new item  
+            sprite = sprites[idx++]
+        ) {
+            if (sprite.variables[args.var] === args.val) {
+                res = `{"id": "${sprite.id}", "name": "${sprite.name}"}`;
+                break;
+            }
+        }
+        
+        return res;
+    }
+    thing_is_number (args) {
+        // i hate js
+        // i also hate regex
+        // so im gonna do this the lazy way
+        // no. String(Number(value)) === value does infact do the job X)
+        // also what was originaly here was inificiant as hell
+
+        // jg: why dont you literally just do what "is text" did but the opposite
+        // except also account for numbers that end with . (that aint a number)
+        if (Cast.toString(args.TEXT1).trim().endsWith(".")) {
+            return false;
+        }
+        return !this.thing_is_text(args);
+    }
+    thing_is_text (args) {
+        // WHY IS NAN NOT EQUAL TO ITSELF
+        // HOW IS NAN A NUMBER
+        // because nan is how numbers say the value put into me is not a number
+        return isNaN(Number(args.TEXT1));
+    }
+
+    thing_has_number(args) {
+        return /\d/.test(Cast.toString(args.TEXT1));
+    }
+
+    mobile () {
+        return typeof window !== 'undefined' && 'ontouchstart' in window;
+    }
+
+    regextest (args) {
+        if (!validateRegex(args.reg, args.regrule)) return false;
+        const regex = new RegExp(args.reg, args.regrule);
+        return regex.test(args.text);
+    }
+
+    getMonitored () {
+        return {
+            sensing_answer: {
+                getId: () => 'answer'
+            },
+            sensing_mousedown: {
+                getId: () => 'mousedown'
+            },
+            sensing_mouseclicked: {
+                getId: () => 'mouseclicked'
+            },
+            sensing_mousex: {
+                getId: () => 'mousex'
+            },
+            sensing_mousey: {
+                getId: () => 'mousey'
+            },
+            sensing_getclipboard: {
+                getId: () => 'getclipboard'
+            },
+            sensing_getdragmode: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_getdragmode`
+            },
+            sensing_loudness: {
+                getId: () => 'loudness'
+            },
+            sensing_loud: {
+                getId: () => 'loud'
+            },
+            sensing_timer: {
+                getId: () => 'timer'
+            },
+            sensing_dayssince2000: {
+                getId: () => 'dayssince2000'
+            },
+            sensing_current: {
+                // This is different from the default toolbox xml id in order to support
+                // importing multiple monitors from the same opcode from sb2 files,
+                // something that is not currently supported in scratch 3.
+                getId: (_, fields) => getMonitorIdForBlockWithArgs('current', fields) // _${param}`
+            },
+            sensing_loggedin: {
+                getId: () => 'loggedin'
+            },
+        };
+    }
+
+    _onAnswer (answer) {
+        this._answer = answer;
+        const questionObj = this._questionList.shift();
+        if (questionObj) {
+            const [_question, resolve, target, wasVisible, wasStage] = questionObj;
+            // If the target was visible when asked, hide the say bubble unless the target was the stage.
+            if (wasVisible && !wasStage) {
+                this.runtime.emit('SAY', target, 'say', '');
+            }
+            resolve();
+            this._askNextQuestion();
+        }
+    }
+
+    _resetAnswer () {
+        this._answer = '';
+    }
+
+    _enqueueAsk (question, resolve, target, wasVisible, wasStage) {
+        this._questionList.push([question, resolve, target, wasVisible, wasStage]);
+    }
+
+    _askNextQuestion () {
+        if (this._questionList.length > 0) {
+            const [question, _resolve, target, wasVisible, wasStage] = this._questionList[0];
+            // If the target is visible, emit a blank question and use the
+            // say event to trigger a bubble unless the target was the stage.
+            if (wasVisible && !wasStage) {
+                this.runtime.emit('SAY', target, 'say', question);
+                this.runtime.emit('QUESTION', '');
+            } else {
+                this.runtime.emit('QUESTION', question);
+            }
+        }
+    }
+
+    _clearAllQuestions () {
+        this._questionList = [];
+        this.runtime.emit('QUESTION', null);
+    }
+
+    _clearTargetQuestions (stopTarget) {
+        const currentlyAsking = this._questionList.length > 0 && this._questionList[0][2] === stopTarget;
+        this._questionList = this._questionList.filter(question => (
+            question[2] !== stopTarget
+        ));
+
+        if (currentlyAsking) {
+            this.runtime.emit('SAY', stopTarget, 'say', '');
+            if (this._questionList.length > 0) {
+                this._askNextQuestion();
+            } else {
+                this.runtime.emit('QUESTION', null);
+            }
+        }
+    }
+
+    askAndWait (args, util) {
+        const _target = util.target;
+        return new Promise(resolve => {
+            const isQuestionAsked = this._questionList.length > 0;
+            this._enqueueAsk(String(args.QUESTION), resolve, _target, _target.visible, _target.isStage);
+            if (!isQuestionAsked) {
+                this._askNextQuestion();
+            }
+        });
+    }
+
+    getAnswer () {
+        return this._answer;
+    }
+    
+    objectTouchingObject (args, util) {
+        const object1 = (args.FULLTOUCHINGOBJECTMENU) === "_myself_" ? util.target.getName() : args.FULLTOUCHINGOBJECTMENU;
+        const object2 = args.SPRITETOUCHINGOBJECTMENU;
+        if (object2 === "_myself_") {
+            return util.target.isTouchingObject(object1);
+        }
+        const target = this.runtime.getSpriteTargetByName(object2);
+        if (!target) return false;
+        return target.isTouchingObject(object1);
+    }
+    objectTouchingCloneOfSprite (args, util) {
+        const object1 = args.FULLTOUCHINGOBJECTMENU;
+        let object2 = args.SPRITETOUCHINGOBJECTMENU;
+        if (object2 === "_myself_") {
+            object2 = util.target.getName();
+        }
+        if (object1 === "_myself_") {
+            return util.target.isTouchingObject(object2, true);
+        }
+
+        const target = this.runtime.getSpriteTargetByName(object2);
+        if (!target) return false;
+        if (object1 === "_mouse_") {
+            if (!this.runtime.ioDevices.mouse) return false;
+            const mouseX = this.runtime.ioDevices.mouse.getClientX();
+            const mouseY = this.runtime.ioDevices.mouse.getClientY();
+            const clones = target.sprite.clones.filter(clone => !clone.isOriginal && clone.isTouchingPoint(mouseX, mouseY));
+            return clones.length > 0;
+        } else if (object1 === '_edge_') {
+            const clones = target.sprite.clones.filter(clone => !clone.isOriginal && clone.isTouchingEdge());
+            return clones.length > 0;
+        }
+        
+        const originalSprite = this.runtime.getSpriteTargetByName(object1);
+        if (!originalSprite) return false;
+        return originalSprite.isTouchingObject(object2, true);
+    }
+
+    touchingObject (args, util) {
+        return util.target.isTouchingObject(args.TOUCHINGOBJECTMENU);
+    }
+
+    getXYOfTouchingSprite (args, util) {
+        const object = args.SPRITE;
+        if (object === '_mouse_') {
+            // we can just return mouse pos
+            // if mouse is touching us, the mouse size is practically 1x1 anyways
+            const x = util.ioQuery('mouse', 'getScratchX');
+            const y = util.ioQuery('mouse', 'getScratchY');
+            if (args.XY === 'y') return y;
+            return x;
+        }
+        const point = util.target.spriteTouchingPoint(object);
+        if (!point) return '';
+        if (args.XY === 'y') return point[1];
+        return point[0];
+    }
+
+    touchingColor (args, util) {
+        const color = Cast.toRgbColorList(args.COLOR);
+        return util.target.isTouchingColor(color);
+    }
+
+    colorTouchingColor (args, util) {
+        const maskColor = Cast.toRgbColorList(args.COLOR);
+        const targetColor = Cast.toRgbColorList(args.COLOR2);
+        return util.target.colorIsTouchingColor(targetColor, maskColor);
+    }
+
+    distanceTo (args, util) {
+        if (util.target.isStage) return 10000;
+
+        let targetX = 0;
+        let targetY = 0;
+        if (args.DISTANCETOMENU === '_mouse_') {
+            targetX = util.ioQuery('mouse', 'getScratchX');
+            targetY = util.ioQuery('mouse', 'getScratchY');
+        } else {
+            args.DISTANCETOMENU = Cast.toString(args.DISTANCETOMENU);
+            const distTarget = this.runtime.getSpriteTargetByName(
+                args.DISTANCETOMENU
+            );
+            if (!distTarget) return 10000;
+            targetX = distTarget.x;
+            targetY = distTarget.y;
+        }
+
+        const dx = util.target.x - targetX;
+        const dy = util.target.y - targetY;
+        return Math.sqrt((dx * dx) + (dy * dy));
+    }
+
+    setDragMode (args, util) {
+        util.target.setDraggable(args.DRAG_MODE === 'draggable');
+    }
+
+    getTimer (args, util) {
+        return util.ioQuery('clock', 'projectTimer');
+    }
+
+    resetTimer (args, util) {
+        util.ioQuery('clock', 'resetProjectTimer');
+    }
+
+    getMouseX (args, util) {
+        return util.ioQuery('mouse', 'getScratchX');
+    }
+
+    getMouseY (args, util) {
+        return util.ioQuery('mouse', 'getScratchY');
+    }
+
+    getMouseDown (args, util) {
+        return util.ioQuery('mouse', 'getIsDown');
+    }
+
+    getFingerX (args, util) {
+        return util.ioQuery('touch', 'getScratchX', [Cast.toNumber(args.FINGER_OPTION) - 1]);
+    }
+
+    getFingerY (args, util) {
+        return util.ioQuery('touch', 'getScratchY', [Cast.toNumber(args.FINGER_OPTION) - 1]);
+    }
+
+    fingerDown (args, util) {
+        return util.ioQuery('touch', 'getIsDown', [Cast.toNumber(args.FINGER_OPTION) - 1]);
+    }
+
+    fingerTapped (args, util) {
+        return util.ioQuery('touch', 'getIsTapped', [Cast.toNumber(args.FINGER_OPTION) - 1]);
+    }
+
+    current (args) {
+        const menuOption = Cast.toString(args.CURRENTMENU).toLowerCase();
+        const date = new Date();
+        switch (menuOption) {
+        case 'year': return date.getFullYear();
+        case 'month': return date.getMonth() + 1; // getMonth is zero-based
+        case 'date': return date.getDate();
+        case 'dayofweek': return date.getDay() + 1; // getDay is zero-based, Sun=0
+        case 'hour': return date.getHours();
+        case 'minute': return date.getMinutes();
+        case 'second': return date.getSeconds();
+        }
+        return 0;
+    }
+
+    getKeyPressed (args, util) {
+        return util.ioQuery('keyboard', 'getKeyIsDown', [args.KEY_OPTION]);
+    }
+
+    daysSince2000 () {
+        const msPerDay = 24 * 60 * 60 * 1000;
+        const start = new Date(2000, 0, 1); // Months are 0-indexed.
+        const today = new Date();
+        const dstAdjust = today.getTimezoneOffset() - start.getTimezoneOffset();
+        let mSecsSinceStart = today.valueOf() - start.valueOf();
+        mSecsSinceStart += ((today.getTimezoneOffset() - dstAdjust) * 60 * 1000);
+        return mSecsSinceStart / msPerDay;
+    }
+
+    getLoudness () {
+        if (typeof this.runtime.audioEngine === 'undefined') return -1;
+        if (this.runtime.currentStepTime === null) return -1;
+
+        // Only measure loudness once per step
+        const timeSinceLoudness = this._timer.time() - this._cachedLoudnessTimestamp;
+        if (timeSinceLoudness < this.runtime.currentStepTime) {
+            return this._cachedLoudness;
+        }
+
+        this._cachedLoudnessTimestamp = this._timer.time();
+        this._cachedLoudness = this.runtime.audioEngine.getLoudness();
+        this.pushLoudness(this._cachedLoudness);
+        return this._cachedLoudness;
+    }
+
+    isLoud () {
+      this.pushLoudness();
+      let sum = this._loudnessList.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+      sum /= this._loudnessList.length;
+      return this.getLoudness() > sum + 15;
+    }
+    pushLoudness (value) {
+      if (this._loudnessList.length >= 30) this._loudnessList.shift(); // remove first item
+      this._loudnessList.push(value ?? this.getLoudness());
+    }
+    
+    getAttributeOf (args) {
+        let attrTarget;
+
+        if (args.OBJECT === '_stage_') {
+            attrTarget = this.runtime.getTargetForStage();
+        } else {
+            args.OBJECT = Cast.toString(args.OBJECT);
+            attrTarget = this.runtime.getSpriteTargetByName(args.OBJECT);
+        }
+
+        // attrTarget can be undefined if the target does not exist
+        // (e.g. single sprite uploaded from larger project referencing
+        // another sprite that wasn't uploaded)
+        if (!attrTarget) return 0;
+
+        // Generic attributes
+        if (attrTarget.isStage) {
+            switch (args.PROPERTY) {
+            // Scratch 1.4 support
+            case 'background #': return attrTarget.currentCostume + 1;
+
+            case 'backdrop #': return attrTarget.currentCostume + 1;
+            case 'backdrop name':
+                return attrTarget.getCostumes()[attrTarget.currentCostume].name;
+            case 'volume': return attrTarget.volume;
+            }
+        } else {
+            switch (args.PROPERTY) {
+            case 'x position': return attrTarget.x;
+            case 'y position': return attrTarget.y;
+            case 'direction': return attrTarget.direction;
+            case 'costume #': return attrTarget.currentCostume + 1;
+            case 'costume name':
+                return attrTarget.getCostumes()[attrTarget.currentCostume].name;
+            case 'layer': return attrTarget.getLayerOrder();
+            case 'size': return attrTarget.size;
+            case 'volume': return attrTarget.volume;
+            }
+        }
+
+        // Target variables.
+        const varName = args.PROPERTY;
+        const variable = attrTarget.lookupVariableByNameAndType(varName, '', true);
+        if (variable) {
+            return variable.value;
+        }
+
+        // Otherwise, 0
+        return 0;
+    }
+
+    getUsername (args, util) {
+        return util.ioQuery('userData', 'getUsername');
+    }
+
+    getLoggedIn(args, util) {
+        return util.ioQuery('userData', 'getLoggedIn');
+    }
+}
+
+module.exports = Scratch3SensingBlocks;

src/blocks/scratch3_sound.js

@@ -0,0 +1,537 @@
+const MathUtil = require('../util/math-util');
+const Cast = require('../util/cast');
+const Clone = require('../util/clone');
+const getMonitorIdForBlockWithArgs = require('../util/get-monitor-id');
+
+/**
+ * Occluded boolean value to make its use more understandable.
+ * @const {boolean}
+ */
+const STORE_WAITING = true;
+
+class Scratch3SoundBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+
+        this.waitingSounds = {};
+
+        // Clear sound effects on green flag and stop button events.
+        this.stopAllSounds = this.stopAllSounds.bind(this);
+        this._stopWaitingSoundsForTarget = this._stopWaitingSoundsForTarget.bind(this);
+        this._clearEffectsForAllTargets = this._clearEffectsForAllTargets.bind(this);
+        if (this.runtime) {
+            this.runtime.on('PROJECT_STOP_ALL', this.stopAllSounds);
+            this.runtime.on('PROJECT_STOP_ALL', this._clearEffectsForAllTargets);
+            this.runtime.on('STOP_FOR_TARGET', this._stopWaitingSoundsForTarget);
+            this.runtime.on('PROJECT_START', this._clearEffectsForAllTargets);
+        }
+
+        this._onTargetCreated = this._onTargetCreated.bind(this);
+        if (this.runtime) {
+            runtime.on('targetWasCreated', this._onTargetCreated);
+        }
+    }
+
+    /**
+     * The key to load & store a target's sound-related state.
+     * @type {string}
+     */
+    static get STATE_KEY () {
+        return 'Scratch.sound';
+    }
+
+    /**
+     * The default sound-related state, to be used when a target has no existing sound state.
+     * @type {SoundState}
+     */
+    static get DEFAULT_SOUND_STATE () {
+        return {
+            effects: {
+                pitch: 0,
+                pan: 0
+            }
+        };
+    }
+
+    /**
+     * The minimum and maximum MIDI note numbers, for clamping the input to play note.
+     * @type {{min: number, max: number}}
+     */
+    static get MIDI_NOTE_RANGE () {
+        return {min: 36, max: 96}; // C2 to C7
+    }
+
+    /**
+     * The minimum and maximum beat values, for clamping the duration of play note, play drum and rest.
+     * 100 beats at the default tempo of 60bpm is 100 seconds.
+     * @type {{min: number, max: number}}
+     */
+    static get BEAT_RANGE () {
+        return {min: 0, max: 100};
+    }
+
+    /** The minimum and maximum tempo values, in bpm.
+     * @type {{min: number, max: number}}
+     */
+    static get TEMPO_RANGE () {
+        return {min: 20, max: 500};
+    }
+
+    /** The minimum and maximum values for each sound effect.
+     * @type {{effect:{min: number, max: number}}}
+     */
+    static get EFFECT_RANGE () {
+        return {
+            pitch: {min: -360, max: 360}, // -3 to 3 octaves
+            pan: {min: -100, max: 100} // 100% left to 100% right
+        };
+    }
+
+    /** The minimum and maximum values for sound effects when miscellaneous limits are removed. */
+    static get LARGER_EFFECT_RANGE () {
+        return {
+            // scratch-audio throws if pitch is too big because some math results in Infinity
+            pitch: {min: -1000, max: 1000},
+
+            // No reason for these to go beyond 100
+            pan: {min: -100, max: 100}
+        };
+    }
+
+    /**
+     * @param {Target} target - collect sound state for this target.
+     * @returns {SoundState} the mutable sound state associated with that target. This will be created if necessary.
+     * @private
+     */
+    _getSoundState (target) {
+        let soundState = target.getCustomState(Scratch3SoundBlocks.STATE_KEY);
+        if (!soundState) {
+            soundState = Clone.simple(Scratch3SoundBlocks.DEFAULT_SOUND_STATE);
+            target.setCustomState(Scratch3SoundBlocks.STATE_KEY, soundState);
+            target.soundEffects = soundState.effects;
+        }
+        return soundState;
+    }
+
+    /**
+     * When a Target is cloned, clone the sound state.
+     * @param {Target} newTarget - the newly created target.
+     * @param {Target} [sourceTarget] - the target used as a source for the new clone, if any.
+     * @listens Runtime#event:targetWasCreated
+     * @private
+     */
+    _onTargetCreated (newTarget, sourceTarget) {
+        if (sourceTarget) {
+            const soundState = sourceTarget.getCustomState(Scratch3SoundBlocks.STATE_KEY);
+            if (soundState && newTarget) {
+                newTarget.setCustomState(Scratch3SoundBlocks.STATE_KEY, Clone.simple(soundState));
+                this._syncEffectsForTarget(newTarget);
+            }
+        }
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            sound_play: this.playSound,
+            sound_playallsounds: this.playSoundAllLolOpAOIUHFoiubea87fge87iufwhef87wye87fn,
+            sound_playuntildone: this.playSoundAndWait,
+            sound_stop: this.stopSpecificSound,
+            sound_stopallsounds: this.stopAllSounds,
+            sound_seteffectto: this.setEffect,
+            sound_changeeffectby: this.changeEffect,
+            sound_cleareffects: this.clearEffects,
+            sound_sounds_menu: this.soundsMenu,
+            sound_beats_menu: this.beatsMenu,
+            sound_effects_menu: this.effectsMenu,
+            sound_setvolumeto: this.setVolume,
+            sound_changevolumeby: this.changeVolume,
+            sound_volume: this.getVolume,
+            sound_isSoundPlaying: this.isSoundPlaying,
+            sound_getEffectValue: this.getEffectValue,
+            sound_getLength: this.getLength,
+            sound_set_stop_fadeout_to: this.setStopFadeout,
+            sound_play_at_seconds: this.playAtSeconds,
+            sound_play_at_seconds_until_done: this.playAtSecondsAndWait,
+            sound_getSoundVolume: this.currentSoundVolume
+        };
+    }
+
+    getMonitored () {
+        return {
+            sound_volume: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_volume`
+            },
+            sound_getEffectValue: {
+                isSpriteSpecific: true,
+                getId: (targetId, fields) => getMonitorIdForBlockWithArgs(`${targetId}_getEffectValue`, fields)
+            },
+        };
+    }
+
+    currentSoundVolume (args, util) {
+        
+    }
+
+    playAtSeconds (args, util) {
+        const seconds = Cast.toNumber(args.VALUE);
+        if (seconds < 0) {
+            return;
+        }
+        
+        this._playSoundAtTimePosition({
+            sound: Cast.toString(args.SOUND_MENU),
+            seconds: seconds
+        }, util, STORE_WAITING);
+    }
+    playAtSecondsAndWait (args, util) {
+        // return promise
+        const seconds = Cast.toNumber(args.VALUE);
+        if (seconds < 0) {
+            return;
+        }
+
+        return this._playSoundAtTimePosition({
+            sound: Cast.toString(args.SOUND_MENU),
+            seconds: seconds
+        }, util, STORE_WAITING);
+    }
+
+    _playSoundAtTimePosition ({ sound, seconds }, util, storeWaiting) {
+        const index = this._getSoundIndex(sound, util);
+        if (index >= 0) {
+            const {target} = util;
+            const {sprite} = target;
+            const {soundId} = sprite.sounds[index];
+            if (sprite.soundBank) {
+                if (storeWaiting === STORE_WAITING) {
+                    this._addWaitingSound(target.id, soundId);
+                } else {
+                    this._removeWaitingSound(target.id, soundId);
+                }
+                return sprite.soundBank.playSound(target, soundId, seconds);
+            }
+        }
+    }
+
+    setStopFadeout (args, util) {
+        const id = Cast.toString(args.SOUND_MENU);
+        const index = this._getSoundIndex(id, util);
+        if (index < 0) return;
+
+        const target = util.target;
+        const sprite = target.sprite;
+        if (!sprite) return;
+        if (!sprite.sounds) return;
+
+        const { soundId } = sprite.sounds[index];
+
+        const soundBank = sprite.soundBank
+        if (!soundBank) return;
+
+        const decayTime = Cast.toNumber(args.VALUE);
+        if (decayTime <= 0) {
+            soundBank.soundPlayers[soundId].stopFadeDecay = 0;
+            return;
+        }
+
+        soundBank.soundPlayers[soundId].stopFadeDecay = decayTime;
+    }
+
+    getEffectValue (args, util) {
+        const target = util.target;
+
+        const effects = target.soundEffects;
+        if (!effects) return 0;
+
+        const effect = Cast.toString(args.EFFECT).toLowerCase();
+        if (!effects.hasOwnProperty(effect)) return 0;
+        const value = Cast.toNumber(effects[effect]);
+
+        return value;
+    }
+
+    isSoundPlaying (args, util) {
+        const index = this._getSoundIndex(args.SOUND_MENU, util);
+        if (index < 0) return false;
+
+        const target = util.target;
+        const sprite = target.sprite;
+        if (!sprite) return false;
+
+        const { soundId } = sprite.sounds[index];
+
+        const soundBank = sprite.soundBank
+        if (!soundBank) return false;
+        const players = soundBank.soundPlayers;
+        if (!players) return false;
+        if (!players.hasOwnProperty(soundId)) return false;
+
+        return players[soundId].isPlaying == true;
+    }
+
+    getLength (args, util) {
+        const index = this._getSoundIndex(args.SOUND_MENU, util);
+        if (index < 0) return 0;
+
+        const target = util.target;
+        const sprite = target.sprite;
+        if (!sprite) return 0;
+
+        const { soundId } = sprite.sounds[index];
+
+        const soundBank = sprite.soundBank
+        if (!soundBank) return 0;
+        const players = soundBank.soundPlayers;
+        if (!players) return 0;
+        if (!players.hasOwnProperty(soundId)) return 0;
+        const buffer = players[soundId].buffer;
+        if (!buffer) return 0;
+
+        return Cast.toNumber(buffer.duration);
+    }
+
+    stopSpecificSound (args, util) {
+        const index = this._getSoundIndex(args.SOUND_MENU, util);
+        if (index < 0) return;
+
+        const target = util.target;
+        const sprite = target.sprite;
+        if (!sprite) return;
+        
+        const { soundId } = sprite.sounds[index];
+
+        const soundBank = sprite.soundBank
+        if (!soundBank) return;
+
+        soundBank.stop(target, soundId);
+    }
+
+    playSound (args, util) {
+        // Don't return the promise, it's the only difference for AndWait
+        this._playSound(args, util);
+    }
+
+    playSoundAndWait (args, util) {
+        return this._playSound(args, util, STORE_WAITING);
+    }
+
+    _playSound (args, util, storeWaiting) {
+        const index = this._getSoundIndex(args.SOUND_MENU, util);
+        if (index >= 0) {
+            const {target} = util;
+            const {sprite} = target;
+            const {soundId} = sprite.sounds[index];
+            if (sprite.soundBank) {
+                if (storeWaiting === STORE_WAITING) {
+                    this._addWaitingSound(target.id, soundId);
+                } else {
+                    this._removeWaitingSound(target.id, soundId);
+                }
+                return sprite.soundBank.playSound(target, soundId);
+            }
+        }
+    }
+
+    _addWaitingSound (targetId, soundId) {
+        if (!this.waitingSounds[targetId]) {
+            this.waitingSounds[targetId] = new Set();
+        }
+        this.waitingSounds[targetId].add(soundId);
+    }
+
+    _removeWaitingSound (targetId, soundId) {
+        if (!this.waitingSounds[targetId]) {
+            return;
+        }
+        this.waitingSounds[targetId].delete(soundId);
+    }
+
+    _getSoundIndex (soundName, util) {
+        // if the sprite has no sounds, return -1
+        const len = util.target.sprite.sounds.length;
+        if (len === 0) {
+            return -1;
+        }
+
+        // look up by name first
+        const index = this.getSoundIndexByName(soundName, util);
+        if (index !== -1) {
+            return index;
+        }
+
+        // then try using the sound name as a 1-indexed index
+        const oneIndexedIndex = parseInt(soundName, 10);
+        if (!isNaN(oneIndexedIndex)) {
+            return MathUtil.wrapClamp(oneIndexedIndex - 1, 0, len - 1);
+        }
+
+        // could not be found as a name or converted to index, return -1
+        return -1;
+    }
+
+    getSoundIndexByName (soundName, util) {
+        const sounds = util.target.sprite.sounds;
+        for (let i = 0; i < sounds.length; i++) {
+            if (sounds[i].name === soundName) {
+                return i;
+            }
+        }
+        // if there is no sound by that name, return -1
+        return -1;
+    }
+
+    stopAllSounds () {
+        if (this.runtime.targets === null) return;
+        const allTargets = this.runtime.targets;
+        for (let i = 0; i < allTargets.length; i++) {
+            this._stopAllSoundsForTarget(allTargets[i]);
+        }
+    }
+
+    playSoundAllLolOpAOIUHFoiubea87fge87iufwhef87wye87fn (_, util) {
+        const target = util.target;
+        const sprite = target.sprite;
+        if (!sprite) return;
+        for (let i = 0; i < sprite.sounds.length; i++) {
+            const { soundId } = sprite.sounds[i];
+            if (sprite.soundBank) {
+                sprite.soundBank.playSound(target, soundId);
+            }
+        }
+    }
+
+    _stopAllSoundsForTarget (target) {
+        if (target.sprite.soundBank) {
+            target.sprite.soundBank.stopAllSounds(target);
+            if (this.waitingSounds[target.id]) {
+                this.waitingSounds[target.id].clear();
+            }
+        }
+    }
+
+    _stopWaitingSoundsForTarget (target) {
+        if (target.sprite.soundBank) {
+            if (this.waitingSounds[target.id]) {
+                for (const soundId of this.waitingSounds[target.id].values()) {
+                    target.sprite.soundBank.stop(target, soundId);
+                }
+                this.waitingSounds[target.id].clear();
+            }
+        }
+    }
+
+    setEffect (args, util) {
+        return this._updateEffect(args, util, false);
+    }
+
+    changeEffect (args, util) {
+        return this._updateEffect(args, util, true);
+    }
+
+    _updateEffect (args, util, change) {
+        const effect = Cast.toString(args.EFFECT).toLowerCase();
+        const value = Cast.toNumber(args.VALUE);
+
+        const soundState = this._getSoundState(util.target);
+        if (!soundState.effects.hasOwnProperty(effect)) return;
+
+        if (change) {
+            soundState.effects[effect] += value;
+        } else {
+            soundState.effects[effect] = value;
+        }
+
+        const miscLimits = this.runtime.runtimeOptions.miscLimits;
+        const {min, max} = miscLimits ?
+            Scratch3SoundBlocks.EFFECT_RANGE[effect] :
+            Scratch3SoundBlocks.LARGER_EFFECT_RANGE[effect];
+        soundState.effects[effect] = MathUtil.clamp(soundState.effects[effect], min, max);
+
+        this._syncEffectsForTarget(util.target);
+        if (miscLimits) {
+            // Yield until the next tick.
+            return Promise.resolve();
+        }
+
+        // Requesting a redraw makes sure that "forever: change pitch by 1" still work but without
+        // yielding unnecessarily in other cases
+        this.runtime.requestRedraw();
+    }
+
+    _syncEffectsForTarget (target) {
+        if (!target || !target.sprite.soundBank) return;
+        target.soundEffects = this._getSoundState(target).effects;
+
+        target.sprite.soundBank.setEffects(target);
+    }
+
+    clearEffects (args, util) {
+        this._clearEffectsForTarget(util.target);
+    }
+
+    _clearEffectsForTarget (target) {
+        const soundState = this._getSoundState(target);
+        for (const effect in soundState.effects) {
+            if (!soundState.effects.hasOwnProperty(effect)) continue;
+            soundState.effects[effect] = 0;
+        }
+        this._syncEffectsForTarget(target);
+    }
+
+    _clearEffectsForAllTargets () {
+        if (this.runtime.targets === null) return;
+        const allTargets = this.runtime.targets;
+        for (let i = 0; i < allTargets.length; i++) {
+            this._clearEffectsForTarget(allTargets[i]);
+        }
+    }
+
+    setVolume (args, util) {
+        const volume = Cast.toNumber(args.VOLUME);
+        return this._updateVolume(volume, util.target);
+    }
+
+    changeVolume (args, util) {
+        const volume = Cast.toNumber(args.VOLUME) + util.target.volume;
+        return this._updateVolume(volume, util.target);
+    }
+
+    _updateVolume (volume, target) {
+        volume = MathUtil.clamp(volume, 0, 100);
+        target.volume = volume;
+        this._syncEffectsForTarget(target);
+
+        if (this.runtime.runtimeOptions.miscLimits) {
+            // Yield until the next tick.
+            return Promise.resolve();
+        }
+        this.runtime.requestRedraw();
+    }
+
+    getVolume (args, util) {
+        return util.target.volume;
+    }
+
+    soundsMenu (args) {
+        return args.SOUND_MENU;
+    }
+
+    beatsMenu (args) {
+        return args.BEATS;
+    }
+
+    effectsMenu (args) {
+        return args.EFFECT;
+    }
+}
+
+module.exports = Scratch3SoundBlocks;

src/cli/index.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const VirtualMachine = require('../index');
+
+/* eslint-env node */
+/* eslint-disable no-console */
+
+const file = process.argv[2];
+if (!file) {
+    throw new Error('Invalid file');
+}
+
+const runProject = async buffer => {
+    const vm = new VirtualMachine();
+    vm.runtime.on('SAY', (target, type, text) => {
+        console.log(text);
+    });
+    vm.setCompatibilityMode(true);
+    vm.clear();
+    await vm.loadProject(buffer);
+    vm.start();
+    vm.greenFlag();
+    await new Promise(resolve => {
+        const interval = setInterval(() => {
+            let active = 0;
+            const threads = vm.runtime.threads;
+            for (let i = 0; i < threads.length; i++) {
+                if (!threads[i].updateMonitor) {
+                    active += 1;
+                }
+            }
+            if (active === 0) {
+                clearInterval(interval);
+                resolve();
+            }
+        }, 50);
+    });
+    vm.stopAll();
+    vm.stop();
+};
+
+runProject(fs.readFileSync(file));

src/compiler/compat-block-utility.js

@@ -0,0 +1,62 @@
+const BlockUtility = require('../engine/block-utility');
+
+class CompatibilityLayerBlockUtility extends BlockUtility {
+    constructor () {
+        super();
+        this._startedBranch = null;
+    }
+
+    get stackFrame () {
+        return this.thread.compatibilityStackFrame;
+    }
+
+    startBranch (branchNumber, isLoop, onEnd) {
+        if (this._branchInfo && onEnd) this._branchInfo.onEnd.push(onEnd);
+        this._startedBranch = [branchNumber, isLoop];
+    }
+
+    /**
+     * runs any given procedure
+     * @param {String} proccode the procedure to start
+     * @param {Object} args 
+     * @returns the return value of the procedure, returns undefined if statement
+     */
+    startProcedure (proccode, args) {
+        if (!args)
+            return this.thread.procedures[proccode]();
+        if (!(typeof args === 'object'))
+            throw new Error(`procedure arguments can only be of type undefined|object. instead got "${typeof args}"`);
+        let evaluate = `this.thread.procedures[proccode](`;
+        const inputs = [];
+        for (const arg in args) {
+            inputs.push(String(args[arg]));
+        }
+        evaluate += `${inputs.join(',')})`;
+        return new Function(`Procedure ${proccode}`, evaluate)();
+    }
+
+    /*
+    // Parameters are not used by compiled scripts.
+    initParams () {
+        throw new Error('initParams is not supported by this BlockUtility');
+    }
+    pushParam () {
+        throw new Error('pushParam is not supported by this BlockUtility');
+    }
+    getParam () {
+        throw new Error('getParam is not supported by this BlockUtility');
+    }
+    */
+
+    init (thread, fakeBlockId, stackFrame, branchInfo) {
+        this.thread = thread;
+        this.sequencer = thread.target.runtime.sequencer;
+        this._startedBranch = null;
+        this._branchInfo = branchInfo;
+        thread.stack[0] = fakeBlockId;
+        thread.compatibilityStackFrame = stackFrame;
+    }
+}
+
+// Export a single instance to be reused.
+module.exports = new CompatibilityLayerBlockUtility();

src/compiler/compat-blocks.js

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview List of blocks to be supported in the compiler compatibility layer.
+ * This is only for native blocks. Extensions should not be listed here.
+ */
+
+// Please keep these lists alphabetical.
+// no >:(
+// haha cry about it - jerem
+
+const statementBlocks = [
+    'looks_hideallsprites',
+    'looks_say',
+    'looks_sayforsecs',
+    'looks_setstretchto',
+    'looks_switchbackdroptoandwait',
+    'looks_think',
+    'looks_thinkforsecs',
+    'motion_align_scene',
+    'motion_glidesecstoxy',
+    'motion_glideto',
+    'motion_goto',
+    'motion_pointtowards',
+    'motion_scroll_right',
+    'motion_scroll_up',
+    'sensing_askandwait',
+    'sensing_setdragmode',
+    'sound_changeeffectby',
+    'sound_changevolumeby',
+    'sound_cleareffects',
+    'sound_play',
+    'sound_playuntildone',
+    'sound_stop',
+    'sound_seteffectto',
+    'sound_setvolumeto',
+    'sound_stopallsounds',
+    "looks_setStretch",
+    "looks_changeStretch",
+    "data_reverselist",
+    "data_arraylist",
+    "control_switch",
+    "control_switch_default",
+    "control_case",
+    "control_exitCase",
+    "control_case_next",
+    "control_backToGreenFlag",
+    'looks_setHorizTransform',
+    'looks_setVertTransform',
+    'looks_layersSetLayer',
+    'control_waitsecondsoruntil',
+    'control_delete_clones_of',
+    'control_stop_sprite',
+    'looks_changeVisibilityOfSprite',
+    'looks_previouscostume',
+    'looks_previousbackdrop',
+    'motion_pointinrandomdirection',
+    'motion_move_sprite_to_scene_side',
+    'sound_playallsounds',
+    'looks_stoptalking',
+    'sensing_setclipboard',
+    'motion_movebacksteps',
+    'motion_moveupdownsteps',
+    'motion_turnrightaroundxy',
+    'motion_turnleftaroundxy',
+    'motion_turnaround',
+    'motion_pointinrandomdirection',
+    'motion_pointtowardsxy',
+    'motion_glidedirectionstepsinseconds',
+    'motion_changebyxy',
+    'motion_ifonspritebounce',
+    'motion_ifonxybounce',
+    'motion_move_sprite_to_scene_side',
+    'control_javascript_command',
+    'looks_changeVisibilityOfSpriteShow',
+    'looks_changeVisibilityOfSpriteHide',
+    'sound_pause',
+    'sound_set_stop_fadeout_to',
+    'sound_play_at_seconds',
+    'sound_play_at_seconds_until_done',
+    'sound_pauseallsounds',
+    'argument_reporter_command'
+];
+
+const outputBlocks = [
+    'motion_xscroll',
+    'motion_yscroll',
+    'sensing_loud',
+    'sensing_loudness',
+    'sensing_userid',
+    'sound_volume',
+    "control_if_return_else_return",
+    "looks_stretchGetX",
+    "looks_stretchGetY",
+    "sensing_getspritewithattrib",
+    "sensing_thing_is_text",
+    "sensing_mobile",
+    "sensing_thing_is_number",
+    "sensing_regextest",
+    "operator_indexOfTextInText",
+    "operator_constrainnumber",
+    "operator_advMath",
+    "operator_advMathExpanded",
+    "operator_lerpFunc",
+    "operator_stringify",
+    "operator_newLine",
+    "operator_readLineInMultilineText",
+    "operator_getLettersFromIndexToIndexInText",
+    "operator_getLettersFromIndexToIndexInTextFixed",
+    "operator_replaceAll",
+    "operator_regexmatch",
+    "data_itemexistslist",
+    "data_listisempty",
+    "data_listarray",
+    "looks_sayHeight",
+    "looks_sayWidth",
+    "sensing_isUpperCase",
+    "operator_toUpperLowerCase",
+    "looks_getSpriteVisible",
+    "looks_getEffectValue",
+    'looks_layersGetLayer',
+    'sound_isSoundPlaying',
+    'sound_getEffectValue',
+    'sound_getLength',
+    "sensing_directionTo",
+    "sensing_distanceTo",
+    "operator_boolify",
+    "operator_tabCharacter",
+    "operator_character_to_code",
+    "operator_code_to_character",
+    "sensing_keyhit",
+    "sensing_mousescrolling",
+    "sensing_mouseclicked",
+    "sensing_thing_has_text",
+    "sensing_thing_has_number",
+    "sensing_objecttouchingobject",
+    "sensing_objecttouchingclonesprite",
+    'looks_getOtherSpriteVisible',
+    'operator_gtorequal',
+    'operator_ltorequal',
+    'operator_notequal',
+    'operator_join3',
+    'operator_replaceFirst',
+    'operator_lastIndexOfTextInText',
+    'operator_countAppearTimes',
+    'operator_textIncludesLetterFrom',
+    'operator_textStartsOrEndsWith',
+    'sensing_fingerdown',
+    'sensing_fingertapped',
+    'sensing_fingerx',
+    'sensing_fingery',
+    'sensing_getclipboard',
+    'sensing_getdragmode',
+    'sensing_getoperatingsystem',
+    'sensing_getbrowser',
+    'sensing_geturl',
+    'operator_javascript_output',
+    'operator_javascript_boolean',
+    'sensing_getxyoftouchingsprite',
+    'operator_nand',
+    'operator_nor',
+    'operator_xor',
+    'operator_xnor',
+    'looks_getinputofcostume',
+    'sound_getTimePosition',
+    'sound_getSoundVolume'
+];
+
+module.exports = {
+    statementBlocks,
+    outputBlocks
+};

src/compiler/compile.js

@@ -0,0 +1,37 @@
+const IRGenerator = require('./irgen');
+const JSGenerator = require('./jsgen');
+
+const compile = thread => {
+    const irGenerator = new IRGenerator(thread);
+    const ir = irGenerator.generate();
+
+    const procedures = {};
+    const target = thread.target;
+
+    const compileScript = script => {
+        if (script.cachedCompileResult) {
+            return script.cachedCompileResult;
+        }
+
+        const compiler = new JSGenerator(script, ir, target);
+        const result = compiler.compile();
+        script.cachedCompileResult = result;
+        return result;
+    };
+
+    const entry = compileScript(ir.entry);
+
+    for (const procedureVariant of Object.keys(ir.procedures)) {
+        const procedureData = ir.procedures[procedureVariant];
+        const procedureTree = compileScript(procedureData);
+        procedures[procedureVariant] = procedureTree;
+    }
+
+    return {
+        startingFunction: entry,
+        procedures,
+        executableHat: ir.entry.executableHat
+    };
+};
+
+module.exports = compile;

src/compiler/environment.js

@@ -0,0 +1,20 @@
+/* eslint-disable no-eval */
+
+/**
+ * @returns {boolean} true if the nullish coalescing operator (x ?? y) is supported.
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator
+ */
+const supportsNullishCoalescing = () => {
+    try {
+        // eslint-disable-next-line no-unused-vars
+        const fn = new Function('undefined ?? 3');
+        // if function construction succeeds, the browser understood the syntax.
+        return true;
+    } catch (e) {
+        return false;
+    }
+};
+
+module.exports = {
+    supportsNullishCoalescing: supportsNullishCoalescing()
+};

src/compiler/intermediate.js

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview Common intermediates shared amongst parts of the compiler.
+ */
+
+/**
+ * An IntermediateScript describes a single script.
+ * Scripts do not necessarily have hats.
+ */
+class IntermediateScript {
+    constructor () {
+        /**
+         * The ID of the top block of this script.
+         * @type {string}
+         */
+        this.topBlockId = null;
+
+        /**
+         * List of nodes that make up this script.
+         * @type {Array|null}
+         */
+        this.stack = null;
+
+        /**
+         * Whether this script is a procedure.
+         * @type {boolean}
+         */
+        this.isProcedure = false;
+
+        /**
+         * This procedure's code, if any.
+         * @type {string}
+         */
+        this.procedureCode = '';
+
+        /**
+         * List of names of arguments accepted by this function, if it is a procedure.
+         * @type {string[]}
+         */
+        this.arguments = [];
+
+        /**
+         * Whether this script should be run in warp mode.
+         * @type {boolean}
+         */
+        this.isWarp = false;
+
+        /**
+         * pm: Whether this script should use dangerous optimizations.
+         * @type {boolean}
+         */
+        this.isOptimized = false;
+
+        /**
+         * pm: An object containing stuff for optimization.
+         * @type {object}
+         */
+        this.optimizationUtil = {};
+
+        /**
+         * Whether this script can `yield`
+         * If false, this script will be compiled as a regular JavaScript function (function)
+         * If true, this script will be compiled as a generator function (function*)
+         * @type {boolean}
+         */
+        this.yields = true;
+
+        /**
+         * Whether this script should use the "warp timer"
+         * @type {boolean}
+         */
+        this.warpTimer = false;
+
+        /**
+         * List of procedure IDs that this script needs.
+         * @readonly
+         */
+        this.dependedProcedures = [];
+
+        /**
+         * Cached result of compiling this script.
+         * @type {Function|null}
+         */
+        this.cachedCompileResult = null;
+        
+        /**
+         * Whether the top block of this script is an executable hat.
+         * @type {boolean}
+         */
+        this.executableHat = false;
+    }
+}
+
+/**
+ * An IntermediateRepresentation contains scripts.
+ */
+class IntermediateRepresentation {
+    constructor () {
+        /**
+         * The entry point of this IR.
+         * @type {IntermediateScript}
+         */
+        this.entry = null;
+
+        /**
+         * Maps procedure variants to their intermediate script.
+         * @type {Object.<string, IntermediateScript>}
+         */
+        this.procedures = {};
+    }
+}
+
+module.exports = {
+    IntermediateScript,
+    IntermediateRepresentation
+};

src/compiler/irgen.js

@@ -0,0 +1,2475 @@
+const Cast = require('../util/cast');
+const StringUtil = require('../util/string-util');
+const BlockType = require('../extension-support/block-type');
+const Sequencer = require('../engine/sequencer');
+const BlockUtility = require('../engine/block-utility');
+const Variable = require('../engine/variable');
+const Color = require('../util/color');
+const log = require('../util/log');
+const Clone = require('../util/clone');
+const {IntermediateScript, IntermediateRepresentation} = require('./intermediate');
+const compatBlocks = require('./compat-blocks');
+
+/**
+ * @fileoverview Generate intermediate representations from Scratch blocks.
+ */
+
+const SCALAR_TYPE = '';
+const LIST_TYPE = 'list';
+
+/**
+ * @typedef {Object.<string, *>} Node
+ * @property {string} kind
+ */
+
+/**
+ * Create a variable codegen object.
+ * @param {'target'|'stage'} scope The scope of this variable -- which object owns it.
+ * @param {import('../engine/variable.js')} varObj The Scratch Variable
+ * @returns {*} A variable codegen object.
+ */
+const createVariableData = (scope, varObj) => ({
+    scope,
+    id: varObj.id,
+    name: varObj.name,
+    isCloud: varObj.isCloud
+});
+
+/**
+ * @param {string} code
+ * @param {boolean} warp
+ * @returns {string}
+ */
+const generateProcedureVariant = (code, warp) => {
+    if (warp) {
+        return `W${code}`;
+    }
+    return `Z${code}`;
+};
+
+/**
+ * @param {string} variant Variant generated by generateProcedureVariant()
+ * @returns {string} original procedure code
+ */
+const parseProcedureCode = variant => variant.substring(1);
+
+/**
+ * @param {string} variant Variant generated by generateProcedureVariant()
+ * @returns {boolean} true if warp enabled
+ */
+const parseIsWarp = variant => variant.charAt(0) === 'W';
+
+class ScriptTreeGenerator {
+    constructor (thread) {
+        /** @private */
+        this.thread = thread;
+        /** @private */
+        this.target = thread.target;
+        /** @private */
+        this.blocks = thread.blockContainer;
+        /** @private */
+        this.runtime = this.target.runtime;
+        /** @private */
+        this.stage = this.runtime.getTargetForStage();
+        /** @private */
+        this.util = new BlockUtility(this.runtime.sequencer, this.thread);
+
+        /**
+         * This script's intermediate representation.
+         */
+        this.script = new IntermediateScript();
+        this.script.warpTimer = this.target.runtime.compilerOptions.warpTimer;
+        this.script.isOptimized = this.target.runtime.runtimeOptions.dangerousOptimizations;
+        this.script.optimizationUtil = this.target.runtime.optimizationUtil;
+
+        /**
+         * Cache of variable ID to variable data object.
+         * @type {Object.<string, object>}
+         * @private
+         */
+        this.variableCache = {};
+
+        this.usesTimer = false;
+    }
+
+    setProcedureVariant (procedureVariant) {
+        const procedureCode = parseProcedureCode(procedureVariant);
+
+        this.script.procedureCode = procedureCode;
+        this.script.isProcedure = true;
+        this.script.yields = false;
+
+        const paramNamesIdsAndDefaults = this.blocks.getProcedureParamNamesIdsAndDefaults(procedureCode);
+        if (paramNamesIdsAndDefaults === null) {
+            throw new Error(`IR: cannot find procedure: ${procedureVariant}`);
+        }
+
+        const [paramNames, _paramIds, _paramDefaults] = paramNamesIdsAndDefaults;
+        this.script.arguments = paramNames;
+    }
+
+    enableWarp () {
+        this.script.isWarp = true;
+    }
+
+    getBlockById (blockId) {
+        // Flyout blocks are stored in a special container.
+        return this.blocks.getBlock(blockId) || this.blocks.runtime.flyoutBlocks.getBlock(blockId);
+    }
+
+    getBlockInfo (fullOpcode) {
+        const [category, opcode] = StringUtil.splitFirst(fullOpcode, '_');
+        if (!category || !opcode) {
+            return null;
+        }
+        const categoryInfo = this.runtime._blockInfo.find(ci => ci.id === category);
+        if (!categoryInfo) {
+            return null;
+        }
+        const blockInfo = categoryInfo.blocks.find(b => b.info.opcode === opcode);
+        if (!blockInfo) {
+            return null;
+        }
+        return blockInfo;
+    }
+
+    /**
+     * Descend into a child input of a block. (eg. the input STRING of "length of ( )")
+     * @param {*} parentBlock The parent Scratch block that contains the input.
+     * @param {string} inputName The name of the input to descend into.
+     * @private
+     * @returns {Node} Compiled input node for this input.
+     */
+    descendInputOfBlock (parentBlock, inputName) {
+        const input = parentBlock.inputs[inputName];
+        if (!input) {
+            log.warn(`IR: ${parentBlock.opcode}: missing input ${inputName}`, parentBlock);
+            return {
+                kind: 'constant',
+                value: 0
+            };
+        }
+        const inputId = input.block;
+        const block = this.getBlockById(inputId);
+        if (!block) {
+            log.warn(`IR: ${parentBlock.opcode}: could not find input ${inputName} with ID ${inputId}`);
+            return {
+                kind: 'constant',
+                value: 0
+            };
+        }
+
+        return this.descendInput(block);
+    }
+
+    /**
+     * Descend into an input. (eg. "length of ( )")
+     * @param {*} block The parent Scratch block input.
+     * @private
+     * @returns {Node} Compiled input node for this input.
+     */
+    descendInput (block) {
+        // check if we have extension ir for this opcode
+        const extensionId = String(block.opcode).split('_')[0];
+        const blockId = String(block.opcode).replace(extensionId + '_', '');
+        if (IRGenerator.hasExtensionIr(extensionId) && IRGenerator.getExtensionIr(extensionId)[blockId]) {
+            // this is an extension block that wants to be compiled
+            const irFunc = IRGenerator.getExtensionIr(extensionId)[blockId];
+            let irData = null;
+            // make sure irFunc isnt broken
+            try {
+                irData = irFunc(this, block);
+            } catch (err) {
+                log.warn(extensionId + '_' + blockId, 'failed to create IR data;', err);
+            }
+            if (irData) {
+                // check if it is this type, we dont want to descend a stack as an input
+                if (irData.kind === 'input') {
+                    // set proper kind
+                    irData.kind = extensionId + '.' + blockId;
+                    return irData;
+                }
+            }
+        }
+
+        switch (block.opcode) {
+        case 'colour_picker':
+            return {
+                kind: 'constant',
+                value: block.fields.COLOUR.value
+            };
+        case 'math_angle':
+        case 'math_integer':
+        case 'math_number':
+        case 'math_positive_number':
+        case 'math_whole_number':
+            return {
+                kind: 'constant',
+                value: block.fields.NUM.value
+            };
+        case 'text':
+            return {
+                kind: 'constant',
+                value: block.fields.TEXT.value
+            };
+        case 'polygon':
+            const points = [];
+            for (let point = 1; point <= block.mutation.points; point++) {
+                const xn = `x${point}`;
+                const yn = `y${point}`;
+                points.push({
+                    x: this.descendInputOfBlock(block, xn),
+                    y: this.descendInputOfBlock(block, yn)
+                });
+            }
+            return {
+                kind: 'math.polygon',
+                points
+            };
+
+        case 'argument_reporter_string_number': {
+            const name = block.fields.VALUE.value;
+            // lastIndexOf because multiple parameters with the same name will use the value of the last definition
+            const index = this.script.arguments.lastIndexOf(name);
+            if (index === -1) {
+                // Legacy support
+                if (name.toLowerCase() === 'last key pressed') {
+                    return {
+                        kind: 'tw.lastKeyPressed'
+                    };
+                }
+            }
+            if (index === -1) {
+                return {
+                    kind: 'constant',
+                    value: 0
+                };
+            }
+            return {
+                kind: 'args.stringNumber',
+                index: index
+            };
+        }
+        case 'argument_reporter_boolean': {
+            // see argument_reporter_string_number above
+            const name = block.fields.VALUE.value;
+            const index = this.script.arguments.lastIndexOf(name);
+            if (index === -1) {
+                if (name.toLowerCase() === 'is compiled?' || 
+                    name.toLowerCase() === 'is turbowarp?' || 
+                    name.toLowerCase() === 'is penguinmod or turbowarp?') {
+                    return {
+                        kind: 'constant',
+                        value: true
+                    };
+                }
+                return {
+                    kind: 'constant',
+                    value: 0
+                };
+            }
+            return {
+                kind: 'args.boolean',
+                index: index
+            };
+        }
+
+        case 'control_get_counter':
+            return {
+                kind: 'counter.get'
+            };
+        case 'control_error':
+            return {
+                kind: 'control.error'
+            };
+        case 'control_is_clone':
+            return {
+                kind: 'control.isclone'
+            };
+
+        case 'data_variable':
+            return {
+                kind: 'var.get',
+                variable: this.descendVariable(block, 'VARIABLE', SCALAR_TYPE)
+            };
+        case 'data_itemoflist':
+            return {
+                kind: 'list.get',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                index: this.descendInputOfBlock(block, 'INDEX')
+            };
+        case 'data_lengthoflist':
+            return {
+                kind: 'list.length',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE)
+            };
+        case 'data_listcontainsitem':
+            return {
+                kind: 'list.contains',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                item: this.descendInputOfBlock(block, 'ITEM')
+            };
+            case 'data_itemnumoflist':
+                return {
+                    kind: 'list.indexOf',
+                    list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                    item: this.descendInputOfBlock(block, 'ITEM')
+                };
+            case 'data_amountinlist':
+                return {
+                    kind: 'list.amountOf',
+                    list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                    value: this.descendInputOfBlock(block, 'VALUE')
+                };
+        case 'data_listcontents':
+            return {
+                kind: 'list.contents',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE)
+            };
+        case 'data_filterlistitem':
+            return {
+                kind: 'list.filteritem'
+            };
+        case 'data_filterlistindex':
+            return {
+                kind: 'list.filterindex'
+            };
+
+        case 'event_broadcast_menu': {
+            const broadcastOption = block.fields.BROADCAST_OPTION;
+            const broadcastVariable = this.target.lookupBroadcastMsg(broadcastOption.id, broadcastOption.value);
+            // TODO: empty string probably isn't the correct fallback
+            const broadcastName = broadcastVariable ? broadcastVariable.name : '';
+            return {
+                kind: 'constant',
+                value: broadcastName
+            };
+        }
+
+        case 'pmEventsExpansion_broadcastFunction':
+            this.script.yields = true;
+            return {
+                kind: 'pmEventsExpansion.broadcastFunction',
+                broadcast: this.descendInputOfBlock(block, 'BROADCAST')
+            };
+        case 'pmEventsExpansion_broadcastFunctionArgs':
+            this.script.yields = true;
+            return {
+                kind: 'pmEventsExpansion.broadcastFunctionArgs',
+                broadcast: this.descendInputOfBlock(block, 'BROADCAST'),
+                args: this.descendInputOfBlock(block, 'ARGS')
+            };
+        
+        case 'control_inline_stack_output':
+            return {
+                kind: 'control.inlineStackOutput',
+                code: this.descendSubstack(block, 'SUBSTACK')
+            };
+
+        case 'looks_backdropnumbername':
+            if (block.fields.NUMBER_NAME.value === 'number') {
+                return {
+                    kind: 'looks.backdropNumber'
+                };
+            }
+            return {
+                kind: 'looks.backdropName'
+            };
+        case 'looks_costumenumbername':
+            if (block.fields.NUMBER_NAME.value === 'number') {
+                return {
+                    kind: 'looks.costumeNumber'
+                };
+            }
+            return {
+                kind: 'looks.costumeName'
+            };
+        case 'looks_size':
+            return {
+                kind: 'looks.size'
+            };
+        case 'looks_tintColor':
+            return {
+                kind: 'looks.tintColor'
+            };
+        case 'motion_direction':
+            return {
+                kind: 'motion.direction'
+            };
+        case 'motion_xposition':
+            return {
+                kind: 'motion.x'
+            };
+        case 'motion_yposition':
+            return {
+                kind: 'motion.y'
+            };
+
+        case 'operator_add':
+            return {
+                kind: 'op.add',
+                left: this.descendInputOfBlock(block, 'NUM1'),
+                right: this.descendInputOfBlock(block, 'NUM2')
+            };
+        case 'operator_and':
+            return {
+                kind: 'op.and',
+                left: this.descendInputOfBlock(block, 'OPERAND1'),
+                right: this.descendInputOfBlock(block, 'OPERAND2')
+            };
+        case 'operator_contains':
+            return {
+                kind: 'op.contains',
+                string: this.descendInputOfBlock(block, 'STRING1'),
+                contains: this.descendInputOfBlock(block, 'STRING2')
+            };
+        case 'operator_divide':
+            return {
+                kind: 'op.divide',
+                left: this.descendInputOfBlock(block, 'NUM1'),
+                right: this.descendInputOfBlock(block, 'NUM2')
+            };
+        case 'operator_power':
+            return {
+                kind: 'op.power',
+                left: this.descendInputOfBlock(block, 'NUM1'),
+                right: this.descendInputOfBlock(block, 'NUM2')
+            };
+        case 'operator_equals':
+            return {
+                kind: 'op.equals',
+                left: this.descendInputOfBlock(block, 'OPERAND1'),
+                right: this.descendInputOfBlock(block, 'OPERAND2')
+            };
+        case 'operator_gt':
+            return {
+                kind: 'op.greater',
+                left: this.descendInputOfBlock(block, 'OPERAND1'),
+                right: this.descendInputOfBlock(block, 'OPERAND2')
+            };
+        case 'operator_join':
+            return {
+                kind: 'op.join',
+                left: this.descendInputOfBlock(block, 'STRING1'),
+                right: this.descendInputOfBlock(block, 'STRING2')
+            };
+        case 'operator_length':
+            return {
+                kind: 'op.length',
+                string: this.descendInputOfBlock(block, 'STRING')
+            };
+        case 'operator_letter_of':
+            return {
+                kind: 'op.letterOf',
+                letter: this.descendInputOfBlock(block, 'LETTER'),
+                string: this.descendInputOfBlock(block, 'STRING')
+            };
+        case 'operator_lt':
+            return {
+                kind: 'op.less',
+                left: this.descendInputOfBlock(block, 'OPERAND1'),
+                right: this.descendInputOfBlock(block, 'OPERAND2')
+            };
+        case 'operator_mathop': {
+            const value = this.descendInputOfBlock(block, 'NUM');
+            const operator = block.fields.OPERATOR.value.toLowerCase();
+            switch (operator) {
+            case 'abs': return {
+                kind: 'op.abs',
+                value
+            };
+            case 'floor': return {
+                kind: 'op.floor',
+                value
+            };
+            case 'ceiling': return {
+                kind: 'op.ceiling',
+                value
+            };
+            case 'sign': return {
+                kind: 'op.sign',
+                value
+            };
+            case 'sqrt': return {
+                kind: 'op.sqrt',
+                value
+            };
+            case 'sin': return {
+                kind: 'op.sin',
+                value
+            };
+            case 'cos': return {
+                kind: 'op.cos',
+                value
+            };
+            case 'tan': return {
+                kind: 'op.tan',
+                value
+            };
+            case 'asin': return {
+                kind: 'op.asin',
+                value
+            };
+            case 'acos': return {
+                kind: 'op.acos',
+                value
+            };
+            case 'atan': return {
+                kind: 'op.atan',
+                value
+            };
+            case 'ln': return {
+                kind: 'op.ln',
+                value
+            };
+            case 'log': return {
+                kind: 'op.log',
+                value
+            };
+            case 'log2': return {
+                kind: 'op.log2',
+                value
+            };
+            case 'e ^': return {
+                kind: 'op.e^',
+                value
+            };
+            case '10 ^': return {
+                kind: 'op.10^',
+                value
+            };
+            default: return {
+                kind: 'constant',
+                value: 0
+            };
+            }
+        }
+        case 'operator_advlog':
+            return {
+                kind: 'op.advlog',
+                left: this.descendInputOfBlock(block, 'NUM1'),
+                right: this.descendInputOfBlock(block, 'NUM2')
+            };
+        case 'operator_mod':
+            return {
+                kind: 'op.mod',
+                left: this.descendInputOfBlock(block, 'NUM1'),
+                right: this.descendInputOfBlock(block, 'NUM2')
+            };
+        case 'operator_multiply':
+            return {
+                kind: 'op.multiply',
+                left: this.descendInputOfBlock(block, 'NUM1'),
+                right: this.descendInputOfBlock(block, 'NUM2')
+            };
+        case 'operator_not':
+            return {
+                kind: 'op.not',
+                operand: this.descendInputOfBlock(block, 'OPERAND')
+            };
+        case 'operator_or':
+            return {
+                kind: 'op.or',
+                left: this.descendInputOfBlock(block, 'OPERAND1'),
+                right: this.descendInputOfBlock(block, 'OPERAND2')
+            };
+        case 'operator_random': {
+            const from = this.descendInputOfBlock(block, 'FROM');
+            const to = this.descendInputOfBlock(block, 'TO');
+            // If both values are known at compile time, we can do some optimizations.
+            // TODO: move optimizations to jsgen?
+            if (from.kind === 'constant' && to.kind === 'constant') {
+                const sFrom = from.value;
+                const sTo = to.value;
+                const nFrom = Cast.toNumber(sFrom);
+                const nTo = Cast.toNumber(sTo);
+                // If both numbers are the same, random is unnecessary.
+                // todo: this probably never happens so consider removing
+                if (nFrom === nTo) {
+                    return {
+                        kind: 'constant',
+                        value: nFrom
+                    };
+                }
+                // If both are ints, hint this to the compiler
+                if (Cast.isInt(sFrom) && Cast.isInt(sTo)) {
+                    return {
+                        kind: 'op.random',
+                        low: nFrom <= nTo ? from : to,
+                        high: nFrom <= nTo ? to : from,
+                        useInts: true,
+                        useFloats: false
+                    };
+                }
+                // Otherwise hint that these are floats
+                return {
+                    kind: 'op.random',
+                    low: nFrom <= nTo ? from : to,
+                    high: nFrom <= nTo ? to : from,
+                    useInts: false,
+                    useFloats: true
+                };
+            } else if (from.kind === 'constant') {
+                // If only one value is known at compile-time, we can still attempt some optimizations.
+                if (!Cast.isInt(Cast.toNumber(from.value))) {
+                    return {
+                        kind: 'op.random',
+                        low: from,
+                        high: to,
+                        useInts: false,
+                        useFloats: true
+                    };
+                }
+            } else if (to.kind === 'constant') {
+                if (!Cast.isInt(Cast.toNumber(to.value))) {
+                    return {
+                        kind: 'op.random',
+                        low: from,
+                        high: to,
+                        useInts: false,
+                        useFloats: true
+                    };
+                }
+            }
+            // No optimizations possible
+            return {
+                kind: 'op.random',
+                low: from,
+                high: to,
+                useInts: false,
+                useFloats: false
+            };
+        }
+        case 'operator_round':
+            return {
+                kind: 'op.round',
+                value: this.descendInputOfBlock(block, 'NUM')
+            };
+        case 'operator_subtract':
+            return {
+                kind: 'op.subtract',
+                left: this.descendInputOfBlock(block, 'NUM1'),
+                right: this.descendInputOfBlock(block, 'NUM2')
+            };
+
+        case 'sensing_answer':
+            return {
+                kind: 'sensing.answer'
+            };
+        case 'sensing_coloristouchingcolor':
+            return {
+                kind: 'sensing.colorTouchingColor',
+                target: this.descendInputOfBlock(block, 'COLOR2'),
+                mask: this.descendInputOfBlock(block, 'COLOR')
+            };
+        case 'sensing_current':
+            switch (block.fields.CURRENTMENU.value.toLowerCase()) {
+            case 'year':
+                return {
+                    kind: 'sensing.year'
+                };
+            case 'month':
+                return {
+                    kind: 'sensing.month'
+                };
+            case 'date':
+                return {
+                    kind: 'sensing.date'
+                };
+            case 'dayofweek':
+                return {
+                    kind: 'sensing.dayofweek'
+                };
+            case 'hour':
+                return {
+                    kind: 'sensing.hour'
+                };
+            case 'minute':
+                return {
+                    kind: 'sensing.minute'
+                };
+            case 'second':
+                return {
+                    kind: 'sensing.second'
+                };
+            case 'timestamp':
+                return {
+                    kind: 'sensing.timestamp'
+                };
+            }
+
+            return {
+                kind: 'constant',
+                value: 0
+            };
+        case 'sensing_dayssince2000':
+            return {
+                kind: 'sensing.daysSince2000'
+            };
+        case 'sensing_distanceto':
+            return {
+                kind: 'sensing.distance',
+                target: this.descendInputOfBlock(block, 'DISTANCETOMENU')
+            };
+        case 'sensing_keypressed':
+            return {
+                kind: 'keyboard.pressed',
+                key: this.descendInputOfBlock(block, 'KEY_OPTION')
+            };
+        case 'sensing_mousedown':
+            return {
+                kind: 'mouse.down'
+            };
+        case 'sensing_mousex':
+            return {
+                kind: 'mouse.x'
+            };
+        case 'sensing_mousey':
+            return {
+                kind: 'mouse.y'
+            };
+        case 'sensing_of':
+            return {
+                kind: 'sensing.of',
+                property: block.fields.PROPERTY.value,
+                object: this.descendInputOfBlock(block, 'OBJECT')
+            };
+        case 'sensing_timer':
+            this.usesTimer = true;
+            return {
+                kind: 'timer.get'
+            };
+        case 'sensing_touchingcolor':
+            return {
+                kind: 'sensing.touchingColor',
+                color: this.descendInputOfBlock(block, 'COLOR')
+            };
+        case 'sensing_touchingobject':
+            return {
+                kind: 'sensing.touching',
+                object: this.descendInputOfBlock(block, 'TOUCHINGOBJECTMENU')
+            };
+        case 'sensing_username':
+            return {
+                kind: 'sensing.username'
+            };
+        case 'sensing_loggedin': 
+            return {
+                kind: 'sensing.loggedin'
+            };
+        case 'operator_trueBoolean':
+            return {
+                kind: 'op.true'
+            };
+        case 'operator_falseBoolean':
+            return {
+                kind: 'op.false'
+            };
+        case 'operator_randomBoolean':
+            return {
+                kind: 'op.randbool'
+            };
+
+        case 'sound_sounds_menu':
+            return {
+                kind: 'constant',
+                value: block.fields.SOUND_MENU.value
+            };
+
+        case 'lmsTempVars2_getRuntimeVariable':
+            return {
+                kind: 'tempVars.get',
+                var: this.descendInputOfBlock(block, 'VAR'),
+                runtime: true
+            };
+        case 'lmsTempVars2_getThreadVariable':
+            return {
+                kind: 'tempVars.get',
+                var: this.descendInputOfBlock(block, 'VAR'),
+                thread: true
+            };
+        case 'tempVars_getVariable':
+            return {
+                kind: 'tempVars.get',
+                var: this.descendInputOfBlock(block, 'name')
+            };
+        
+        case 'lmsTempVars2_runtimeVariableExists':
+            return {
+                kind: 'tempVars.exists',
+                var: this.descendInputOfBlock(block, 'VAR'),
+                runtime: true
+            };
+        case 'lmsTempVars2_threadVariableExists':
+            return {
+                kind: 'tempVars.exists',
+                var: this.descendInputOfBlock(block, 'VAR'),
+                thread: true
+            };
+        case 'tempVars_variableExists':
+            // This menu is special compared to other menus -- it actually has an opcode function.
+            return {
+                kind: 'tempVars.exists',
+                var: this.descendInputOfBlock(block, 'name')
+            };
+
+        case 'lmsTempVars2_listRuntimeVariables':
+            return {
+                kind: 'tempVars.all',
+                runtime: true
+            };
+        case 'lmsTempVars2_listThreadVariables':
+            return {
+                kind: 'tempVars.all',
+                thread: true
+            };
+        case 'tempVars_allVariables':
+            return {
+                kind: 'tempVars.all'
+            };
+
+        // used by the stacked version of this block to run as an input block 
+        // despite there being a stacked version
+        case 'procedures_call_return':
+        case 'procedures_call': {
+            // setting of yields will be handled later in the analysis phase
+    
+            const procedureCode = block.mutation.proccode;
+            if (procedureCode === 'tw:debugger;') {
+                return {
+                    kind: 'tw.debugger'
+                };
+            }
+            const paramNamesIdsAndDefaults = this.blocks.getProcedureParamNamesIdsAndDefaults(procedureCode);
+            if (paramNamesIdsAndDefaults === null) {
+                return {
+                    kind: 'noop'
+                };
+            }
+    
+            const [paramNames, paramIds, paramDefaults] = paramNamesIdsAndDefaults;
+    
+            const addonBlock = this.runtime.getAddonBlock(procedureCode);
+            if (addonBlock) {
+                this.script.yields = true;
+                const args = {};
+                for (let i = 0; i < paramIds.length; i++) {
+                    let value;
+                    if (block.inputs[paramIds[i]] && block.inputs[paramIds[i]].block) {
+                        value = this.descendInputOfBlock(block, paramIds[i]);
+                    } else {
+                        value = {
+                            kind: 'constant',
+                            value: paramDefaults[i]
+                        };
+                    }
+                    args[paramNames[i]] = value;
+                }
+                return {
+                    kind: 'addons.call',
+                    code: procedureCode,
+                    arguments: args,
+                    blockId: block.id
+                };
+            }
+    
+            const definitionId = this.blocks.getProcedureDefinition(procedureCode);
+            const definitionBlock = this.blocks.getBlock(definitionId);
+            if (!definitionBlock) {
+                return {
+                    kind: 'noop'
+                };
+            }
+            const innerDefinition = this.blocks.getBlock(definitionBlock.inputs.custom_block.block);
+    
+            let isWarp = this.script.isWarp;
+            if (!isWarp) {
+                if (innerDefinition && innerDefinition.mutation) {
+                    const warp = innerDefinition.mutation.warp;
+                    if (typeof warp === 'boolean') {
+                        isWarp = warp;
+                    } else if (typeof warp === 'string') {
+                        isWarp = JSON.parse(warp);
+                    }
+                }
+            }
+    
+            const variant = generateProcedureVariant(procedureCode, isWarp);
+    
+            if (!this.script.dependedProcedures.includes(variant)) {
+                this.script.dependedProcedures.push(variant);
+            }
+    
+            // Non-warp direct recursion yields.
+            if (!this.script.isWarp) {
+                if (procedureCode === this.script.procedureCode) {
+                    this.script.yields = true;
+                }
+            }
+    
+            const args = [];
+            for (let i = 0; i < paramIds.length; i++) {
+                let value;
+                if (block.inputs[paramIds[i]] && block.inputs[paramIds[i]].block) {
+                    if (paramIds[i].startsWith("SUBSTACK")) {
+                        value = this.descendSubstack(block, paramIds[i])
+                    } else {
+                        value = this.descendInputOfBlock(block, paramIds[i]);
+                    }
+                } else {
+                    value = {
+                        kind: 'constant',
+                        value: paramDefaults[i]
+                    };
+                }
+                args.push(value);
+            }
+    
+            return {
+                kind: 'procedures.call',
+                code: procedureCode,
+                variant,
+                returns: true,
+                arguments: args,
+                type: JSON.parse(block.mutation.opType || '"string"')
+            };
+        }
+
+        case 'tw_getLastKeyPressed':
+            return {
+                kind: 'tw.lastKeyPressed'
+            };
+
+        case 'control_dualblock':
+            return {
+                kind: 'control.dualBlock'
+            };
+
+        default: {
+            const opcodeFunction = this.runtime.getOpcodeFunction(block.opcode);
+            if (opcodeFunction) {
+                // It might be a non-compiled primitive from a standard category
+                if (compatBlocks.outputBlocks.includes(block.opcode)) {
+                    return this.descendCompatLayer(block);
+                }
+                // It might be an extension block.
+                const blockInfo = this.getBlockInfo(block.opcode);
+                if (blockInfo) {
+                    const type = blockInfo.info.blockType;
+                    const args = this.descendCompatLayer(block);
+                    args.block = block;
+                    if (block.mutation) args.mutation = block.mutation;
+                    if (type === BlockType.REPORTER || type === BlockType.BOOLEAN) {
+                        return args;
+                    }
+                }
+            }
+
+            // It might be a menu.
+            const inputs = Object.keys(block.inputs);
+            const fields = Object.keys(block.fields);
+            if (inputs.length === 0 && fields.length === 1) {
+                return {
+                    kind: 'constant',
+                    value: block.fields[fields[0]].value
+                };
+            }
+
+            log.warn(`IR: Unknown input: ${block.opcode}`, block);
+            throw new Error(`IR: Unknown input: ${block.opcode}`);
+        }
+        }
+    }
+
+    /**
+     * Descend into a stacked block. (eg. "move ( ) steps")
+     * @param {*} block The Scratch block to parse.
+     * @private
+     * @returns {Node} Compiled node for this block.
+     */
+    descendStackedBlock (block) {
+        // check if we have extension ir for this opcode
+        const extensionId = String(block.opcode).split('_')[0];
+        const blockId = String(block.opcode).replace(extensionId + '_', '');
+        if (IRGenerator.hasExtensionIr(extensionId) && IRGenerator.getExtensionIr(extensionId)[blockId]) {
+            // this is an extension block that wants to be compiled
+            const irFunc = IRGenerator.getExtensionIr(extensionId)[blockId];
+            let irData = null;
+            // make sure irFunc isnt broken
+            try {
+                irData = irFunc(this, block);
+            } catch (err) {
+                log.warn(extensionId + '_' + blockId, 'failed to create IR data;', err);
+            }
+            if (irData) {
+                // check if it is this type, we dont want to descend an input as a stack
+                if (irData.kind === 'stack') {
+                    // set proper kind
+                    irData.kind = extensionId + '.' + blockId;
+                    return irData;
+                }
+            }
+        }
+
+        switch (block.opcode) {
+        case 'your_mom':
+            return {
+                kind: 'your mom'
+            };
+        case 'control_switch':
+            return {
+                kind: 'control.switch',
+                test: this.descendInputOfBlock(block, 'CONDITION'),
+                conditions: this.descendSubstack(block, 'SUBSTACK'),
+                default: []
+            };
+        case 'control_switch_default':
+            return {
+                kind: 'control.switch',
+                test: this.descendInputOfBlock(block, 'CONDITION'),
+                conditions: this.descendSubstack(block, 'SUBSTACK1'),
+                default: this.descendSubstack(block, 'SUBSTACK2')
+            };
+        case 'control_case_next':
+            return {
+                kind: 'control.case',
+                condition: this.descendInputOfBlock(block, 'CONDITION'),
+                code: this.descendSubstack(block, 'SUBSTACK'),
+                runsNext: true
+            };
+        case 'control_case':
+            return {
+                kind: 'control.case',
+                condition: this.descendInputOfBlock(block, 'CONDITION'),
+                code: this.descendSubstack(block, 'SUBSTACK'),
+                runsNext: false
+            };
+        case 'control_exitCase':
+            return {
+                kind: 'control.exitCase'
+            };
+        case 'control_exitLoop':
+            return {
+                kind: 'control.exitLoop'
+            };
+        case 'control_continueLoop':
+            return {
+                kind: 'control.continueLoop'
+            };
+        case 'control_all_at_once':
+            // In Scratch 3, this block behaves like "if 1 = 1"
+            // WE ARE IN PM NOW IT BEHAVES PROPERLY LESS GO
+            return {
+                kind: 'control.allAtOnce',
+                condition: {
+                    kind: 'constant',
+                    value: true
+                },
+                code: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'control_clear_counter':
+            return {
+                kind: 'counter.clear'
+            };
+        case 'control_create_clone_of':
+            return {
+                kind: 'control.createClone',
+                target: this.descendInputOfBlock(block, 'CLONE_OPTION')
+            };
+        case 'control_delete_this_clone':
+            this.script.yields = true;
+            return {
+                kind: 'control.deleteClone'
+            };
+        case 'control_forever':
+            this.analyzeLoop();
+            return {
+                kind: 'control.while',
+                condition: {
+                    kind: 'constant',
+                    value: true
+                },
+                do: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'control_for_each':
+            this.analyzeLoop();
+            return {
+                kind: 'control.for',
+                variable: this.descendVariable(block, 'VARIABLE', SCALAR_TYPE),
+                count: this.descendInputOfBlock(block, 'VALUE'),
+                do: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'control_if':
+            return {
+                kind: 'control.if',
+                condition: this.descendInputOfBlock(block, 'CONDITION'),
+                whenTrue: this.descendSubstack(block, 'SUBSTACK'),
+                whenFalse: []
+            };
+        case 'control_if_else':
+            return {
+                kind: 'control.if',
+                condition: this.descendInputOfBlock(block, 'CONDITION'),
+                whenTrue: this.descendSubstack(block, 'SUBSTACK'),
+                whenFalse: this.descendSubstack(block, 'SUBSTACK2')
+            };
+        case 'control_try_catch':
+            return {
+                kind: 'control.trycatch',
+                try: this.descendSubstack(block, 'SUBSTACK'),
+                catch: this.descendSubstack(block, 'SUBSTACK2')
+            };
+        case 'control_throw_error':
+            return {
+                kind: 'control.throwError',
+                error: this.descendInputOfBlock(block, 'ERROR'),
+            };
+        case 'control_incr_counter':
+            return {
+                kind: 'counter.increment'
+            };
+        case 'control_decr_counter':
+            return {
+                kind: 'counter.decrement'
+            };
+        case 'control_set_counter':
+            return {
+                kind: 'counter.set',
+                value: this.descendInputOfBlock(block, 'VALUE')
+            };
+        case 'control_repeat':
+            this.analyzeLoop();
+            return {
+                kind: 'control.repeat',
+                times: this.descendInputOfBlock(block, 'TIMES'),
+                do: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'control_repeatForSeconds':
+            this.analyzeLoop();
+            return {
+                kind: 'control.repeatForSeconds',
+                times: this.descendInputOfBlock(block, 'TIMES'),
+                do: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'control_repeat_until': {
+            this.analyzeLoop();
+            // Dirty hack: automatically enable warp timer for this block if it uses timer
+            // This fixes project that do things like "repeat until timer > 0.5"
+            this.usesTimer = false;
+            const condition = this.descendInputOfBlock(block, 'CONDITION');
+            const needsWarpTimer = this.usesTimer;
+            if (needsWarpTimer) {
+                this.script.yields = true;
+            }
+            return {
+                kind: 'control.while',
+                condition: {
+                    kind: 'op.not',
+                    operand: condition
+                },
+                do: this.descendSubstack(block, 'SUBSTACK'),
+                warpTimer: needsWarpTimer
+            };
+        }
+        case 'control_stop': {
+            const level = block.fields.STOP_OPTION.value;
+            if (level === 'all') {
+                this.script.yields = true;
+                return {
+                    kind: 'control.stopAll'
+                };
+            } else if (level === 'other scripts in sprite' || level === 'other scripts in stage') {
+                return {
+                    kind: 'control.stopOthers'
+                };
+            } else if (level === 'this script') {
+                return {
+                    kind: 'control.stopScript'
+                };
+            }
+            return {
+                kind: 'noop'
+            };
+        }
+        case 'control_wait':
+            this.script.yields = true;
+            return {
+                kind: 'control.wait',
+                seconds: this.descendInputOfBlock(block, 'DURATION')
+            };
+        case 'control_waittick':
+            this.script.yields = true;
+            return {
+                kind: 'control.waitTick'
+            };
+        case 'control_wait_until':
+            this.script.yields = true;
+            return {
+                kind: 'control.waitUntil',
+                condition: this.descendInputOfBlock(block, 'CONDITION')
+            };
+        case 'control_waitsecondsoruntil':
+            this.script.yields = true;
+            return {
+                kind: 'control.waitOrUntil',
+                seconds: this.descendInputOfBlock(block, 'DURATION'),
+                condition: this.descendInputOfBlock(block, 'CONDITION')
+            };
+        case 'control_while':
+            this.analyzeLoop();
+            return {
+                kind: 'control.while',
+                condition: this.descendInputOfBlock(block, 'CONDITION'),
+                do: this.descendSubstack(block, 'SUBSTACK'),
+                // We should consider analyzing this like we do for control_repeat_until
+                warpTimer: false
+            };
+        case 'control_run_as_sprite':
+            return {
+                kind: 'control.runAsSprite',
+                sprite: this.descendInputOfBlock(block, 'RUN_AS_OPTION'),
+                substack: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'control_new_script':
+            return {
+                kind: 'control.newScript',
+                substack: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'data_addtolist':
+            return {
+                kind: 'list.add',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                item: this.descendInputOfBlock(block, 'ITEM')
+            };
+        case 'data_changevariableby': {
+            const variable = this.descendVariable(block, 'VARIABLE', SCALAR_TYPE);
+            return {
+                kind: 'var.set',
+                variable,
+                value: {
+                    kind: 'op.add',
+                    left: {
+                        kind: 'var.get',
+                        variable
+                    },
+                    right: this.descendInputOfBlock(block, 'VALUE')
+                }
+            };
+        }
+        case 'data_deletealloflist':
+            return {
+                kind: 'list.deleteAll',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE)
+            };
+        case 'data_listforeachnum':
+            this.analyzeLoop();
+            return {
+                kind: 'list.forEach',
+                num: true,
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                variable: this.descendVariable(block, 'VARIABLE', SCALAR_TYPE),
+                do: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'data_listforeachitem':
+            this.analyzeLoop();
+            return {
+                kind: 'list.forEach',
+                num: false,
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                variable: this.descendVariable(block, 'VARIABLE', SCALAR_TYPE),
+                do: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'data_deleteoflist': {
+            const index = this.descendInputOfBlock(block, 'INDEX');
+            if (index.kind === 'constant' && index.value === 'all') {
+                return {
+                    kind: 'list.deleteAll',
+                    list: this.descendVariable(block, 'LIST', LIST_TYPE)
+                };
+            }
+            return {
+                kind: 'list.delete',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                index: index
+            };
+        }
+        case 'data_shiftlist': {
+            return {
+                kind: 'list.shift',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                index: this.descendInputOfBlock(block, 'INDEX')
+            };
+        }
+        case 'data_hidelist':
+            return {
+                kind: 'list.hide',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE)
+            };
+        case 'data_hidevariable':
+            return {
+                kind: 'var.hide',
+                variable: this.descendVariable(block, 'VARIABLE', SCALAR_TYPE)
+            };
+        case 'data_insertatlist':
+            return {
+                kind: 'list.insert',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                index: this.descendInputOfBlock(block, 'INDEX'),
+                item: this.descendInputOfBlock(block, 'ITEM')
+            };
+        case 'data_replaceitemoflist':
+            return {
+                kind: 'list.replace',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                index: this.descendInputOfBlock(block, 'INDEX'),
+                item: this.descendInputOfBlock(block, 'ITEM')
+            };
+        case 'data_setvariableto':
+            return {
+                kind: 'var.set',
+                variable: this.descendVariable(block, 'VARIABLE', SCALAR_TYPE),
+                value: this.descendInputOfBlock(block, 'VALUE')
+            };
+        case 'data_showlist':
+            return {
+                kind: 'list.show',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE)
+            };
+        case 'data_showvariable':
+            return {
+                kind: 'var.show',
+                variable: this.descendVariable(block, 'VARIABLE', SCALAR_TYPE)
+            };
+        case 'data_filterlist':
+            return {
+                kind: 'list.filter',
+                list: this.descendVariable(block, 'LIST', LIST_TYPE),
+                bool: this.descendInputOfBlock(block, 'BOOL')
+            };
+
+        case 'event_broadcast':
+            return {
+                kind: 'event.broadcast',
+                broadcast: this.descendInputOfBlock(block, 'BROADCAST_INPUT')
+            };
+        case 'event_broadcastandwait':
+            this.script.yields = true;
+            return {
+                kind: 'event.broadcastAndWait',
+                broadcast: this.descendInputOfBlock(block, 'BROADCAST_INPUT')
+            };
+
+        case 'looks_changeeffectby':
+            return {
+                kind: 'looks.changeEffect',
+                effect: block.fields.EFFECT.value.toLowerCase(),
+                value: this.descendInputOfBlock(block, 'CHANGE')
+            };
+        case 'looks_changesizeby':
+            return {
+                kind: 'looks.changeSize',
+                size: this.descendInputOfBlock(block, 'CHANGE')
+            };
+        case 'looks_cleargraphiceffects':
+            return {
+                kind: 'looks.clearEffects'
+            };
+        case 'looks_goforwardbackwardlayers':
+            if (block.fields.FORWARD_BACKWARD.value === 'forward') {
+                return {
+                    kind: 'looks.forwardLayers',
+                    layers: this.descendInputOfBlock(block, 'NUM')
+                };
+            }
+            return {
+                kind: 'looks.backwardLayers',
+                layers: this.descendInputOfBlock(block, 'NUM')
+            };
+        case 'looks_goTargetLayer':
+            if (block.fields.FORWARD_BACKWARD.value === 'infront') {
+                return {
+                    kind: 'looks.targetFront',
+                    layers: this.descendInputOfBlock(block, 'VISIBLE_OPTION')
+                };
+            }
+            return {
+                kind: 'looks.targetBack',
+                layers: this.descendInputOfBlock(block, 'VISIBLE_OPTION')
+            };
+        case 'looks_gotofrontback':
+            if (block.fields.FRONT_BACK.value === 'front') {
+                return {
+                    kind: 'looks.goToFront'
+                };
+            }
+            return {
+                kind: 'looks.goToBack'
+            };
+        case 'looks_hide':
+            return {
+                kind: 'looks.hide'
+            };
+        case 'looks_nextbackdrop':
+            return {
+                kind: 'looks.nextBackdrop'
+            };
+        case 'looks_nextcostume':
+            return {
+                kind: 'looks.nextCostume'
+            };
+        case 'looks_seteffectto':
+            return {
+                kind: 'looks.setEffect',
+                effect: block.fields.EFFECT.value.toLowerCase(),
+                value: this.descendInputOfBlock(block, 'VALUE')
+            };
+        case 'looks_setsizeto':
+            return {
+                kind: 'looks.setSize',
+                size: this.descendInputOfBlock(block, 'SIZE')
+            };
+        case "looks_setFont": 
+            return {
+                kind: 'looks.setFont',
+                font: this.descendInputOfBlock(block, 'font'),
+                size: this.descendInputOfBlock(block, 'size')
+            };
+        case "looks_setColor": 
+            return {
+                kind: 'looks.setColor',
+                prop: block.fields.prop.value,
+                color: this.descendInputOfBlock(block, 'color')
+            };
+        case "looks_setTintColor":
+            return {
+                kind: 'looks.setTintColor',
+                color: this.descendInputOfBlock(block, 'color')
+            };
+        case "looks_setShape": 
+            return {
+                kind: 'looks.setShape',
+                prop: block.fields.prop.value,
+                value: this.descendInputOfBlock(block, 'color')
+            };
+        case 'looks_show':
+            return {
+                kind: 'looks.show'
+            };
+        case 'looks_switchbackdropto':
+            return {
+                kind: 'looks.switchBackdrop',
+                backdrop: this.descendInputOfBlock(block, 'BACKDROP')
+            };
+        case 'looks_switchcostumeto':
+            return {
+                kind: 'looks.switchCostume',
+                costume: this.descendInputOfBlock(block, 'COSTUME')
+            };
+
+        case 'motion_changexby':
+            return {
+                kind: 'motion.changeX',
+                dx: this.descendInputOfBlock(block, 'DX')
+            };
+        case 'motion_changeyby':
+            return {
+                kind: 'motion.changeY',
+                dy: this.descendInputOfBlock(block, 'DY')
+            };
+        case 'motion_gotoxy':
+            return {
+                kind: 'motion.setXY',
+                x: this.descendInputOfBlock(block, 'X'),
+                y: this.descendInputOfBlock(block, 'Y')
+            };
+        case 'motion_ifonedgebounce':
+            return {
+                kind: 'motion.ifOnEdgeBounce'
+            };
+        case 'motion_movesteps':
+            return {
+                kind: 'motion.step',
+                steps: this.descendInputOfBlock(block, 'STEPS')
+            };
+        case 'motion_pointindirection':
+            return {
+                kind: 'motion.setDirection',
+                direction: this.descendInputOfBlock(block, 'DIRECTION')
+            };
+        case 'motion_setrotationstyle':
+            return {
+                kind: 'motion.setRotationStyle',
+                style: block.fields.STYLE.value
+            };
+        case 'motion_setx':
+            return {
+                kind: 'motion.setX',
+                x: this.descendInputOfBlock(block, 'X')
+            };
+        case 'motion_sety':
+            return {
+                kind: 'motion.setY',
+                y: this.descendInputOfBlock(block, 'Y')
+            };
+        case 'motion_turnleft':
+            return {
+                kind: 'motion.setDirection',
+                direction: {
+                    kind: 'op.subtract',
+                    left: {
+                        kind: 'motion.direction'
+                    },
+                    right: this.descendInputOfBlock(block, 'DEGREES')
+                }
+            };
+        case 'motion_turnright':
+            return {
+                kind: 'motion.setDirection',
+                direction: {
+                    kind: 'op.add',
+                    left: {
+                        kind: 'motion.direction'
+                    },
+                    right: this.descendInputOfBlock(block, 'DEGREES')
+                }
+            };
+
+        case 'pen_clear':
+            return {
+                kind: 'pen.clear'
+            };
+        case 'pen_changePenColorParamBy':
+            return {
+                kind: 'pen.changeParam',
+                param: this.descendInputOfBlock(block, 'COLOR_PARAM'),
+                value: this.descendInputOfBlock(block, 'VALUE')
+            };
+        case 'pen_changePenHueBy':
+            return {
+                kind: 'pen.legacyChangeHue',
+                hue: this.descendInputOfBlock(block, 'HUE')
+            };
+        case 'pen_changePenShadeBy':
+            return {
+                kind: 'pen.legacyChangeShade',
+                shade: this.descendInputOfBlock(block, 'SHADE')
+            };
+        case 'pen_penDown':
+            return {
+                kind: 'pen.down'
+            };
+        case 'pen_penUp':
+            return {
+                kind: 'pen.up'
+            };
+        case 'pen_setPenColorParamTo':
+            return {
+                kind: 'pen.setParam',
+                param: this.descendInputOfBlock(block, 'COLOR_PARAM'),
+                value: this.descendInputOfBlock(block, 'VALUE')
+            };
+        case 'pen_setPenColorToColor':
+            return {
+                kind: 'pen.setColor',
+                color: this.descendInputOfBlock(block, 'COLOR')
+            };
+        case 'pen_setPenHueToNumber':
+            return {
+                kind: 'pen.legacySetHue',
+                hue: this.descendInputOfBlock(block, 'HUE')
+            };
+        case 'pen_setPenShadeToNumber':
+            return {
+                kind: 'pen.legacySetShade',
+                shade: this.descendInputOfBlock(block, 'SHADE')
+            };
+        case 'pen_setPenSizeTo':
+            return {
+                kind: 'pen.setSize',
+                size: this.descendInputOfBlock(block, 'SIZE')
+            };
+        case 'pen_changePenSizeBy':
+            return {
+                kind: 'pen.changeSize',
+                size: this.descendInputOfBlock(block, 'SIZE')
+            };
+        case 'pen_stamp':
+            return {
+                kind: 'pen.stamp'
+            };
+        case 'procedures_return': 
+            return {
+                kind: 'procedures.return',
+                return: this.descendInputOfBlock(block, 'return')
+            };
+        case 'procedures_set': 
+            return {
+                kind: 'procedures.set',
+                param: this.descendInputOfBlock(block, "PARAM"),
+                val: this.descendInputOfBlock(block, "VALUE")
+            };
+        case 'procedures_call': {
+            // setting of yields will be handled later in the analysis phase
+            // patches output previewing
+            if (block.mutation.returns === 'true') {
+                const Block = Clone.simple(block);
+                Block.opcode = 'procedures_call_return';
+                return this.descendStackedBlock(Block);
+            }
+
+            const procedureCode = block.mutation.proccode;
+            if (procedureCode === 'tw:debugger;') {
+                return {
+                    kind: 'tw.debugger'
+                };
+            }
+            const paramNamesIdsAndDefaults = this.blocks.getProcedureParamNamesIdsAndDefaults(procedureCode);
+            if (paramNamesIdsAndDefaults === null) {
+                return {
+                    kind: 'noop'
+                };
+            }
+
+            const [paramNames, paramIds, paramDefaults] = paramNamesIdsAndDefaults;
+
+            const addonBlock = this.runtime.getAddonBlock(procedureCode);
+            if (addonBlock) {
+                this.script.yields = true;
+                const args = {};
+                for (let i = 0; i < paramIds.length; i++) {
+                    let value;
+                    if (block.inputs[paramIds[i]] && block.inputs[paramIds[i]].block) {
+                        value = this.descendInputOfBlock(block, paramIds[i]);
+                    } else {
+                        value = {
+                            kind: 'constant',
+                            value: paramDefaults[i]
+                        };
+                    }
+                    args[paramNames[i]] = value;
+                }
+                return {
+                    kind: 'addons.call',
+                    code: procedureCode,
+                    arguments: args,
+                    blockId: block.id
+                };
+            }
+
+            const definitionId = this.blocks.getProcedureDefinition(procedureCode);
+            const definitionBlock = this.blocks.getBlock(definitionId);
+            if (!definitionBlock) {
+                return {
+                    kind: 'noop'
+                };
+            }
+            const innerDefinition = this.blocks.getBlock(definitionBlock.inputs.custom_block.block);
+
+            let isWarp = this.script.isWarp;
+            if (!isWarp) {
+                if (innerDefinition && innerDefinition.mutation) {
+                    const warp = innerDefinition.mutation.warp;
+                    if (typeof warp === 'boolean') {
+                        isWarp = warp;
+                    } else if (typeof warp === 'string') {
+                        isWarp = JSON.parse(warp);
+                    }
+                }
+            }
+
+            const variant = generateProcedureVariant(procedureCode, isWarp);
+
+            if (!this.script.dependedProcedures.includes(variant)) {
+                this.script.dependedProcedures.push(variant);
+            }
+
+            // Non-warp direct recursion yields.
+            if (!this.script.isWarp) {
+                if (procedureCode === this.script.procedureCode) {
+                    this.script.yields = true;
+                }
+            }
+
+            const args = [];
+            for (let i = 0; i < paramIds.length; i++) {
+                let value;
+                if (block.inputs[paramIds[i]] && block.inputs[paramIds[i]].block) {
+                    if (paramIds[i].startsWith("SUBSTACK")) {
+                        value = this.descendSubstack(block, paramIds[i])
+                    } else {
+                        value = this.descendInputOfBlock(block, paramIds[i]);
+                    }
+                } else {
+                    value = {
+                        kind: 'constant',
+                        value: paramDefaults[i]
+                    };
+                }
+                args.push(value);
+            }
+
+            return {
+                kind: 'procedures.call',
+                code: procedureCode,
+                variant,
+                returns: false,
+                arguments: args,
+                type: JSON.parse(block.mutation.optype || '"statement"')
+            };
+        }
+
+        case 'sensing_set_of':
+            return {
+                kind: 'sensing.set.of',
+                property: block.fields.PROPERTY.value,
+                object: this.descendInputOfBlock(block, 'OBJECT'),
+                value: this.descendInputOfBlock(block, 'VALUE')
+            };
+        case 'sensing_resettimer':
+            return {
+                kind: 'timer.reset'
+            };
+
+            /*
+            can someone set up the jsgen for these, i dont want to rn
+            case "sensing_regextest":
+                return {
+                    kind: "sensing.regextest",
+                    regex: this.descendInputOfBlock(block, 'reg'),
+                    text: this.descendInputOfBlock(block, 'text')
+                }
+            case "sensing_thing_is_number":
+                return {
+                    kind: "sensing.thing.is.number",
+                    text: this.descendInputOfBlock(block, 'TEXT1')
+                }
+            case "sensing_mobile":
+                return {
+                    kind: "sensing.mobile",
+                }
+            case "sensing_thing_is_text":
+                return {
+                    kind: "sensing.thing.is.text",
+                    text: this.descendInputOfBlock(block, 'TEXT1')
+                }
+            case "sensing_getspritewithattrib":
+                return {
+                    kind: "sensing.getspritewithattrib",
+                    variable: this.descendInputOfBlock(block, 'var'),
+                    value: this.descendInputOfBlock(block, 'val')
+                }
+
+            case "operator_regexmatch":
+                return {
+                    kind: "operator.regexmatch",
+                    regex: this.descendInputOfBlock(block, 'reg'),
+                    text: this.descendInputOfBlock(block, 'text')
+                }
+            case "operator_replaceAll":
+                return {
+                    kind: "operator.replaceAll",
+                    text: this.descendInputOfBlock(block, 'term'),
+                    with: this.descendInputOfBlock(block, 'res'),
+                    in: this.descendInputOfBlock(block, 'text')
+                }
+            case "operator_getLettersFromIndexToIndexInTextFixed":
+            case "operator_getLettersFromIndexToIndexInText":
+                return {
+                    kind: "operator.getLettersFromIndexToIndexInText",
+                    from: this.descendInputOfBlock(block, 'INDEX1'),
+                    to: this.descendInputOfBlock(block, 'INDEX2'),
+                    ammount: this.descendInputOfBlock(block, 'TEXT')
+                }
+            case "operator_readLineInMultilineText":
+                return {
+                    kind: "operator.readLineInMultilineText",
+                    line: this.descendInputOfBlock(block, 'LINE'),
+                    text: this.descendInputOfBlock(block, 'TEXT')
+                }
+            case "operator_newLine":
+                return {
+                    kind: "operator.newLine",
+                }
+            case "operator_stringify":
+                return {
+                    kind: "operator.stringify",
+                    pass: this.descendInputOfBlock(block, 'ONE')
+                }
+            case "operator_lerpFunc":
+                return {
+                    kind: "operator.lerpFunc",
+                    from: this.descendInputOfBlock(block, 'ONE'),
+                    to: this.descendInputOfBlock(block, 'TWO'),
+                    ammount: this.descendInputOfBlock(block, 'AMOUNT')
+                }
+            case "operator_advMath":
+                return {
+                    kind: "operator.advMath",
+                    num1: this.descendInputOfBlock(block, 'ONE'),
+                    num2: this.descendInputOfBlock(block, 'TWO'),
+                    op: block.fields.OPTION.value
+                }
+            case "operator_constrainnumber":
+                return {
+                    kind: "operator.constrainnumber",
+                    number: this.descendInputOfBlock(block, 'inp'),
+                    min: this.descendInputOfBlock(block, 'min'),
+                    max: this.descendInputOfBlock(block, 'max')
+                }
+            case "operator_trueBoolean":
+                return {
+                    kind: "operator.trueBoolean",
+                }
+            case "operator_falseBoolean":
+                return {
+                    kind: "operator.falseBoolean",
+                }
+            case "operator_randomBoolean":
+                return {
+                    kind: "operator.randomBoolean",
+                }
+            case "operator_indexOfTextInText":
+                return {
+                    kind: "operator.indexOfTextInText",
+                    check: this.descendInputOfBlock(block, 'TEXT1'),
+                    text: this.descendInputOfBlock(block, 'TEXT2')
+                }
+
+            case "event_whenanything":
+                return {
+                    kind: "event.whenanything",
+                }
+            case "event_always":
+                return {
+                    kind: "event.always",
+                    event: this.descendInputOfBlock(block, 'ANYTHING')
+                }
+
+            case "control_backToGreenFlag":
+                return {
+                    kind: "control.backToGreenFlag",
+                }
+            case "control_if_return_else_return":
+                return {
+                    kind: "control.if.return.else.return",
+                    if: this.descendInputOfBlock(block, 'boolean'),
+                    true: this.descendInputOfBlock(block, 'TEXT1'),
+                    false: this.descendInputOfBlock(block, 'TEXT2'),
+                }
+            all the names so you dont have to get them 
+            sensing.regextest
+            sensing.thing.is.number
+            sensing.mobile
+            sensing.thing.is.text
+            sensing.getspritewithattrib
+
+            operator.regexmatch
+            operator.replaceAll
+            operator.getLettersFromIndexToIndexInText
+            operator.readLineInMultilineText
+            operator.newLine
+            operator.stringify
+            operator.lerpFunc
+            operator.advMath
+            operator.constrainnumber
+            operator.trueBoolean
+            operator.falseBoolean
+            operator.randomBoolean
+            operator.indexOfTextInText
+
+            event.whenanything
+            event.always
+
+            control.backToGreenFlag
+            control.if.return.else.return
+            */
+
+        case 'lmsTempVars2_setRuntimeVariable':
+            return {
+                kind: 'tempVars.set',
+                var: this.descendInputOfBlock(block, 'VAR'),
+                val: this.descendInputOfBlock(block, 'STRING'),
+                runtime: true
+            };
+        case 'lmsTempVars2_setThreadVariable':
+            return {
+                kind: 'tempVars.set',
+                var: this.descendInputOfBlock(block, 'VAR'),
+                val: this.descendInputOfBlock(block, 'STRING'),
+                thread: true
+            };
+        case 'tempVars_setVariable':
+            return {
+                kind: 'tempVars.set',
+                var: this.descendInputOfBlock(block, 'name'),
+                val: this.descendInputOfBlock(block, 'value')
+            };
+        
+        case 'lmsTempVars2_changeRuntimeVariable':
+            const name = this.descendInputOfBlock(block, 'VAR');
+            return {
+                kind: 'tempVars.set',
+                var: name,
+                val: {
+                    kind: 'op.add',
+                    left: {
+                        kind: 'tempVars.get',
+                        var: name,
+                        runtime: true
+                    },
+                    right: this.descendInputOfBlock(block, 'NUM')
+                },
+                runtime: true
+            };
+        case 'lmsTempVars2_changeThreadVariable': {
+            const name = this.descendInputOfBlock(block, 'VAR');
+            return {
+                kind: 'tempVars.set',
+                var: name,
+                val: {
+                    kind: 'op.add',
+                    left: {
+                        kind: 'tempVars.get',
+                        var: name,
+                        thread: true
+                    },
+                    right: this.descendInputOfBlock(block, 'NUM')
+                },
+                thread: true
+            };
+        }
+        case 'tempVars_changeVariable': {
+            const name = this.descendInputOfBlock(block, 'name');
+            return {
+                kind: 'tempVars.set',
+                var: name,
+                val: {
+                    kind: 'op.add',
+                    left: {
+                        kind: 'tempVars.get',
+                        var: name
+                    },
+                    right: this.descendInputOfBlock(block, 'value')
+                }
+            };
+        }
+
+        case 'lmsTempVars2_deleteRuntimeVariable':
+            return {
+                kind: 'tempVars.delete',
+                var: this.descendInputOfBlock(block, 'VAR'),
+                runtime: true
+            };
+        case 'tempVars_deleteVariable':
+            return {
+                kind: 'tempVars.delete',
+                var: this.descendInputOfBlock(block, 'name')
+            };
+
+        case 'lmsTempVars2_deleteAllRuntimeVariables':
+            return {
+                kind: 'tempVars.deleteAll',
+                runtime: true
+            };
+        case 'tempVars_deleteAllVariables':
+            return {
+                kind: 'tempVars.deleteAll'
+            };
+
+        case 'lmsTempVars2_forEachThreadVariable':
+            return {
+                kind: 'tempVars.forEach',
+                var: this.descendInputOfBlock(block, 'VAR'),
+                loops: this.descendInputOfBlock(block, 'NUM'),
+                do: this.descendSubstack(block, 'SUBSTACK'),
+                thread: true
+            };
+        case 'tempVars_forEachTempVar':
+            this.analyzeLoop();
+            return {
+                kind: 'tempVars.forEach',
+                var: this.descendInputOfBlock(block, 'NAME'),
+                loops: this.descendInputOfBlock(block, 'REPEAT'),
+                do: this.descendSubstack(block, 'SUBSTACK')
+            };
+        case 'control_dualblock':
+            return {
+                kind: 'control.dualBlock'
+            };
+
+        default: {
+            const opcodeFunction = this.runtime.getOpcodeFunction(block.opcode);
+            if (opcodeFunction) {
+                // It might be a non-compiled primitive from a standard category
+                if (compatBlocks.statementBlocks.includes(block.opcode)) {
+                    return this.descendCompatLayer(block);
+                }
+                // It might be an extension block.
+                const blockInfo = this.getBlockInfo(block.opcode);
+                if (blockInfo) {
+                    const type = blockInfo.info.blockType;
+                    const args = this.descendCompatLayer(block, blockInfo.info);
+                    args.block = block;
+                    if (block.mutation) args.mutation = block.mutation;
+                    if (type === BlockType.COMMAND || type === BlockType.CONDITIONAL || type === BlockType.LOOP) {
+                        return args;
+                    }
+                }
+            }
+
+            // When this thread was triggered by a stack click, attempt to compile as an input.
+            // TODO: perhaps this should be moved to generate()?
+            if (this.thread.stackClick) {
+                try {
+                    const inputNode = this.descendInput(block);
+                    return {
+                        kind: 'visualReport',
+                        input: inputNode
+                    };
+                } catch (e) {
+                    // Ignore
+                }
+            }
+
+            log.warn(`IR: Unknown stacked block: ${block.opcode}`, block);
+            throw new Error(`IR: Unknown stacked block: ${block.opcode}`);
+        }
+        }
+    }
+
+    /**
+     * Descend into a stack of blocks (eg. the blocks contained within an "if" block)
+     * @param {*} parentBlock The parent Scratch block that contains the stack to parse.
+     * @param {*} substackName The name of the stack to descend into.
+     * @private
+     * @returns {Node[]} List of stacked block nodes.
+     */
+    descendSubstack (parentBlock, substackName) {
+        const input = parentBlock.inputs[substackName];
+        if (!input) {
+            return [];
+        }
+        const stackId = input.block;
+        return this.walkStack(stackId);
+    }
+
+    /**
+     * Descend into and walk the siblings of a stack.
+     * @param {string} startingBlockId The ID of the first block of a stack.
+     * @private
+     * @returns {Node[]} List of stacked block nodes.
+     */
+    walkStack (startingBlockId) {
+        const result = [];
+        let blockId = startingBlockId;
+
+        while (blockId !== null) {
+            const block = this.getBlockById(blockId);
+            if (!block) {
+                break;
+            }
+
+            const node = this.descendStackedBlock(block);
+            result.push(node);
+
+            blockId = block.next;
+        }
+
+        return result;
+    }
+
+    /**
+     * Descend into a variable.
+     * @param {*} block The block that has the variable.
+     * @param {string} fieldName The name of the field that the variable is stored in.
+     * @param {''|'list'} type Variable type, '' for scalar and 'list' for list.
+     * @private
+     * @returns {*} A parsed variable object.
+     */
+    descendVariable (block, fieldName, type) {
+        const variable = block.fields[fieldName];
+        const id = variable.id;
+
+        if (this.variableCache.hasOwnProperty(id)) {
+            return this.variableCache[id];
+        }
+
+        const data = this._descendVariable(id, variable.value, type);
+        this.variableCache[id] = data;
+        return data;
+    }
+
+    /**
+     * @param {string} id The ID of the variable.
+     * @param {string} name The name of the variable.
+     * @param {''|'list'} type The variable type.
+     * @private
+     * @returns {*} A parsed variable object.
+     */
+    _descendVariable (id, name, type) {
+        const target = this.target;
+        const stage = this.stage;
+
+        // Look for by ID in target...
+        if (target.variables.hasOwnProperty(id)) {
+            return createVariableData('target', target.variables[id]);
+        }
+
+        // Look for by ID in stage...
+        if (!target.isStage) {
+            if (stage && stage.variables.hasOwnProperty(id)) {
+                return createVariableData('stage', stage.variables[id]);
+            }
+        }
+
+        // Look for by name and type in target...
+        for (const varId in target.variables) {
+            if (target.variables.hasOwnProperty(varId)) {
+                const currVar = target.variables[varId];
+                if (currVar.name === name && currVar.type === type) {
+                    return createVariableData('target', currVar);
+                }
+            }
+        }
+
+        // Look for by name and type in stage...
+        if (!target.isStage && stage) {
+            for (const varId in stage.variables) {
+                if (stage.variables.hasOwnProperty(varId)) {
+                    const currVar = stage.variables[varId];
+                    if (currVar.name === name && currVar.type === type) {
+                        return createVariableData('stage', currVar);
+                    }
+                }
+            }
+        }
+
+        // Create it locally...
+        const newVariable = this.runtime.newVariableInstance(type, id, name, false);
+        target.variables[id] = newVariable;
+
+        if (target.sprite) {
+            // Create the variable in all instances of this sprite.
+            // This is necessary because the script cache is shared between clones.
+            // sprite.clones has all instances of this sprite including the original and all clones
+            for (const clone of target.sprite.clones) {
+                if (!clone.variables.hasOwnProperty(id)) {
+                    clone.variables[id] = this.runtime.newVariableInstance(type, id, name, false);
+                }
+            }
+        }
+
+        return createVariableData('target', newVariable);
+    }
+
+    /**
+     * Descend into a block that uses the compatibility layer.
+     * @param {*} block The block to use the compatibility layer for.
+     * @private
+     * @returns {Node} The parsed node.
+     */
+    descendCompatLayer (block, blockInfo) {
+        this.script.yields = true;
+        if (!blockInfo) {
+            blockInfo = this.getBlockInfo(block.opcode);
+            blockInfo = blockInfo ? blockInfo.info : null;
+        }
+        
+        const inputs = {};
+        for (const name of Object.keys(block.inputs)) {
+            if (!name.startsWith('SUBSTACK')) {
+                inputs[name] = this.descendInputOfBlock(block, name);
+            }
+        }
+
+        const fields = {};
+        const substacks = [];
+        const blockType = (blockInfo && blockInfo.blockType) || BlockType.COMMAND;
+        if (blockType === BlockType.CONDITIONAL || blockType === BlockType.LOOP) {
+            for (let i in (blockInfo.branches || [])) {
+                const inputName = i === "0" ? 'SUBSTACK' : `SUBSTACK${Number(i) + 1}`;
+                substacks.push(this.descendSubstack(block, inputName));
+            }
+        }
+        for (const name of Object.keys(block.fields)) {
+            const type = block.fields[name].variableType;
+            if (typeof type !== 'undefined') {
+                const data = this.descendVariable(block, name, type);
+                fields[name] = data;
+                continue;
+            }
+            fields[name] = block.fields[name].value;
+        }
+        return {
+            kind: 'compat',
+            id: block.id,
+            opcode: block.opcode,
+            blockType,
+            inputs,
+            fields,
+            substacks
+        };
+    }
+
+    analyzeLoop () {
+        if (!this.script.isWarp || this.script.warpTimer) {
+            this.script.yields = true;
+        }
+    }
+
+    readTopBlockComment (commentId) {
+        const comment = this.target.comments[commentId];
+        if (!comment) {
+            // can't find the comment
+            // this is safe to ignore
+            return;
+        }
+
+        const text = comment.text;
+
+        for (const line of text.split('\n')) {
+            if (!/^tw\b/.test(line)) {
+                continue;
+            }
+
+            const flags = line.split(' ');
+            for (const flag of flags) {
+                switch (flag) {
+                case 'nocompile':
+                    throw new Error('Script explicitly disables compilation');
+                case 'stuck':
+                    this.script.warpTimer = true;
+                    break;
+                }
+            }
+
+            // Only the first 'tw' line is parsed.
+            break;
+        }
+    }
+    
+    /**
+     * @param {Block} hatBlock
+     */
+    walkHat(hatBlock) {
+        const nextBlock = hatBlock.next;
+        const opcode = hatBlock.opcode;
+        const hatInfo = this.runtime._hats[opcode];
+
+        if (this.thread.stackClick) {
+            // We still need to treat the hat as a normal block (so executableHat should be false) for
+            // interpreter parity, but the reuslt is ignored.
+            const opcodeFunction = this.runtime.getOpcodeFunction(opcode);
+            if (opcodeFunction) {
+                return [
+                    this.descendCompatLayer(hatBlock),
+                    ...this.walkStack(nextBlock)
+                ];
+            }
+            return this.walkStack(nextBlock);
+        }
+
+        if (hatInfo.edgeActivated) {
+            // Edge-activated HAT
+            this.script.yields = true;
+            this.script.executableHat = true;
+            return [
+                {
+                    kind: 'hat.edge',
+                    id: hatBlock.id,
+                    condition: this.descendCompatLayer(hatBlock)
+                },
+                ...this.walkStack(nextBlock)
+            ];
+        }
+
+        const opcodeFunction = this.runtime.getOpcodeFunction(opcode);
+        if (opcodeFunction) {
+            // Predicate-based HAT
+            this.script.yields = true;
+            this.script.executableHat = true;
+            return [
+                {
+                    kind: 'hat.predicate',
+                    condition: this.descendCompatLayer(hatBlock)
+                },
+                ...this.walkStack(nextBlock)
+            ];
+        }
+
+        return this.walkStack(nextBlock);
+    }
+
+    /**
+     * @param {string} topBlockId The ID of the top block of the script.
+     * @returns {IntermediateScript}
+     */
+    generate (topBlockId) {
+        this.blocks.populateProcedureCache();
+
+        this.script.topBlockId = topBlockId;
+
+        const topBlock = this.getBlockById(topBlockId);
+        if (!topBlock) {
+            if (this.script.isProcedure) {
+                // Empty procedure
+                return this.script;
+            }
+            throw new Error('Cannot find top block');
+        }
+
+        if (topBlock.comment) {
+            this.readTopBlockComment(topBlock.comment);
+        }
+
+        // We do need to evaluate empty hats
+        const hatInfo = this.runtime._hats[topBlock.opcode];
+        const isHat = !!hatInfo;
+        if (isHat) {
+            this.script.stack = this.walkHat(topBlock);
+        } else {
+            // We don't evaluate the procedures_definition top block as it never does anything
+            // We also don't want it to be treated like a hat block
+            let entryBlock;
+            if (
+                topBlock.opcode === 'procedures_definition'
+                || topBlock.opcode === 'procedures_definition_return'
+            ) {
+                entryBlock = topBlock.next;
+            } else {
+                entryBlock = topBlockId;
+            }
+
+            if (entryBlock) {
+                this.script.stack = this.walkStack(entryBlock);
+            }
+        }
+
+        return this.script;
+    }
+}
+
+class IRGenerator {
+    constructor (thread) {
+        this.thread = thread;
+        this.blocks = thread.blockContainer;
+
+        this.proceduresToCompile = new Map();
+        this.compilingProcedures = new Map();
+        /** @type {Object.<string, IntermediateScript>} */
+        this.procedures = {};
+
+        this.analyzedProcedures = [];
+    }
+
+    static _extensionIRInfo = {};
+    static setExtensionIr(id, data) {
+        IRGenerator._extensionIRInfo[id] = data;
+    }
+    static hasExtensionIr(id) {
+        return Boolean(IRGenerator._extensionIRInfo[id]);
+    }
+    static getExtensionIr(id) {
+        return IRGenerator._extensionIRInfo[id];
+    }
+
+    addProcedureDependencies (dependencies) {
+        for (const procedureVariant of dependencies) {
+            if (this.procedures.hasOwnProperty(procedureVariant)) {
+                continue;
+            }
+            if (this.compilingProcedures.has(procedureVariant)) {
+                continue;
+            }
+            if (this.proceduresToCompile.has(procedureVariant)) {
+                continue;
+            }
+            const procedureCode = parseProcedureCode(procedureVariant);
+            const definition = this.blocks.getProcedureDefinition(procedureCode);
+            this.proceduresToCompile.set(procedureVariant, definition);
+        }
+    }
+
+    /**
+     * @param {ScriptTreeGenerator} generator The generator to run.
+     * @param {string} topBlockId The ID of the top block in the stack.
+     * @returns {IntermediateScript} Intermediate script.
+     */
+    generateScriptTree (generator, topBlockId) {
+        const result = generator.generate(topBlockId);
+        this.addProcedureDependencies(result.dependedProcedures);
+        return result;
+    }
+
+    /**
+     * Recursively analyze a script and its dependencies.
+     * @param {IntermediateScript} script Intermediate script.
+     */
+    analyzeScript (script) {
+        let madeChanges = false;
+        for (const procedureCode of script.dependedProcedures) {
+            const procedureData = this.procedures[procedureCode];
+
+            // Analyze newly found procedures.
+            if (!this.analyzedProcedures.includes(procedureCode)) {
+                this.analyzedProcedures.push(procedureCode);
+                if (this.analyzeScript(procedureData)) {
+                    madeChanges = true;
+                }
+                this.analyzedProcedures.pop();
+            }
+
+            // If a procedure used by a script may yield, the script itself may yield.
+            if (procedureData.yields && !script.yields) {
+                script.yields = true;
+                madeChanges = true;
+            }
+        }
+        return madeChanges;
+    }
+
+    /**
+     * @returns {IntermediateRepresentation} Intermediate representation.
+     */
+    generate () {
+        const entry = this.generateScriptTree(new ScriptTreeGenerator(this.thread), this.thread.topBlock);
+
+        // Compile any required procedures.
+        // As procedures can depend on other procedures, this process may take several iterations.
+        const procedureTreeCache = this.blocks._cache.compiledProcedures;
+        while (this.proceduresToCompile.size > 0) {
+            this.compilingProcedures = this.proceduresToCompile;
+            this.proceduresToCompile = new Map();
+
+            for (const [procedureVariant, definitionId] of this.compilingProcedures.entries()) {
+                if (procedureTreeCache[procedureVariant]) {
+                    const result = procedureTreeCache[procedureVariant];
+                    this.procedures[procedureVariant] = result;
+                    this.addProcedureDependencies(result.dependedProcedures);
+                } else {
+                    const isWarp = parseIsWarp(procedureVariant);
+                    const generator = new ScriptTreeGenerator(this.thread);
+                    generator.setProcedureVariant(procedureVariant);
+                    if (isWarp) generator.enableWarp();
+                    const compiledProcedure = this.generateScriptTree(generator, definitionId);
+                    this.procedures[procedureVariant] = compiledProcedure;
+                    procedureTreeCache[procedureVariant] = compiledProcedure;
+                }
+            }
+        }
+
+        // Analyze scripts until no changes are made.
+        while (this.analyzeScript(entry));
+
+        const ir = new IntermediateRepresentation();
+        ir.entry = entry;
+        ir.procedures = this.procedures;
+        return ir;
+    }
+    
+    static exports = {
+        ScriptTreeGenerator
+    }
+}
+
+module.exports = IRGenerator;

src/compiler/jsexecute.js

@@ -0,0 +1,715 @@
+/**
+ * @fileoverview Runtime for scripts generated by jsgen
+ */
+
+/* eslint-disable no-unused-vars */
+/* eslint-disable prefer-template */
+/* eslint-disable valid-jsdoc */
+/* eslint-disable max-len */
+
+const globalState = {
+    Timer: require('../util/timer'),
+    Cast: require('../util/cast'),
+    log: require('../util/log'),
+    blockUtility: require('./compat-block-utility'),
+    thread: null
+};
+
+let baseRuntime = '';
+const runtimeFunctions = {};
+
+/**
+ * Determine whether the current tick is likely stuck.
+ * This implements similar functionality to the warp timer found in Scratch.
+ * @returns {boolean} true if the current tick is likely stuck.
+ */
+baseRuntime += `let stuckCounter = 0;
+const isStuck = () => {
+    // The real time is not checked on every call for performance.
+    stuckCounter++;
+    if (stuckCounter === 100) {
+        stuckCounter = 0;
+        return globalState.thread.target.runtime.sequencer.timer.timeElapsed() > 500;
+    }
+    return false;
+};`;
+
+/**
+ * Alternative for nullish Coalescing
+ * @param {string} name The variable to get
+ * @returns {any} The value of the temp var or an empty string if its nullish
+ */
+runtimeFunctions.nullish = `const nullish = (check, alt) => {
+    if (!check) {
+        if (val === undefined) return alt
+        if (val === null) return alt
+        return check
+    } else {
+        return check
+    }
+}`;
+
+/**
+ * Start hats by opcode.
+ * @param {string} requestedHat The opcode of the hat to start.
+ * @param {*} optMatchFields Fields to match.
+ * @returns {Array} A list of threads that were started.
+ */
+runtimeFunctions.startHats = `const startHats = (requestedHat, optMatchFields) => {
+    const thread = globalState.thread;
+    const threads = thread.target.runtime.startHats(requestedHat, optMatchFields);
+    return threads;
+}`;
+
+/**
+ * Implements "thread waiting", where scripts are halted until all the scripts have finished executing.
+ * @param {Array} threads The list of threads.
+ */
+runtimeFunctions.waitThreads = `const waitThreads = function*(threads) {
+    const thread = globalState.thread;
+    const runtime = thread.target.runtime;
+
+    while (true) {
+        // determine whether any threads are running
+        let anyRunning = false;
+        for (let i = 0; i < threads.length; i++) {
+            if (runtime.threads.indexOf(threads[i]) !== -1) {
+                anyRunning = true;
+                break;
+            }
+        }
+        if (!anyRunning) {
+            // all threads are finished, can resume
+            return;
+        }
+
+        let allWaiting = true;
+        for (let i = 0; i < threads.length; i++) {
+            if (!runtime.isWaitingThread(threads[i])) {
+                allWaiting = false;
+                break;
+            }
+        }
+        if (allWaiting) {
+            thread.status = 3; // STATUS_YIELD_TICK
+        }
+
+        yield;
+    }
+}`;
+
+/**
+ * waitPromise: Wait until a Promise resolves or rejects before continuing.
+ * @param {Promise} promise The promise to wait for.
+ * @returns {*} the value that the promise resolves to, otherwise undefined if the promise rejects
+ */
+runtimeFunctions.waitPromise = `
+const waitPromise = function*(promise) {
+    const thread = globalState.thread;
+    let returnValue;
+    let errorReturn;
+
+    promise
+        .then(value => {
+            returnValue = value;
+            thread.status = 0; // STATUS_RUNNING
+        })
+        .catch(error => {
+            errorReturn = error;
+            // i realized, i dont actually know what would happen if we never do this but throw and exit anyways
+            thread.status = 0; // STATUS_RUNNING
+        });
+
+    // enter STATUS_PROMISE_WAIT and yield
+    // this will stop script execution until the promise handlers reset the thread status
+    thread.status = 1; // STATUS_PROMISE_WAIT
+    yield;
+
+    // throw the promise error if ee got one
+    if (errorReturn) throw errorReturn
+    return returnValue;
+}`;
+
+/**
+ * isPromise: Determine if a value is Promise-like
+ * @param {unknown} promise The value to check
+ * @returns {promise is PromiseLike} True if the value is Promise-like (has a .then())
+ */
+
+/**
+ * executeInCompatibilityLayer: Execute a scratch-vm primitive.
+ * @param {*} inputs The inputs to pass to the block.
+ * @param {function} blockFunction The primitive's function.
+ * @param {boolean} useFlags Whether to set flags (hasResumedFromPromise)
+ * @param {string} blockId Block ID to set on the emulated block utility.
+ * @param {*|null} branchInfo Extra information object for CONDITIONAL and LOOP blocks. See createBranchInfo().
+ * @returns {*} the value returned by the block, if any.
+ */
+runtimeFunctions.executeInCompatibilityLayer = `let hasResumedFromPromise = false;
+
+const isPromise = value => (
+    // see engine/execute.js
+    value !== null &&
+    typeof value === 'object' &&
+    typeof value.then === 'function'
+);
+const executeInCompatibilityLayer = function*(inputs, blockFunction, isWarp, useFlags, blockId, branchInfo, visualReport) {
+    const thread = globalState.thread;
+    const blockUtility = globalState.blockUtility;
+    const stackFrame = branchInfo ? branchInfo.stackFrame : {};
+    const finish = (returnValue) => {
+        if (branchInfo) {
+            if (typeof returnValue === 'undefined' && blockUtility._startedBranch) {
+                branchInfo.isLoop = blockUtility._startedBranch[1];
+                return blockUtility._startedBranch[0];
+            }
+            branchInfo.isLoop = branchInfo.defaultIsLoop;
+            return returnValue;
+        }
+        return returnValue;
+    };
+
+    // reset the stackframe
+    // we only ever use one stackframe at a time, so this shouldn't cause issues
+    thread.stackFrames[thread.stackFrames.length - 1].reuse(isWarp);
+
+    const executeBlock = () => {
+        blockUtility.init(thread, blockId, stackFrame, branchInfo);
+        return blockFunction(inputs, blockUtility, visualReport);
+    };
+
+    let returnValue = executeBlock();
+    if (isPromise(returnValue)) {
+        returnValue = finish(yield* waitPromise(returnValue));
+        if (useFlags) hasResumedFromPromise = true;
+        return returnValue;
+    }
+
+    if (thread.status === 1 /* STATUS_PROMISE_WAIT */ || thread.status === 4 /* STATUS_DONE */) {
+        // Something external is forcing us to stop
+        yield;
+        // Make up a return value because whatever is forcing us to stop can't specify one
+        return '';
+    }
+
+    while (thread.status === 2 /* STATUS_YIELD */ || thread.status === 3 /* STATUS_YIELD_TICK */) {
+        // Yielded threads will run next iteration.
+        if (thread.status === 2 /* STATUS_YIELD */) {
+            thread.status = 0; // STATUS_RUNNING
+            // Yield back to the event loop when stuck or not in warp mode.
+            if (!isWarp || isStuck()) {
+                yield;
+            }
+        } else {
+            // status is STATUS_YIELD_TICK, always yield to the event loop
+            yield;
+        }
+
+        returnValue = executeBlock();
+        if (isPromise(returnValue)) {
+            returnValue = finish(yield* waitPromise(returnValue));
+            if (useFlags) hasResumedFromPromise = true;
+            return returnValue;
+        }
+
+        if (thread.status === 1 /* STATUS_PROMISE_WAIT */ || thread.status === 4 /* STATUS_DONE */) {
+            yield;
+            return finish('');
+        }
+    }
+    return finish(returnValue);
+}`;
+
+/**
+ * @param {boolean} isLoop True if the block is a LOOP by default (can be overridden by startBranch() call)
+ * @returns {unknown} Branch info object for compatibility layer.
+ */
+runtimeFunctions.createBranchInfo = `const createBranchInfo = (isLoop) => ({
+    defaultIsLoop: isLoop,
+    isLoop: false,
+    branch: 0,
+    stackFrame: {},
+    onEnd: [],
+});`;
+
+/**
+ * End the current script.
+ */
+runtimeFunctions.retire = `const retire = () => {
+    const thread = globalState.thread;
+    thread.target.runtime.sequencer.retireThread(thread);
+}`;
+
+/**
+ * Scratch cast to boolean.
+ * Similar to Cast.toBoolean()
+ * @param {*} value The value to cast
+ * @returns {boolean} The value cast to a boolean
+ */
+runtimeFunctions.toBoolean = `const toBoolean = value => {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        if (value === '' || value === '0' || value.toLowerCase() === 'false') {
+            return false;
+        }
+        return true;
+    }
+    return !!value;
+}`;
+
+/**
+ * If a number is very close to a whole number, round to that whole number.
+ * @param {number} value Value to round
+ * @returns {number} Rounded number or original number
+ */
+runtimeFunctions.limitPrecision = `const limitPrecision = value => {
+    const rounded = Math.round(value);
+    const delta = value - rounded;
+    return (Math.abs(delta) < 1e-9) ? rounded : value;
+}`;
+
+/**
+ * Used internally by the compare family of function.
+ * See similar method in cast.js.
+ * @param {*} val A value that evaluates to 0 in JS string-to-number conversation such as empty string, 0, or tab.
+ * @returns {boolean} True if the value should not be treated as the number zero.
+ */
+baseRuntime += `const isNotActuallyZero = val => {
+    if (typeof val !== 'string') return false;
+    for (let i = 0; i < val.length; i++) {
+        const code = val.charCodeAt(i);
+        if (code === 48 || code === 9) {
+            return false;
+        }
+    }
+    return true;
+};`;
+
+/**
+ * Determine if two values are equal.
+ * @param {*} v1 First value
+ * @param {*} v2 Second value
+ * @returns {boolean} true if v1 is equal to v2
+ */
+baseRuntime += `const compareEqualSlow = (v1, v2) => {
+    const n1 = +v1;
+    if (isNaN(n1) || (n1 === 0 && isNotActuallyZero(v1))) return ('' + v1).toLowerCase() === ('' + v2).toLowerCase();
+    const n2 = +v2;
+    if (isNaN(n2) || (n2 === 0 && isNotActuallyZero(v2))) return ('' + v1).toLowerCase() === ('' + v2).toLowerCase();
+    return n1 === n2;
+};
+const compareEqual = (v1, v2) => (typeof v1 === 'number' && typeof v2 === 'number' && !isNaN(v1) && !isNaN(v2) || v1 === v2) ? v1 === v2 : compareEqualSlow(v1, v2);`;
+
+/**
+ * Determine if one value is greater than another.
+ * @param {*} v1 First value
+ * @param {*} v2 Second value
+ * @returns {boolean} true if v1 is greater than v2
+ */
+runtimeFunctions.compareGreaterThan = `const compareGreaterThanSlow = (v1, v2) => {
+    let n1 = +v1;
+    let n2 = +v2;
+    if (n1 === 0 && isNotActuallyZero(v1)) {
+        n1 = NaN;
+    } else if (n2 === 0 && isNotActuallyZero(v2)) {
+        n2 = NaN;
+    }
+    if (isNaN(n1) || isNaN(n2)) {
+        const s1 = ('' + v1).toLowerCase();
+        const s2 = ('' + v2).toLowerCase();
+        return s1 > s2;
+    }
+    return n1 > n2;
+};
+const compareGreaterThan = (v1, v2) => typeof v1 === 'number' && typeof v2 === 'number' && !isNaN(v1) ? v1 > v2 : compareGreaterThanSlow(v1, v2)`;
+
+/**
+ * Determine if one value is less than another.
+ * @param {*} v1 First value
+ * @param {*} v2 Second value
+ * @returns {boolean} true if v1 is less than v2
+ */
+runtimeFunctions.compareLessThan = `const compareLessThanSlow = (v1, v2) => {
+    let n1 = +v1;
+    let n2 = +v2;
+    if (n1 === 0 && isNotActuallyZero(v1)) {
+        n1 = NaN;
+    } else if (n2 === 0 && isNotActuallyZero(v2)) {
+        n2 = NaN;
+    }
+    if (isNaN(n1) || isNaN(n2)) {
+        const s1 = ('' + v1).toLowerCase();
+        const s2 = ('' + v2).toLowerCase();
+        return s1 < s2;
+    }
+    return n1 < n2;
+};
+const compareLessThan = (v1, v2) => typeof v1 === 'number' && typeof v2 === 'number' && !isNaN(v2) ? v1 < v2 : compareLessThanSlow(v1, v2)`;
+
+/**
+ * Generate a random integer.
+ * @param {number} low Lower bound
+ * @param {number} high Upper bound
+ * @returns {number} A random integer between low and high, inclusive.
+ */
+runtimeFunctions.randomInt = `const randomInt = (low, high) => low + Math.floor(Math.random() * ((high + 1) - low))`;
+
+/**
+ * Generate a random float.
+ * @param {number} low Lower bound
+ * @param {number} high Upper bound
+ * @returns {number} A random floating point number between low and high.
+ */
+runtimeFunctions.randomFloat = `const randomFloat = (low, high) => (Math.random() * (high - low)) + low`;
+
+/**
+ * Create and start a timer.
+ * @returns {Timer} A started timer
+ */
+runtimeFunctions.timer = `const timer = () => {
+    const t = new globalState.Timer({
+        now: () => globalState.thread.target.runtime.currentMSecs
+    });
+    t.start();
+    return t;
+}`;
+
+/**
+ * Returns the amount of days since January 1st, 2000.
+ * @returns {number} Days since 2000.
+ */
+// Date.UTC(2000, 0, 1) === 946684800000
+// Hardcoding it is marginally faster
+runtimeFunctions.daysSince2000 = `const daysSince2000 = () => (Date.now() - 946684800000) / (24 * 60 * 60 * 1000)`;
+
+/**
+ * Determine distance to a sprite or point.
+ * @param {string} menu The name of the sprite or location to find.
+ * @returns {number} Distance to the point, or 10000 if it cannot be calculated.
+ */
+runtimeFunctions.distance = `const distance = menu => {
+    const thread = globalState.thread;
+    if (thread.target.isStage) return 10000;
+
+    let targetX = 0;
+    let targetY = 0;
+    if (menu === '_mouse_') {
+        targetX = thread.target.runtime.ioDevices.mouse.getScratchX();
+        targetY = thread.target.runtime.ioDevices.mouse.getScratchY();
+    } else {
+        const distTarget = thread.target.runtime.getSpriteTargetByName(menu);
+        if (!distTarget) return 10000;
+        targetX = distTarget.x;
+        targetY = distTarget.y;
+    }
+
+    const dx = thread.target.x - targetX;
+    const dy = thread.target.y - targetY;
+    return Math.sqrt((dx * dx) + (dy * dy));
+}`;
+
+/**
+ * Convert a Scratch list index to a JavaScript list index.
+ * "all" is not considered as a list index.
+ * Similar to Cast.toListIndex()
+ * @param {number} index Scratch list index.
+ * @param {number} length Length of the list.
+ * @returns {number} 0 based list index, or -1 if invalid.
+ */
+baseRuntime += `const listIndexSlow = (index, length) => {
+    if (index === 'last') {
+        return length - 1;
+    } else if (index === 'random' || index === 'any') {
+        if (length > 0) {
+            return (Math.random() * length) | 0;
+        }
+        return -1;
+    }
+    index = (+index || 0) | 0;
+    if (index < 1 || index > length) {
+        return -1;
+    }
+    return index - 1;
+};
+const listIndex = (index, length) => {
+    if (typeof index !== 'number') {
+      return listIndexSlow(index, length);
+    }
+    index = index | 0;
+    return index < 1 || index > length ? -1 : index - 1;
+};`;
+
+/**
+ * Get a value from a list.
+ * @param {Array} list The list
+ * @param {*} idx The 1-indexed index in the list.
+ * @returns {*} The list item, otherwise empty string if it does not exist.
+ */
+runtimeFunctions.listGet = `const listGet = (list, idx) => {
+    const index = listIndex(idx, list.length);
+    if (index === -1) {
+        return '';
+    }
+    return list[index];
+}`;
+
+/**
+ * Replace a value in a list.
+ * @param {import('../engine/variable')} list The list
+ * @param {*} idx List index, Scratch style.
+ * @param {*} value The new value.
+ */
+runtimeFunctions.listReplace = `const listReplace = (list, idx, value) => {
+    const index = listIndex(idx, list.value.length);
+    if (index === -1) {
+        return;
+    }
+    list.value[index] = value;
+    list._monitorUpToDate = false;
+}`;
+
+/**
+ * Insert a value in a list.
+ * @param {import('../engine/variable')} list The list.
+ * @param {*} idx The Scratch index in the list.
+ * @param {*} value The value to insert.
+ */
+runtimeFunctions.listInsert = `const listInsert = (list, idx, value) => {
+    const index = listIndex(idx, list.value.length + 1);
+    if (index === -1) {
+        return;
+    }
+    list.value.splice(index, 0, value);
+    list._monitorUpToDate = false;
+}`;
+
+/**
+ * Delete a value from a list.
+ * @param {import('../engine/variable')} list The list.
+ * @param {*} idx The Scratch index in the list.
+ */
+runtimeFunctions.listDelete = `const listDelete = (list, idx) => {
+    if (idx === 'all') {
+        list.value = [];
+        return;
+    }
+    const index = listIndex(idx, list.value.length);
+    if (index === -1) {
+        return;
+    }
+    list.value.splice(index, 1);
+    list._monitorUpToDate = false;
+}`;
+
+/**
+ * Return whether a list contains a value.
+ * @param {import('../engine/variable')} list The list.
+ * @param {*} item The value to search for.
+ * @returns {boolean} True if the list contains the item
+ */
+runtimeFunctions.listContains = `const listContains = (list, item) => {
+    // TODO: evaluate whether indexOf is worthwhile here
+    if (list.value.indexOf(item) !== -1) {
+        return true;
+    }
+    for (let i = 0; i < list.value.length; i++) {
+        if (compareEqual(list.value[i], item)) {
+            return true;
+        }
+    }
+    return false;
+}`;
+
+/**
+ * pm: Returns whether a list contains a value, using Array.some
+ * @param {import('../engine/variable')} list The list.
+ * @param {*} item The value to search for.
+ * @returns {boolean} True if the list contains the item
+ */
+runtimeFunctions.listContainsFastest = `const listContainsFastest = (list, item) => {
+    return list.value.some(litem => compareEqual(litem, item));
+}`;
+
+/**
+ * Find the 1-indexed index of an item in a list.
+ * @param {import('../engine/variable')} list The list.
+ * @param {*} item The item to search for
+ * @returns {number} The 1-indexed index of the item in the list, otherwise 0
+ */
+runtimeFunctions.listIndexOf = `const listIndexOf = (list, item) => {
+    for (let i = 0; i < list.value.length; i++) {
+        if (compareEqual(list.value[i], item)) {
+            return i + 1;
+        }
+    }
+    return 0;
+}`;
+
+/**
+ * Get the stringified form of a list.
+ * @param {import('../engine/variable')} list The list.
+ * @returns {string} Stringified form of the list.
+ */
+runtimeFunctions.listContents = `const listContents = list => {
+    for (let i = 0; i < list.value.length; i++) {
+        const listItem = list.value[i];
+        // this is an intentional break from what scratch 3 does to address our automatic string -> number conversions
+        // it fixes more than it breaks
+        if ((listItem + '').length !== 1) {
+            return list.value.join(' ');
+        }
+    }
+    return list.value.join('');
+}`;
+
+/**
+ * Convert a color to an RGB list
+ * @param {*} color The color value to convert
+ * @return {Array.<number>} [r,g,b], values between 0-255.
+ */
+runtimeFunctions.colorToList = `const colorToList = color => globalState.Cast.toRgbColorList(color)`;
+
+/**
+ * Implements Scratch modulo (floored division instead of truncated division)
+ * @param {number} n Number
+ * @param {number} modulus Base
+ * @returns {number} n % modulus (floored division)
+ */
+runtimeFunctions.mod = `const mod = (n, modulus) => {
+    let result = n % modulus;
+    if (result / modulus < 0) result += modulus;
+    return result;
+}`;
+
+/**
+ * Implements Scratch tangent.
+ * @param {number} angle Angle in degrees.
+ * @returns {number} value of tangent or Infinity or -Infinity
+ */
+runtimeFunctions.tan = `const tan = (angle) => {
+    switch (angle % 360) {
+    case -270: case 90: return Infinity;
+    case -90: case 270: return -Infinity;
+    }
+    return Math.round(Math.tan((Math.PI * angle) / 180) * 1e10) / 1e10;
+}`;
+
+runtimeFunctions.resolveImageURL = `const resolveImageURL = imgURL => 
+    typeof imgURL === 'object' && imgURL.type === 'canvas'
+        ? Promise.resolve(imgURL.canvas)
+        : new Promise(resolve => {
+            const image = new Image();
+            image.crossOrigin = "anonymous";
+            image.onload = resolve(image);
+            image.onerror = resolve; // ignore loading errors lol!
+            image.src = ''+imgURL;
+        })`;
+
+runtimeFunctions.parseJSONSafe = `const parseJSONSafe = json => {
+    try return JSON.parse(json)
+    catch return {}
+}`;
+
+runtimeFunctions._resolveKeyPath = `const _resolveKeyPath = (obj, keyPath) => {
+    const path = keyPath.matchAll(/(\\.|^)(?<key>[^.[]+)|\\[(?<litkey>(\\\\\\]|\\\\|[^]])+)\\]/g);
+    let top = obj;
+    let pre;
+    let tok;
+    let key;
+    while (!(tok = path.next()).done) {
+        key = tok.value.groups.key ?? tok.value.groups.litKey.replaceAll('\\\\\\\\', '\\\\').replaceAll('\\\\]', ']');
+        pre = top;
+        top = top?.get?.(key) ?? top?.[key];
+        if (top === undefined) return [obj, keyPath];
+    }
+    return [pre, key];
+}`;
+
+runtimeFunctions.get = `const get = (obj, keyPath) => {
+    const [root, key] = _resolveKeyPath(obj, keyPath);
+    return typeof root === 'undefined' 
+        ? '' 
+        : root.get?.(key) ?? root[key];
+}`;
+
+runtimeFunctions.set = `const set = (obj, keyPath, val) => {
+    const [root, key] = _resolveKeyPath(obj, keyPath);
+    return typeof root === 'undefined' 
+        ? '' 
+        : root.set?.(key) ?? (root[key] = val);
+}`;
+
+runtimeFunctions.remove = `const remove = (obj, keyPath) => {
+    const [root, key] = _resolveKeyPath(obj, keyPath);
+    return typeof root === 'undefined' 
+        ? '' 
+        : root.delete?.(key) ?? root.remove?.(key) ?? (delete root[key]);
+}`;
+
+runtimeFunctions.includes = `const includes = (obj, keyPath) => {
+    const [root, key] = _resolveKeyPath(obj, keyPath);
+    return typeof root === 'undefined' 
+        ? '' 
+        : root.has?.(key) ?? (key in root);
+}`;
+
+/**
+ * Step a compiled thread.
+ * @param {Thread} thread The thread to step.
+ */
+const execute = thread => {
+    globalState.thread = thread;
+    thread.generator.next();
+};
+
+const threadStack = [];
+const saveGlobalState = () => {
+    threadStack.push(globalState.thread);
+};
+const restoreGlobalState = () => {
+    globalState.thread = threadStack.pop();
+};
+
+const insertRuntime = source => {
+    let result = baseRuntime;
+    for (const functionName of Object.keys(runtimeFunctions)) {
+        if (source.includes(functionName)) {
+            result += `${runtimeFunctions[functionName]};`;
+        }
+    }
+    if (result.includes('executeInCompatibilityLayer') && !result.includes('const waitPromise')) {
+        result = result.replace('let hasResumedFromPromise = false;', `let hasResumedFromPromise = false;\n${runtimeFunctions.waitPromise}`);
+    }
+    if (result.includes('_resolveKeyPath') && !result.includes('const _resolveKeyPath')) {
+        result = runtimeFunctions._resolveKeyPath + ';' + result;
+    }
+    result += `return ${source}`;
+    return result;
+};
+
+/**
+ * Evaluate arbitrary JS in the context of the runtime.
+ * @param {string} source The string to evaluate.
+ * @returns {*} The result of evaluating the string.
+ */
+const scopedEval = source => {
+    const withRuntime = insertRuntime(source);
+    try {
+        return new Function('globalState', withRuntime)(globalState);
+    } catch (e) {
+        globalState.log.error('was unable to compile script', withRuntime);
+        console.log(e);
+        throw e;
+    }
+};
+
+execute.scopedEval = scopedEval;
+execute.runtimeFunctions = runtimeFunctions;
+execute.saveGlobalState = saveGlobalState;
+execute.restoreGlobalState = restoreGlobalState;
+// not actually used, this is an export for extensions
+execute.globalState = globalState;
+
+module.exports = execute;

src/compiler/jsgen.js

@@ -0,0 +1,2114 @@
+const log = require('../util/log');
+const Cast = require('../util/cast');
+const BlockType = require('../extension-support/block-type');
+const VariablePool = require('./variable-pool');
+const jsexecute = require('./jsexecute');
+const environment = require('./environment');
+
+// Imported for JSDoc types, not to actually use
+// eslint-disable-next-line no-unused-vars
+const {IntermediateScript, IntermediateRepresentation} = require('./intermediate');
+
+/**
+ * @fileoverview Convert intermediate representations to JavaScript functions.
+ */
+
+/* eslint-disable max-len */
+/* eslint-disable prefer-template */
+
+const sanitize = string => {
+    if (typeof string !== 'string') {
+        log.warn(`sanitize got unexpected type: ${typeof string}`);
+        string = '' + string;
+    }
+    return JSON.stringify(string).slice(1, -1);
+};
+
+const TYPE_NUMBER = 1;
+const TYPE_STRING = 2;
+const TYPE_BOOLEAN = 3;
+const TYPE_UNKNOWN = 4;
+const TYPE_NUMBER_NAN = 5;
+
+
+// Pen-related constants
+const PEN_EXT = 'runtime.ext_pen';
+const PEN_STATE = `${PEN_EXT}._getPenState(target)`;
+
+/**
+ * Variable pool used for factory function names.
+ */
+const factoryNameVariablePool = new VariablePool('factory');
+
+/**
+ * Variable pool used for generated functions (non-generator)
+ */
+const functionNameVariablePool = new VariablePool('fun');
+
+/**
+ * Variable pool used for generated generator functions.
+ */
+const generatorNameVariablePool = new VariablePool('gen');
+
+/**
+ * @typedef Input
+ * @property {() => string} asNumber
+ * @property {() => string} asNumberOrNaN
+ * @property {() => string} asString
+ * @property {() => string} asBoolean
+ * @property {() => string} asColor
+ * @property {() => string} asUnknown
+ * @property {() => string} asSafe
+ * @property {() => boolean} isAlwaysNumber
+ * @property {() => boolean} isAlwaysNumberOrNaN
+ * @property {() => boolean} isNeverNumber
+ */
+
+/**
+ * @implements {Input}
+ */
+class TypedInput {
+    constructor (source, type) {
+        this.source = source;
+        this.type = type;
+    }
+
+    asNumber () {
+        if (this.type === TYPE_NUMBER) return this.source;
+        if (this.type === TYPE_NUMBER_NAN) return `(${this.source} || 0)`;
+        return `(+${this.source} || 0)`;
+    }
+
+    asNumberOrNaN () {
+        if (this.type === TYPE_NUMBER || this.type === TYPE_NUMBER_NAN) return this.source;
+        return `(+${this.source})`;
+    }
+
+    asString () {
+        if (this.type === TYPE_STRING) return this.source;
+        return `("" + ${this.source})`;
+    }
+
+    asBoolean () {
+        if (this.type === TYPE_UNKNOWN) return `toBoolean(${this.source})`;
+        if (this.type === TYPE_STRING) return `${this.source} === 'false' || ${this.source} === '0' ? false : true`;
+        if (this.type === TYPE_NUMBER) return `${this.source} !== 0`;
+        if (this.type === TYPE_NUMBER_NAN) return `(${this.source} || 0) !== 0`;
+        
+        return this.source;
+    }
+
+    asColor () {
+        return this.asUnknown();
+    }
+
+    asUnknown () {
+        return this.source;
+    }
+
+    asSafe () {
+        return this.asUnknown();
+    }
+
+    isAlwaysNumber () {
+        return this.type === TYPE_NUMBER;
+    }
+
+    isAlwaysNumberOrNaN () {
+        return this.type === TYPE_NUMBER || this.type === TYPE_NUMBER_NAN;
+    }
+
+    isNeverNumber () {
+        return false;
+    }
+}
+
+/**
+ * @implements {Input}
+ */
+class ConstantInput {
+    constructor (constantValue, safe) {
+        this.constantValue = constantValue;
+        this.safe = safe;
+    }
+
+    asNumber () {
+        // Compute at compilation time
+        const numberValue = +this.constantValue;
+        if (numberValue) {
+            // It's important that we use the number's stringified value and not the constant value
+            // Using the constant value allows numbers such as "010" to be interpreted as 8 (or SyntaxError in strict mode) instead of 10.
+            return numberValue.toString();
+        }
+        // numberValue is one of 0, -0, or NaN
+        if (Object.is(numberValue, -0)) {
+            return '-0';
+        }
+        return '0';
+    }
+
+    asNumberOrNaN () {
+        return this.asNumber();
+    }
+
+    asString () {
+        return `"${sanitize('' + this.constantValue)}"`;
+    }
+
+    asBoolean () {
+        // Compute at compilation time
+        return Cast.toBoolean(this.constantValue).toString();
+    }
+
+    asColor () {
+        // Attempt to parse hex code at compilation time
+        if (/^#[0-9a-f]{6,8}$/i.test(this.constantValue)) {
+            const hex = this.constantValue.slice(1);
+            return Number.parseInt(hex, 16).toString();
+        }
+        return this.asUnknown();
+    }
+
+    asUnknown () {
+        // Attempt to convert strings to numbers if it is unlikely to break things
+        if (typeof this.constantValue === 'number') {
+            // todo: handle NaN?
+            return this.constantValue;
+        }
+        const numberValue = +this.constantValue;
+        if (numberValue.toString() === this.constantValue) {
+            return this.constantValue;
+        }
+        return this.asString();
+    }
+
+    asSafe () {
+        if (this.safe) {
+            return this.asUnknown();
+        }
+        return this.asString();
+    }
+
+    isAlwaysNumber () {
+        const value = +this.constantValue;
+        if (Number.isNaN(value)) {
+            return false;
+        }
+        // Empty strings evaluate to 0 but should not be considered a number.
+        if (value === 0) {
+            return this.constantValue.toString().trim() !== '';
+        }
+        return true;
+    }
+
+    isAlwaysNumberOrNaN () {
+        return this.isAlwaysNumber();
+    }
+
+    isNeverNumber () {
+        return Number.isNaN(+this.constantValue);
+    }
+}
+
+/**
+ * @implements {Input}
+ */
+class VariableInput {
+    constructor (source) {
+        this.source = source;
+        this.type = TYPE_UNKNOWN;
+        /**
+         * The value this variable was most recently set to, if any.
+         * @type {Input}
+         * @private
+         */
+        this._value = null;
+    }
+
+    /**
+     * @param {Input} input The input this variable was most recently set to.
+     */
+    setInput (input) {
+        if (input instanceof VariableInput) {
+            // When being set to another variable, extract the value it was set to.
+            // Otherwise, you may end up with infinite recursion in analysis methods when a variable is set to itself.
+            if (input._value) {
+                input = input._value;
+            } else {
+                this.type = TYPE_UNKNOWN;
+                this._value = null;
+                return;
+            }
+        }
+        this._value = input;
+        if (input instanceof TypedInput) {
+            this.type = input.type;
+        } else {
+            this.type = TYPE_UNKNOWN;
+        }
+    }
+
+    asNumber () {
+        if (this.type === TYPE_NUMBER) return this.source;
+        if (this.type === TYPE_NUMBER_NAN) return `(${this.source} || 0)`;
+        return `(+${this.source} || 0)`;
+    }
+
+    asNumberOrNaN () {
+        if (this.type === TYPE_NUMBER || this.type === TYPE_NUMBER_NAN) return this.source;
+        return `(+${this.source})`;
+    }
+
+    asString () {
+        if (this.type === TYPE_STRING) return this.source;
+        return `("" + ${this.source})`;
+    }
+
+    asBoolean () {
+        if (this.type === TYPE_BOOLEAN) return this.source;
+        return `toBoolean(${this.source})`;
+    }
+
+    asColor () {
+        return this.asUnknown();
+    }
+
+    asUnknown () {
+        return this.source;
+    }
+
+    asSafe () {
+        return this.asUnknown();
+    }
+
+    isAlwaysNumber () {
+        if (this._value) {
+            return this._value.isAlwaysNumber();
+        }
+        return false;
+    }
+
+    isAlwaysNumberOrNaN () {
+        if (this._value) {
+            return this._value.isAlwaysNumberOrNaN();
+        }
+        return false;
+    }
+
+    isNeverNumber () {
+        if (this._value) {
+            return this._value.isNeverNumber();
+        }
+        return false;
+    }
+}
+
+const getNamesOfCostumesAndSounds = runtime => {
+    const result = new Set();
+    for (const target of runtime.targets) {
+        if (target.isOriginal) {
+            const sprite = target.sprite;
+            for (const costume of sprite.costumes) {
+                result.add(costume.name);
+            }
+            for (const sound of sprite.sounds) {
+                result.add(sound.name);
+            }
+        }
+    }
+    return result;
+};
+
+const isSafeConstantForEqualsOptimization = input => {
+    const numberValue = +input.constantValue;
+    // Do not optimize 0
+    if (!numberValue) {
+        return false;
+    }
+    // Do not optimize numbers when the original form does not match
+    return numberValue.toString() === input.constantValue.toString();
+};
+
+/**
+ * A frame contains some information about the current substack being compiled.
+ */
+class Frame {
+    constructor (isLoop, parentKind) {
+        /**
+         * Whether the current stack runs in a loop (while, for)
+         * @type {boolean}
+         * @readonly
+         */
+        this.isLoop = isLoop;
+
+        /**
+         * Whether the current block is the last block in the stack.
+         * @type {boolean}
+         */
+        this.isLastBlock = false;
+
+        /**
+         * General important data that needs to be carried down from other threads.
+         * @type {boolean}
+         */
+        this.importantData = {
+            parents: [parentKind]
+        };
+        if (isLoop)
+            this.importantData.containedByLoop = isLoop;
+
+        /**
+         * the block who created this frame
+         * @type {string}
+         * @readonly
+         */
+        this.parent = parentKind;
+    }
+
+    assignData(obj) {
+        if (obj instanceof Frame) {
+            obj = obj.importantData;
+            obj.parents = obj.parents.concat(this.importantData.parents);
+        }
+        Object.assign(this.importantData, obj);
+    }
+}
+
+class JSGenerator {
+    /**
+     * @param {IntermediateScript} script
+     * @param {IntermediateRepresentation} ir
+     * @param {Target} target
+     */
+    constructor (script, ir, target) {
+        this.script = script;
+        this.ir = ir;
+        this.target = target;
+        this.source = '';
+
+        /**
+         * @type {Object.<string, VariableInput>}
+         */
+        this.variableInputs = {};
+
+        this.isWarp = script.isWarp;
+        this.isOptimized = script.isOptimized;
+        this.optimizationUtil = script.optimizationUtil;
+        this.isProcedure = script.isProcedure;
+        this.warpTimer = script.warpTimer;
+
+        /**
+         * Stack of frames, most recent is last item.
+         * @type {Frame[]}
+         */
+        this.frames = [];
+
+        /**
+         * The current Frame.
+         * @type {Frame}
+         */
+        this.currentFrame = null;
+
+        this.namesOfCostumesAndSounds = getNamesOfCostumesAndSounds(target.runtime);
+
+        this.localVariables = new VariablePool('a');
+        this._setupVariablesPool = new VariablePool('b');
+        this._setupVariables = {};
+
+        this.descendedIntoModulo = false;
+        this.isInHat = false;
+
+        this.debug = this.target.runtime.debug;
+    }
+
+    static exports = {
+        TypedInput,
+        ConstantInput,
+        VariableInput,
+        Frame,
+        VariablePool,
+        TYPE_NUMBER,
+        TYPE_STRING,
+        TYPE_BOOLEAN,
+        TYPE_UNKNOWN,
+        TYPE_NUMBER_NAN,
+        PEN_EXT,
+        PEN_STATE,
+        factoryNameVariablePool,
+        functionNameVariablePool,
+        generatorNameVariablePool
+    }
+
+    static _extensionJSInfo = {};
+    static setExtensionJs(id, data) {
+        JSGenerator._extensionJSInfo[id] = data;
+    }
+    static hasExtensionJs(id) {
+        return Boolean(JSGenerator._extensionJSInfo[id]);
+    }
+    static getExtensionJs(id) {
+        return JSGenerator._extensionJSInfo[id];
+    }
+
+    static getExtensionImports() {
+        // used so extensions have things like the Frame class
+        return {
+            Frame: Frame,
+            TypedInput: TypedInput,
+            VariableInput: VariableInput,
+            ConstantInput: ConstantInput,
+            VariablePool: VariablePool,
+
+            TYPE_NUMBER: TYPE_NUMBER,
+            TYPE_STRING: TYPE_STRING,
+            TYPE_BOOLEAN: TYPE_BOOLEAN,
+            TYPE_UNKNOWN: TYPE_UNKNOWN,
+            TYPE_NUMBER_NAN: TYPE_NUMBER_NAN
+        };
+    }
+
+    /**
+     * Enter a new frame
+     * @param {Frame} frame New frame.
+     */
+    pushFrame (frame) {
+        this.frames.push(frame);
+        this.currentFrame = frame;
+    }
+
+    /**
+     * Exit the current frame
+     */
+    popFrame () {
+        this.frames.pop();
+        this.currentFrame = this.frames[this.frames.length - 1];
+    }
+
+    /**
+     * @returns {boolean} true if the current block is the last command of a loop
+     */
+    isLastBlockInLoop () {
+        for (let i = this.frames.length - 1; i >= 0; i--) {
+            const frame = this.frames[i];
+            if (!frame.isLastBlock) {
+                return false;
+            }
+            if (frame.isLoop) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @param {object} node Input node to compile.
+     * @param {boolean} visualReport if this is being called to get visual reporter content
+     * @returns {Input} Compiled input.
+     */
+    descendInput (node, visualReport = false) {
+        // check if we have extension js for this kind
+        const extensionId = String(node.kind).split('.')[0];
+        const blockId = String(node.kind).replace(extensionId + '.', '');
+        if (JSGenerator.hasExtensionJs(extensionId) && JSGenerator.getExtensionJs(extensionId)[blockId]) {
+            // this is an extension block that wants to be compiled
+            const imports = JSGenerator.getExtensionImports();
+            const jsFunc = JSGenerator.getExtensionJs(extensionId)[blockId];
+            // return the input
+            let input = null;
+            try {
+                input = jsFunc(node, this, imports);
+            } catch (err) {
+                log.warn(extensionId + '_' + blockId, 'failed to compile JavaScript;', err);
+            }
+            // log.log(input);
+            return input;
+        }
+
+        switch (node.kind) {
+        case 'args.boolean':
+            return new TypedInput(`toBoolean(p${node.index})`, TYPE_BOOLEAN);
+        case 'args.stringNumber':
+            return new TypedInput(`p${node.index}`, TYPE_UNKNOWN);
+
+        case 'compat':
+            // Compatibility layer inputs never use flags.
+            // log.log('compat')
+            return new TypedInput(`(${this.generateCompatibilityLayerCall(node, false, null, visualReport)})`, TYPE_UNKNOWN);
+
+        case 'constant':
+            return this.safeConstantInput(node.value);
+        case 'counter.get':
+            return new TypedInput('runtime.ext_scratch3_control._counter', TYPE_NUMBER);
+        case 'control.error':
+            return new TypedInput('runtime.ext_scratch3_control._error', TYPE_STRING);
+        case 'control.isclone':
+            return new TypedInput('(!target.isOriginal)', TYPE_BOOLEAN);
+        case 'math.polygon':
+            let points = JSON.stringify(node.points.map((point, num) => ({x: `x${num}`, y: `y${num}`})));
+            for (let num = 0; num < node.points.length; num++) {
+                const point = node.points[num];
+                const xn = `"x${num}"`;
+                const yn = `"y${num}"`;
+                points = points
+                    .replace(xn, this.descendInput(point.x).asNumber())
+                    .replace(yn, this.descendInput(point.y).asNumber());
+            }
+            return new TypedInput(points, TYPE_UNKNOWN);
+            
+        case 'control.inlineStackOutput': {
+            // reset this.source but save it
+            const originalSource = this.source;
+            this.source = '(yield* (function*() {';
+            // descend now since descendStack modifies source
+            this.descendStack(node.code, new Frame(false, 'control.inlineStackOutput'));
+            this.source += '})())';
+            // save edited
+            const stackSource = this.source;
+            this.source = originalSource;
+            return new TypedInput(stackSource, TYPE_UNKNOWN);
+        }
+
+        case 'keyboard.pressed':
+            return new TypedInput(`runtime.ioDevices.keyboard.getKeyIsDown(${this.descendInput(node.key).asSafe()})`, TYPE_BOOLEAN);
+
+        case 'list.contains':
+            if (this.isOptimized) {
+                // pm: we can use a better function here
+                return new TypedInput(`listContainsFastest(${this.referenceVariable(node.list)}, ${this.descendInput(node.item).asUnknown()})`, TYPE_BOOLEAN);
+            }
+            return new TypedInput(`listContains(${this.referenceVariable(node.list)}, ${this.descendInput(node.item).asUnknown()})`, TYPE_BOOLEAN);
+        case 'list.contents':
+            if (this.isOptimized) {
+                // pm: its more consistent to just return the list with spaces inbetween
+                return new TypedInput(`(${this.referenceVariable(node.list)}.value.join(' '))`, TYPE_STRING);
+            }
+            return new TypedInput(`listContents(${this.referenceVariable(node.list)})`, TYPE_STRING);
+        case 'list.get': {
+            const index = this.descendInput(node.index);
+            if (environment.supportsNullishCoalescing) {
+                if (index.isAlwaysNumberOrNaN()) {
+                    return new TypedInput(`(${this.referenceVariable(node.list)}.value[(${index.asNumber()} | 0) - 1] ?? "")`, TYPE_UNKNOWN);
+                }
+                if (index instanceof ConstantInput && index.constantValue === 'last') {
+                    return new TypedInput(`(${this.referenceVariable(node.list)}.value[${this.referenceVariable(node.list)}.value.length - 1] ?? "")`, TYPE_UNKNOWN);
+                }
+            }
+            if (this.isOptimized) {
+                // pm: we can just use this as an index ignoring the string input, the nullish coalescing operator will just make sure we dont return undefined
+                return new TypedInput(`(${this.referenceVariable(node.list)}.value[${index.asUnknown()} - 1] ?? "")`, TYPE_UNKNOWN);
+            }
+            return new TypedInput(`listGet(${this.referenceVariable(node.list)}.value, ${index.asUnknown()})`, TYPE_UNKNOWN);
+        }
+        case 'list.indexOf':
+            return new TypedInput(`listIndexOf(${this.referenceVariable(node.list)}, ${this.descendInput(node.item).asUnknown()})`, TYPE_NUMBER);
+        case 'list.amountOf':
+            return new TypedInput(`${this.referenceVariable(node.list)}.value.filter((x) => x == ${this.descendInput(node.value).asUnknown()}).length`, TYPE_NUMBER);
+        case 'list.length':
+            return new TypedInput(`${this.referenceVariable(node.list)}.value.length`, TYPE_NUMBER);
+
+        case 'list.filteritem':
+            return new TypedInput('runtime.ext_scratch3_data._listFilterItem', TYPE_UNKNOWN);
+        case 'list.filterindex':
+            return new TypedInput('runtime.ext_scratch3_data._listFilterIndex', TYPE_UNKNOWN);
+
+        case 'looks.size':
+            return new TypedInput('target.size', TYPE_NUMBER);
+        case 'looks.tintColor':
+            return new TypedInput('runtime.ext_scratch3_looks.getTintColor(null, { target: target })', TYPE_NUMBER);
+        case 'looks.backdropName':
+            return new TypedInput('stage.getCostumes()[stage.currentCostume].name', TYPE_STRING);
+        case 'looks.backdropNumber':
+            return new TypedInput('(stage.currentCostume + 1)', TYPE_NUMBER);
+        case 'looks.costumeName':
+            return new TypedInput('target.getCostumes()[target.currentCostume].name', TYPE_STRING);
+        case 'looks.costumeNumber':
+            return new TypedInput('(target.currentCostume + 1)', TYPE_NUMBER);
+
+        case 'motion.direction':
+            return new TypedInput('target.direction', TYPE_NUMBER);
+
+        case 'motion.x':
+            if (this.isOptimized) {
+                return new TypedInput('(target.x)', TYPE_NUMBER);
+            }
+            return new TypedInput('limitPrecision(target.x)', TYPE_NUMBER);
+        case 'motion.y':
+            if (this.isOptimized) {
+                return new TypedInput('(target.y)', TYPE_NUMBER);
+            }
+            return new TypedInput('limitPrecision(target.y)', TYPE_NUMBER);
+
+        case 'mouse.down':
+            return new TypedInput('runtime.ioDevices.mouse.getIsDown()', TYPE_BOOLEAN);
+        case 'mouse.x':
+            return new TypedInput('runtime.ioDevices.mouse.getScratchX()', TYPE_NUMBER);
+        case 'mouse.y':
+            return new TypedInput('runtime.ioDevices.mouse.getScratchY()', TYPE_NUMBER);
+            
+        case 'op.true':
+            return new TypedInput('(true)', TYPE_BOOLEAN);
+        case 'op.false':
+            return new TypedInput('(false)', TYPE_BOOLEAN);
+        case 'op.randbool':
+            return new TypedInput('(Boolean(Math.round(Math.random())))', TYPE_BOOLEAN);
+            
+        case 'pmEventsExpansion.broadcastFunction':
+            // we need to do function otherwise this block would be stupidly long
+            let source = '(yield* (function*() {';
+            source += `var broadcastVar = runtime.getTargetForStage().lookupBroadcastMsg("", ${this.descendInput(node.broadcast).asString()} );`;
+            source += `if (broadcastVar) broadcastVar.isSent = true;`;
+            const threads = this.localVariables.next();
+            source += `var ${threads} = startHats("event_whenbroadcastreceived", { BROADCAST_OPTION: ${this.descendInput(node.broadcast).asString()} });`;
+            const threadVar = this.localVariables.next();
+            source += `for (const ${threadVar} of ${threads}) { ${threadVar}.__evex_recievedDataa = '' };`;
+            source += `yield* waitThreads(${threads});`;
+            // wait an extra frame so the thread has the new value
+            if (this.isWarp) {
+                source += 'if (isStuck()) yield;\n';
+            } else {
+                source += 'yield;\n';
+            }
+            // Control may have been yielded to another script -- all bets are off.
+            this.resetVariableInputs();
+            // get value
+            const value = this.localVariables.next();
+            const thread = this.localVariables.next();
+            source += `var ${value} = undefined;`;
+            source += `for (var ${thread} of ${threads}) {`;
+            // if not undefined, return value
+            source += `if (typeof ${thread}.__evex_returnDataa !== 'undefined') {`;
+            source += `return ${thread}.__evex_returnDataa;`;
+            source += `}`;
+            source += `}`;
+            // no value, return empty value
+            source += `return '';`;
+            source += '})())';
+            return new TypedInput(source, TYPE_STRING);
+        case 'pmEventsExpansion.broadcastFunctionArgs': {
+            // we need to do function otherwise this block would be stupidly long
+            let source = '(yield* (function*() {';
+            const threads = this.localVariables.next();
+            source += `var broadcastVar = runtime.getTargetForStage().lookupBroadcastMsg("", ${this.descendInput(node.broadcast).asString()} );`;
+            source += `if (broadcastVar) broadcastVar.isSent = true;`;
+            source += `var ${threads} = startHats("event_whenbroadcastreceived", { BROADCAST_OPTION: ${this.descendInput(node.broadcast).asString()} });`;
+            const threadVar = this.localVariables.next();
+            source += `for (const ${threadVar} of ${threads}) { ${threadVar}.__evex_recievedDataa = ${this.descendInput(node.args).asString()} };`;
+            source += `yield* waitThreads(${threads});`;
+            // wait an extra frame so the thread has the new value
+            if (this.isWarp) {
+                source += 'if (isStuck()) yield;\n';
+            } else {
+                source += 'yield;\n';
+            }
+            // Control may have been yielded to another script -- all bets are off.
+            this.resetVariableInputs();
+            // get value
+            const value = this.localVariables.next();
+            const thread = this.localVariables.next();
+            source += `var ${value} = undefined;`;
+            source += `for (var ${thread} of ${threads}) {`;
+            // if not undefined, return value
+            source += `if (typeof ${thread}.__evex_returnDataa !== 'undefined') {`;
+            source += `return ${thread}.__evex_returnDataa;`;
+            source += `}`;
+            source += `}`;
+            // no value, return empty value
+            source += `return '';`;
+            source += '})())';
+            return new TypedInput(source, TYPE_STRING);
+        }
+        case 'op.abs':
+            return new TypedInput(`Math.abs(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER);
+        case 'op.acos':
+            // Needs to be marked as NaN because Math.acos(1.0001) === NaN
+            return new TypedInput(`((Math.acos(${this.descendInput(node.value).asNumber()}) * 180) / Math.PI)`, TYPE_NUMBER_NAN);
+        case 'op.add':
+            // Needs to be marked as NaN because Infinity + -Infinity === NaN
+            return new TypedInput(`(${this.descendInput(node.left).asNumber()} + ${this.descendInput(node.right).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.and':
+            return new TypedInput(`(${this.descendInput(node.left).asBoolean()} && ${this.descendInput(node.right).asBoolean()})`, TYPE_BOOLEAN);
+        case 'op.asin':
+            // Needs to be marked as NaN because Math.asin(1.0001) === NaN
+            return new TypedInput(`((Math.asin(${this.descendInput(node.value).asNumber()}) * 180) / Math.PI)`, TYPE_NUMBER_NAN);
+        case 'op.atan':
+            return new TypedInput(`((Math.atan(${this.descendInput(node.value).asNumber()}) * 180) / Math.PI)`, TYPE_NUMBER);
+        case 'op.ceiling':
+            return new TypedInput(`Math.ceil(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER);
+        case 'op.contains':
+            return new TypedInput(`(${this.descendInput(node.string).asString()}.toLowerCase().indexOf(${this.descendInput(node.contains).asString()}.toLowerCase()) !== -1)`, TYPE_BOOLEAN);
+        case 'op.cos':
+            // pm: optimizations allow us to use a premade list for sin values on integers
+            if (this.isOptimized) {
+                const value = `${this.descendInput(node.value).asNumber()}`;
+                return new TypedInput(`(Number.isInteger(${value}) ? runtime.optimizationUtil.cos[((${value} % 360) + 360) % 360] : (Math.round(Math.cos((Math.PI * ${value}) / 180) * 1e10) / 1e10))`, TYPE_NUMBER_NAN);
+            }
+            return new TypedInput(`(Math.round(Math.cos((Math.PI * ${this.descendInput(node.value).asNumber()}) / 180) * 1e10) / 1e10)`, TYPE_NUMBER_NAN);
+        case 'op.divide':
+            // Needs to be marked as NaN because 0 / 0 === NaN
+            return new TypedInput(`(${this.descendInput(node.left).asNumber()} / ${this.descendInput(node.right).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.power':
+            // Needs to be marked as NaN because -1 ** 0.5 === NaN
+            return new TypedInput(`(Math.pow(${this.descendInput(node.left).asNumber()}, ${this.descendInput(node.right).asNumber()}))`, TYPE_NUMBER_NAN);
+        case 'op.equals': {
+            const left = this.descendInput(node.left);
+            const right = this.descendInput(node.right);
+            // When both operands are known to never be numbers, only use string comparison to avoid all number parsing.
+            if (left.isNeverNumber() || right.isNeverNumber()) {
+                return new TypedInput(`(${left.asString()}.toLowerCase() === ${right.asString()}.toLowerCase())`, TYPE_BOOLEAN);
+            }
+            const leftAlwaysNumber = left.isAlwaysNumber();
+            const rightAlwaysNumber = right.isAlwaysNumber();
+            // When both operands are known to be numbers, we can use ===
+            if (leftAlwaysNumber && rightAlwaysNumber) {
+                return new TypedInput(`(${left.asNumber()} === ${right.asNumber()})`, TYPE_BOOLEAN);
+            }
+            // In certain conditions, we can use === when one of the operands is known to be a safe number.
+            if (leftAlwaysNumber && left instanceof ConstantInput && isSafeConstantForEqualsOptimization(left)) {
+                return new TypedInput(`(${left.asNumber()} === ${right.asNumber()})`, TYPE_BOOLEAN);
+            }
+            if (rightAlwaysNumber && right instanceof ConstantInput && isSafeConstantForEqualsOptimization(right)) {
+                return new TypedInput(`(${left.asNumber()} === ${right.asNumber()})`, TYPE_BOOLEAN);
+            }
+            // No compile-time optimizations possible - use fallback method.
+            return new TypedInput(`compareEqual(${left.asUnknown()}, ${right.asUnknown()})`, TYPE_BOOLEAN);
+        }
+        case 'op.e^':
+            return new TypedInput(`Math.exp(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER);
+        case 'op.floor':
+            return new TypedInput(`Math.floor(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER);
+        case 'op.greater': {
+            const left = this.descendInput(node.left);
+            const right = this.descendInput(node.right);
+            // When the left operand is a number and the right operand is a number or NaN, we can use >
+            if (left.isAlwaysNumber() && right.isAlwaysNumberOrNaN()) {
+                return new TypedInput(`(${left.asNumber()} > ${right.asNumberOrNaN()})`, TYPE_BOOLEAN);
+            }
+            // When the left operand is a number or NaN and the right operand is a number, we can negate <=
+            if (left.isAlwaysNumberOrNaN() && right.isAlwaysNumber()) {
+                return new TypedInput(`!(${left.asNumberOrNaN()} <= ${right.asNumber()})`, TYPE_BOOLEAN);
+            }
+            // When either operand is known to never be a number, avoid all number parsing.
+            if (left.isNeverNumber() || right.isNeverNumber()) {
+                return new TypedInput(`(${left.asString()}.toLowerCase() > ${right.asString()}.toLowerCase())`, TYPE_BOOLEAN);
+            }
+            // No compile-time optimizations possible - use fallback method.
+            return new TypedInput(`compareGreaterThan(${left.asUnknown()}, ${right.asUnknown()})`, TYPE_BOOLEAN);
+        }
+        case 'op.join':
+            return new TypedInput(`(${this.descendInput(node.left).asString()} + ${this.descendInput(node.right).asString()})`, TYPE_STRING);
+        case 'op.length':
+            return new TypedInput(`${this.descendInput(node.string).asString()}.length`, TYPE_NUMBER);
+        case 'op.less': {
+            const left = this.descendInput(node.left);
+            const right = this.descendInput(node.right);
+            // When the left operand is a number or NaN and the right operand is a number, we can use <
+            if (left.isAlwaysNumberOrNaN() && right.isAlwaysNumber()) {
+                return new TypedInput(`(${left.asNumberOrNaN()} < ${right.asNumber()})`, TYPE_BOOLEAN);
+            }
+            // When the left operand is a number and the right operand is a number or NaN, we can negate >=
+            if (left.isAlwaysNumber() && right.isAlwaysNumberOrNaN()) {
+                return new TypedInput(`!(${left.asNumber()} >= ${right.asNumberOrNaN()})`, TYPE_BOOLEAN);
+            }
+            // When either operand is known to never be a number, avoid all number parsing.
+            if (left.isNeverNumber() || right.isNeverNumber()) {
+                return new TypedInput(`(${left.asString()}.toLowerCase() < ${right.asString()}.toLowerCase())`, TYPE_BOOLEAN);
+            }
+            // No compile-time optimizations possible - use fallback method.
+            return new TypedInput(`compareLessThan(${left.asUnknown()}, ${right.asUnknown()})`, TYPE_BOOLEAN);
+        }
+        case 'op.letterOf':
+            return new TypedInput(`((${this.descendInput(node.string).asString()})[(${this.descendInput(node.letter).asNumber()} | 0) - 1] || "")`, TYPE_STRING);
+        case 'op.ln':
+            // Needs to be marked as NaN because Math.log(-1) == NaN
+            return new TypedInput(`Math.log(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.log':
+            // Needs to be marked as NaN because Math.log(-1) == NaN
+            return new TypedInput(`(Math.log(${this.descendInput(node.value).asNumber()}) / Math.LN10)`, TYPE_NUMBER_NAN);
+        case 'op.log2':
+            // Needs to be marked as NaN because Math.log2(-1) == NaN
+            return new TypedInput(`Math.log2(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.advlog':
+            // Needs to be marked as NaN because Math.log(-1) == NaN
+            return new TypedInput(`(Math.log(${this.descendInput(node.right).asNumber()}) / (Math.log(${this.descendInput(node.left).asNumber()}))`, TYPE_NUMBER_NAN);
+        case 'op.mod':
+            this.descendedIntoModulo = true;
+            // Needs to be marked as NaN because mod(0, 0) (and others) == NaN
+            return new TypedInput(`mod(${this.descendInput(node.left).asNumber()}, ${this.descendInput(node.right).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.multiply':
+            // Needs to be marked as NaN because Infinity * 0 === NaN
+            return new TypedInput(`(${this.descendInput(node.left).asNumber()} * ${this.descendInput(node.right).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.not':
+            return new TypedInput(`!${this.descendInput(node.operand).asBoolean()}`, TYPE_BOOLEAN);
+        case 'op.or':
+            return new TypedInput(`(${this.descendInput(node.left).asBoolean()} || ${this.descendInput(node.right).asBoolean()})`, TYPE_BOOLEAN);
+        case 'op.random':
+            if (node.useInts) {
+                // Both inputs are ints, so we know neither are NaN
+                return new TypedInput(`randomInt(${this.descendInput(node.low).asNumber()}, ${this.descendInput(node.high).asNumber()})`, TYPE_NUMBER);
+            }
+            if (node.useFloats) {
+                return new TypedInput(`randomFloat(${this.descendInput(node.low).asNumber()}, ${this.descendInput(node.high).asNumber()})`, TYPE_NUMBER_NAN);
+            }
+            return new TypedInput(`runtime.ext_scratch3_operators._random(${this.descendInput(node.low).asUnknown()}, ${this.descendInput(node.high).asUnknown()})`, TYPE_NUMBER_NAN);
+        case 'op.round':
+            return new TypedInput(`Math.round(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER);
+        case 'op.sign':
+            return new TypedInput(`Math.sign(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER);
+        case 'op.sin':
+            // pm: optimizations allow us to use a premade list for sin values on integers
+            if (this.isOptimized) {
+                const value = `${this.descendInput(node.value).asNumber()}`;
+                return new TypedInput(`(Number.isInteger(${value}) ? runtime.optimizationUtil.sin[((${value} % 360) + 360) % 360] : (Math.round(Math.sin((Math.PI * ${value}) / 180) * 1e10) / 1e10))`, TYPE_NUMBER_NAN);
+            }
+            return new TypedInput(`(Math.round(Math.sin((Math.PI * ${this.descendInput(node.value).asNumber()}) / 180) * 1e10) / 1e10)`, TYPE_NUMBER_NAN);
+        case 'op.sqrt':
+            // Needs to be marked as NaN because Math.sqrt(-1) === NaN
+            return new TypedInput(`Math.sqrt(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.subtract':
+            // Needs to be marked as NaN because Infinity - Infinity === NaN
+            return new TypedInput(`(${this.descendInput(node.left).asNumber()} - ${this.descendInput(node.right).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.tan':
+            return new TypedInput(`tan(${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER_NAN);
+        case 'op.10^':
+            return new TypedInput(`(10 ** ${this.descendInput(node.value).asNumber()})`, TYPE_NUMBER);
+
+        case 'sensing.answer':
+            return new TypedInput(`runtime.ext_scratch3_sensing._answer`, TYPE_STRING);
+        case 'sensing.colorTouchingColor':
+            return new TypedInput(`target.colorIsTouchingColor(colorToList(${this.descendInput(node.target).asColor()}), colorToList(${this.descendInput(node.mask).asColor()}))`, TYPE_BOOLEAN);
+        case 'sensing.date':
+            return new TypedInput(`(new Date().getDate())`, TYPE_NUMBER);
+        case 'sensing.dayofweek':
+            return new TypedInput(`(new Date().getDay() + 1)`, TYPE_NUMBER);
+        case 'sensing.daysSince2000':
+            return new TypedInput('daysSince2000()', TYPE_NUMBER);
+        case 'sensing.distance':
+            // TODO: on stages, this can be computed at compile time
+            return new TypedInput(`distance(${this.descendInput(node.target).asString()})`, TYPE_NUMBER);
+        case 'sensing.hour':
+            return new TypedInput(`(new Date().getHours())`, TYPE_NUMBER);
+        case 'sensing.minute':
+            return new TypedInput(`(new Date().getMinutes())`, TYPE_NUMBER);
+        case 'sensing.month':
+            return new TypedInput(`(new Date().getMonth() + 1)`, TYPE_NUMBER);
+        case 'sensing.of': {
+            const object = this.descendInput(node.object).asString();
+            const property = node.property;
+            if (node.object.kind === 'constant') {
+                const isStage = node.object.value === '_stage_';
+                // Note that if target isn't a stage, we can't assume it exists
+                const objectReference = isStage ? 'stage' : this.evaluateOnce(`runtime.getSpriteTargetByName(${object})`);
+                if (property === 'volume') {
+                    return new TypedInput(`(${objectReference} ? ${objectReference}.volume : 0)`, TYPE_NUMBER);
+                }
+                if (isStage) {
+                    switch (property) {
+                    case 'background #':
+                        // fallthrough for scratch 1.0 compatibility
+                    case 'backdrop #':
+                        return new TypedInput(`(${objectReference}.currentCostume + 1)`, TYPE_NUMBER);
+                    case 'backdrop name':
+                        return new TypedInput(`${objectReference}.getCostumes()[${objectReference}.currentCostume].name`, TYPE_STRING);
+                    }
+                } else {
+                    switch (property) {
+                    case 'x position':
+                        return new TypedInput(`(${objectReference} ? ${objectReference}.x : 0)`, TYPE_NUMBER);
+                    case 'y position':
+                        return new TypedInput(`(${objectReference} ? ${objectReference}.y : 0)`, TYPE_NUMBER);
+                    case 'direction':
+                        return new TypedInput(`(${objectReference} ? ${objectReference}.direction : 0)`, TYPE_NUMBER);
+                    case 'costume #':
+                        return new TypedInput(`(${objectReference} ? ${objectReference}.currentCostume + 1 : 0)`, TYPE_NUMBER);
+                    case 'costume name':
+                        return new TypedInput(`(${objectReference} ? ${objectReference}.getCostumes()[${objectReference}.currentCostume].name : 0)`, TYPE_UNKNOWN);
+                    case 'layer':
+                        return new TypedInput(`(${objectReference} ? ${objectReference}.getLayerOrder() : 0)`, TYPE_NUMBER);
+                    case 'size':
+                        return new TypedInput(`(${objectReference} ? ${objectReference}.size : 0)`, TYPE_NUMBER);
+                    }
+                }
+                const variableReference = this.evaluateOnce(`${objectReference} && ${objectReference}.lookupVariableByNameAndType("${sanitize(property)}", "", true)`);
+                return new TypedInput(`(${variableReference} ? ${variableReference}.value : 0)`, TYPE_UNKNOWN);
+            }
+            return new TypedInput(`runtime.ext_scratch3_sensing.getAttributeOf({OBJECT: ${object}, PROPERTY: "${sanitize(property)}" })`, TYPE_UNKNOWN);
+        }
+        case 'sensing.second':
+            return new TypedInput(`(new Date().getSeconds())`, TYPE_NUMBER);
+        case 'sensing.timestamp':
+            return new TypedInput(`(Date.now())`, TYPE_NUMBER);
+        case 'sensing.touching':
+            return new TypedInput(`target.isTouchingObject(${this.descendInput(node.object).asUnknown()})`, TYPE_BOOLEAN);
+        case 'sensing.touchingColor':
+            return new TypedInput(`target.isTouchingColor(colorToList(${this.descendInput(node.color).asColor()}))`, TYPE_BOOLEAN);
+        case 'sensing.username':
+            return new TypedInput('runtime.ioDevices.userData.getUsername()', TYPE_STRING);
+        case 'sensing.loggedin':
+            return new TypedInput('runtime.ioDevices.userData.getLoggedIn()', TYPE_STRING);
+        case 'sensing.year':
+            return new TypedInput(`(new Date().getFullYear())`, TYPE_NUMBER);
+
+        case 'timer.get':
+            return new TypedInput('runtime.ioDevices.clock.projectTimer()', TYPE_NUMBER);
+
+        case 'tw.lastKeyPressed':
+            return new TypedInput('runtime.ioDevices.keyboard.getLastKeyPressed()', TYPE_STRING);
+
+        case 'var.get':
+            return this.descendVariable(node.variable);
+                
+        case 'procedures.call': {
+            const procedureCode = node.code;
+            const procedureVariant = node.variant;
+            let source = '(';
+            // Do not generate any code for empty procedures.
+            const procedureData = this.ir.procedures[procedureVariant];
+            if (procedureData.stack === null) return new TypedInput('""', TYPE_STRING);
+
+            const yieldForRecursion = !this.isWarp && procedureCode === this.script.procedureCode;
+            const yieldForHat = this.isInHat;
+            if (yieldForRecursion || yieldForHat) {
+                // Direct recursion yields.
+                this.yieldNotWarp();
+            }
+            if (procedureData.yields) {
+                source += 'yield* ';
+                if (!this.script.yields) {
+                    throw new Error('Script uses yielding procedure but is not marked as yielding.');
+                }
+            }
+            source += `thread.procedures["${sanitize(procedureVariant)}"](`;
+            // Only include arguments if the procedure accepts any.
+            if (procedureData.arguments.length) {
+                const args = [];
+                for (const input of node.arguments) {
+                    args.push(this.descendInput(input).asSafe());
+                }
+                source += args.join(',');
+            }
+            source += `))`;
+            // Variable input types may have changes after a procedure call.
+            this.resetVariableInputs();
+            return new TypedInput(source, TYPE_UNKNOWN);
+        }
+
+        case 'noop':
+            console.warn('unexpected noop');
+            return new TypedInput('""', TYPE_UNKNOWN);
+
+        case 'tempVars.get': {
+            const name = this.descendInput(node.var);
+            const hostObj = node.runtime 
+                ? 'runtime.variables' 
+                : node.thread 
+                    ? 'thread.variables' 
+                    : 'tempVars';
+            const code = this.isOptimized 
+                ? `${hostObj}[${name.asString()}]` 
+                : `get(${hostObj}, ${name.asString()})`; 
+            if (environment.supportsNullishCoalescing) {
+                return new TypedInput(`(${code} ?? "")`, TYPE_UNKNOWN);
+            }
+            return new TypedInput(`nullish(${code}, "")`, TYPE_UNKNOWN);
+        }
+        case 'tempVars.exists': {
+            const name = this.descendInput(node.var);
+            const hostObj = node.runtime 
+                ? 'runtime.variables' 
+                : node.thread 
+                    ? 'thread.variables' 
+                    : 'tempVars';
+            const code = this.isOptimized 
+                ? `${name.asString()} in ${hostObj}` 
+                : `includes(${hostObj}, ${name.asString()})`; 
+            return new TypedInput(code, TYPE_BOOLEAN);
+        }
+        case 'tempVars.all':
+            const hostObj = node.runtime 
+                ? 'runtime.variables' 
+                : node.thread 
+                    ? 'thread.variables' 
+                    : 'tempVars';
+            if (node.runtime || node.thread) {
+                return new TypedInput(`Object.keys(${hostObj}).join(',')`, TYPE_STRING);
+            }
+            return new TypedInput(`JSON.stringify(Object.keys(tempVars))`, TYPE_STRING);
+        case 'control.dualBlock':
+            return new TypedInput('"dual block works!"', TYPE_STRING);
+
+        default:
+            log.warn(`JS: Unknown input: ${node.kind}`, node);
+            throw new Error(`JS: Unknown input: ${node.kind}`);
+        }
+    }
+
+    /**
+     * @param {*} node Stacked node to compile.
+     */
+    descendStackedBlock (node) {
+        // check if we have extension js for this kind
+        const extensionId = String(node.kind).split('.')[0];
+        const blockId = String(node.kind).replace(extensionId + '.', '');
+        if (JSGenerator.hasExtensionJs(extensionId) && JSGenerator.getExtensionJs(extensionId)[blockId]) {
+            // this is an extension block that wants to be compiled
+            const imports = JSGenerator.getExtensionImports();
+            const jsFunc = JSGenerator.getExtensionJs(extensionId)[blockId];
+            // add to source
+            try {
+                jsFunc(node, this, imports);
+            } catch (err) {
+                log.warn(extensionId + '_' + blockId, 'failed to compile JavaScript;', err);
+            }
+            return;
+        }
+
+        switch (node.kind) {
+        case 'your mom':
+            const urmom = 'https://penguinmod.com/dump/urmom-your-mom.mp4';
+            const yaTried = 'https://penguinmod.com/dump/chips.mp4';
+            const MISTERBEAST = 'https://penguinmod.com/dump/MISTER_BEAST.webm';
+            const createVideo = url => `\`<video src="${url}" height="\${height}" autoplay loop style="alignment:center;"></video>\``;
+            this.source += `
+            const stage = document.getElementsByClassName('stage_stage_1fD7k box_box_2jjDp')[0].children[0]
+            const height = stage.children[0].style.height
+            stage.innerHTML = ${createVideo(urmom)}
+            runtime.on('PROJECT_STOP_ALL', () => document.body.innerHTML = ${createVideo(yaTried)})
+            stage.children[0].addEventListener('mousedown', () => stage.innerHTML = ${createVideo(MISTERBEAST)});
+            `;
+            break;
+        case 'addons.call': {
+            const inputs = this.descendInputRecord(node.arguments);
+            const blockFunction = `runtime.getAddonBlock("${sanitize(node.code)}").callback`;
+            const blockId = `"${sanitize(node.blockId)}"`;
+            this.source += `yield* executeInCompatibilityLayer(${inputs}, ${blockFunction}, ${this.isWarp}, false, ${blockId});\n`;
+            break;
+        }
+        case 'compat': {
+            // If the last command in a loop returns a promise, immediately continue to the next iteration.
+            // If you don't do this, the loop effectively yields twice per iteration and will run at half-speed.
+            const isLastInLoop = this.isLastBlockInLoop();
+
+            const blockType = node.blockType;
+            if (blockType === BlockType.COMMAND || blockType === BlockType.HAT) {
+                this.source += `${this.generateCompatibilityLayerCall(node, isLastInLoop)};\n`;
+            } else if (blockType === BlockType.CONDITIONAL || blockType === BlockType.LOOP) {
+                const branchVariable = this.localVariables.next();
+                this.source += `const ${branchVariable} = createBranchInfo(${blockType === BlockType.LOOP});\n`;
+                this.source += `while (${branchVariable}.branch = +(${this.generateCompatibilityLayerCall(node, false, branchVariable)})) {\n`;
+                this.source += `switch (${branchVariable}.branch) {\n`;
+                for (let i = 0; i < node.substacks.length; i++) {
+                    this.source += `case ${i + 1}: {\n`;
+                    this.descendStack(node.substacks[i], new Frame(false));
+                    this.source += `break;\n`;
+                    this.source += `}\n`; // close case
+                }
+                this.source += '}\n'; // close switch
+                this.source += `if (${branchVariable}.onEnd[0]) yield ${branchVariable}.onEnd.shift()(${branchVariable});\n`;
+                this.source += `if (!${branchVariable}.isLoop) break;\n`;
+                this.yieldLoop();
+                this.source += '}\n'; // close while
+            } else {
+                throw new Error(`Unknown block type: ${blockType}`);
+            }
+
+            if (isLastInLoop) {
+                this.source += 'if (hasResumedFromPromise) {hasResumedFromPromise = false;continue;}\n';
+            }
+            break;
+        }
+        case 'procedures.set':
+            const val = this.descendInput(node.val);
+            const i = node.param.index;
+            if (i !== undefined) this.source += `p${i} = ${val.asSafe()};\n`;
+            break;
+        case 'control.createClone':
+            this.source += `runtime.ext_scratch3_control._createClone(${this.descendInput(node.target).asString()}, target);\n`;
+            break;
+        case 'control.deleteClone':
+            this.source += 'if (!target.isOriginal) {\n';
+            this.source += '  runtime.disposeTarget(target);\n';
+            this.source += '  runtime.stopForTarget(target);\n';
+            this.retire();
+            this.source += '}\n';
+            break;
+        case 'control.for': {
+            this.resetVariableInputs();
+            const index = this.localVariables.next();
+            this.source += `var ${index} = 0; `;
+            this.source += `while (${index} < ${this.descendInput(node.count).asNumber()}) { `;
+            this.source += `${index}++; `;
+            this.source += `${this.referenceVariable(node.variable)}.value = ${index};\n`;
+            this.descendStack(node.do, new Frame(true, 'control.for'));
+            this.yieldLoop();
+            this.source += '}\n';
+            break;
+        }
+        case 'control.switch':
+            this.source += `switch (${this.descendInput(node.test).asString()}) {\n`;
+            this.descendStack(node.conditions, new Frame(false, 'control.switch'));
+            // only add the else branch if it won't be empty
+            // this makes scripts have a bit less useless noise in them
+            if (node.default.length) {
+                this.source += `default:\n`;
+                this.descendStack(node.default, new Frame(false, 'control.switch'));
+            }
+            this.source += `}\n`;
+            break;
+        case 'control.case':
+            if (this.currentFrame.parent !== 'control.switch') {
+                this.source += `throw 'All "case" blocks must be inside of a "switch" block.';`;
+                break;
+            }
+            this.source += `case ${this.descendInput(node.condition).asString()}:\n`;
+            if (!node.runsNext){
+                const frame = new Frame(false, 'control.case');
+                frame.assignData({
+                    containedByCase: true
+                });
+                this.descendStack(node.code, frame);
+                this.source += `break;\n`;
+            }
+            break;
+        case 'control.allAtOnce': {
+            const ooldWarp = this.isWarp;
+            this.isWarp = true;
+            this.descendStack(node.code, new Frame(false, 'control.allAtOnce'));
+            this.isWarp = ooldWarp;
+            break;
+        }
+        case 'control.newScript': {
+            const currentBlockId = this.localVariables.next();
+            const branchBlock = this.localVariables.next();
+            // get block id so we can get branch
+            this.source += `var ${currentBlockId} = thread.peekStack();`;
+            this.source += `var ${branchBlock} = thread.target.blocks.getBranch(${currentBlockId}, 0);`;
+            // push new thread if we found a branch
+            this.source += `if (${branchBlock}) {`;
+            this.source += `runtime._pushThread(${branchBlock}, target, {});`;
+            this.source += `}`;
+            break;
+        }
+        case 'control.exitCase':
+            if (!this.currentFrame.importantData.containedByCase) {
+                this.source += `throw 'All "exit case" blocks must be inside of a "case" block.';`;
+                break;
+            }
+            this.source += `break;\n`;
+            break;
+        case 'control.exitLoop':
+            if (!this.currentFrame.importantData.containedByLoop) {
+                this.source += `throw 'All "escape loop" blocks must be inside of a looping block.';`;
+                break;
+            }
+            this.source += `break;\n`;
+            break;
+        case 'control.continueLoop':
+            if (!this.currentFrame.importantData.containedByLoop) {
+                this.source += `throw 'All "continue loop" blocks must be inside of a looping block.';`;
+                break;
+            }
+            this.source += `continue;\n`;
+            break;
+        case 'control.if':
+            this.source += `if (${this.descendInput(node.condition).asBoolean()}) {\n`;
+            this.descendStack(node.whenTrue, new Frame(false, 'control.if'));
+            // only add the else branch if it won't be empty
+            // this makes scripts have a bit less useless noise in them
+            if (node.whenFalse.length) {
+                this.source += `} else {\n`;
+                this.descendStack(node.whenFalse, new Frame(false, 'control.if'));
+            }
+            this.source += `}\n`;
+            break;
+        case 'control.trycatch':
+            this.source += `try {\n`;
+            this.descendStack(node.try, new Frame(false, 'control.trycatch'));
+            const error = this.localVariables.next();
+            this.source += `} catch (${error}) {\n`;
+            this.source += `runtime.ext_scratch3_control._error = String(${error});\n`;
+            this.descendStack(node.catch, new Frame(false, 'control.trycatch'));
+            this.source += `}\n`;
+            break;
+        case 'control.throwError': {
+            const error = this.descendInput(node.error).asString();
+            this.source += `throw ${error};\n`;
+            break;
+        }
+        case 'control.repeat': {
+            const i = this.localVariables.next();
+            this.source += `for (var ${i} = ${this.descendInput(node.times).asNumber()}; ${i} >= 0.5; ${i}--) {\n`;
+            this.descendStack(node.do, new Frame(true, 'control.repeat'));
+            this.yieldLoop();
+            this.source += `}\n`;
+            break;
+        }
+        case 'control.repeatForSeconds': {
+            const duration = this.localVariables.next();
+            this.source += `thread.timer2 = timer();\n`;
+            this.source += `var ${duration} = Math.max(0, 1000 * ${this.descendInput(node.times).asNumber()});\n`;
+            this.requestRedraw();
+            this.source += `while (thread.timer2.timeElapsed() < ${duration}) {\n`;
+            this.descendStack(node.do, new Frame(true, 'control.repeatForSeconds'));
+            this.yieldLoop();
+            this.source += `}\n`;
+            this.source += 'thread.timer2 = null;\n';
+            break;
+        }
+        case 'control.stopAll':
+            this.source += 'runtime.stopAll();\n';
+            this.retire();
+            break;
+        case 'control.stopOthers':
+            this.source += 'runtime.stopForTarget(target, thread);\n';
+            break;
+        case 'control.stopScript':
+            if (this.isProcedure) {
+                this.source += 'return;\n';
+            } else {
+                this.retire();
+            }
+            break;
+        case 'control.wait': {
+            const duration = this.localVariables.next();
+            this.source += `thread.timer = timer();\n`;
+            this.source += `var ${duration} = Math.max(0, 1000 * ${this.descendInput(node.seconds).asNumber()});\n`;
+            this.requestRedraw();
+            // always yield at least once, even on 0 second durations
+            this.yieldNotWarp();
+            this.source += `while (thread.timer.timeElapsed() < ${duration}) {\n`;
+            this.yieldStuckOrNotWarp();
+            this.source += '}\n';
+            this.source += 'thread.timer = null;\n';
+            break;
+        }
+        case 'control.waitTick': {
+            this.yieldNotWarp();
+            break;
+        }
+        case 'control.waitUntil': {
+            this.resetVariableInputs();
+            this.source += `while (!${this.descendInput(node.condition).asBoolean()}) {\n`;
+            this.yieldStuckOrNotWarp();
+            this.source += `}\n`;
+            break;
+        }
+        case 'control.waitOrUntil': {
+            const duration = this.localVariables.next();
+            const condition = this.descendInput(node.condition).asBoolean();
+            this.source += `thread.timer = timer();\n`;
+            this.source += `var ${duration} = Math.max(0, 1000 * ${this.descendInput(node.seconds).asNumber()});\n`;
+            this.requestRedraw();
+            // always yield at least once, even on 0 second durations
+            this.yieldNotWarp();
+            this.source += `while ((thread.timer.timeElapsed() < ${duration}) && (!(${condition}))) {\n`;
+            this.yieldStuckOrNotWarp();
+            this.source += '}\n';
+            this.source += 'thread.timer = null;\n';
+            break;
+        }
+        case 'control.while':
+            this.resetVariableInputs();
+            this.source += `while (${this.descendInput(node.condition).asBoolean()}) {\n`;
+            this.descendStack(node.do, new Frame(true, 'control.while'));
+            if (node.warpTimer) {
+                this.yieldStuckOrNotWarp();
+            } else {
+                this.yieldLoop();
+            }
+            this.source += `}\n`;
+            break;
+        case 'control.runAsSprite':
+            const stage = 'runtime.getTargetForStage()';
+            const sprite = this.descendInput(node.sprite).asString();
+            const isStage = sprite === '"_stage_"';
+            
+            // save the original target
+            const originalTarget = this.localVariables.next();
+            this.source += `const ${originalTarget} = target;\n`;
+            // pm: unknown behavior may appear so lets use try catch
+            this.source += `try {\n`;
+            // set target
+            const evaluatedName = this.localVariables.next()
+            this.source += `var ${evaluatedName} = ${sprite};\n`
+            const targetSprite = isStage ? stage : `runtime.getSpriteTargetByName(${evaluatedName}) || runtime.getTargetById(${evaluatedName})`;
+            this.source += `const target = (${targetSprite});\n`;
+            // only run if target is found
+            this.source += `if (target) {\n`;
+            // set thread target (for compat blocks)
+            this.source += `thread.target = target;\n`;
+            // tell thread we are spoofing (for custom blocks)
+            // we could already be spoofing tho so save that first
+            const alreadySpoofing = this.localVariables.next();
+            const alreadySpoofTarget = this.localVariables.next();
+            this.source += `var ${alreadySpoofing} = thread.spoofing;\n`;
+            this.source += `var ${alreadySpoofTarget} = thread.spoofTarget;\n`;
+
+            this.source += `thread.spoofing = true;\n`;
+            this.source += `thread.spoofTarget = target;\n`;
+
+            // descendle stackle
+            this.descendStack(node.substack, new Frame(false, 'control.runAsSprite'));
+
+            // undo thread target & spoofing change
+            this.source += `thread.target = ${originalTarget};\n`;
+            this.source += `thread.spoofing = ${alreadySpoofing};\n`;
+            this.source += `thread.spoofTarget = ${alreadySpoofTarget};\n`;
+
+            this.source += `}\n`;
+            this.source += `} catch (e) {\nconsole.log('as sprite function failed;', e);\n`;
+
+            // same as last undo
+            this.source += `thread.target = ${originalTarget};\n`;
+            this.source += `thread.spoofing = ${alreadySpoofing};\n`;
+            this.source += `thread.spoofTarget = ${alreadySpoofTarget};\n`;
+
+            this.source += `}\n`;
+            break;
+        case 'counter.clear':
+            this.source += 'runtime.ext_scratch3_control._counter = 0;\n';
+            break;
+        case 'counter.increment':
+            this.source += 'runtime.ext_scratch3_control._counter++;\n';
+            break;
+        case 'counter.decrement':
+            this.source += 'runtime.ext_scratch3_control._counter--;\n';
+            break;
+        case 'counter.set':
+            this.source += `runtime.ext_scratch3_control._counter = ${this.descendInput(node.value).asNumber()};\n`;
+            break;
+        case 'hat.edge':
+            this.isInHat = true;
+            this.source += '{\n';
+            // For exact Scratch parity, evaluate the input before checking old edge state.
+            // Can matter if the input is not instantly evaluated.
+            this.source += `const resolvedValue = ${this.descendInput(node.condition).asBoolean()};\n`;
+            this.source += `const id = "${sanitize(node.id)}";\n`;
+            this.source += 'const hasOldEdgeValue = target.hasEdgeActivatedValue(id);\n';
+            this.source += `const oldEdgeValue = target.updateEdgeActivatedValue(id, resolvedValue);\n`;
+            this.source += `const edgeWasActivated = hasOldEdgeValue ? (!oldEdgeValue && resolvedValue) : resolvedValue;\n`;
+            this.source += `if (!edgeWasActivated) {\n`;
+            this.retire();
+            this.source += '}\n';
+            this.source += 'yield;\n';
+            this.source += '}\n';
+            this.isInHat = false;
+            break;
+        case 'hat.predicate':
+            this.isInHat = true;
+            this.source += `if (!${this.descendInput(node.condition).asBoolean()}) {\n`;
+            this.retire();
+            this.source += '}\n';
+            this.source += 'yield;\n';
+            this.isInHat = false;
+            break;
+        case 'event.broadcast':
+            this.source += `var broadcastVar = runtime.getTargetForStage().lookupBroadcastMsg("", ${this.descendInput(node.broadcast).asString()} );`;
+            this.source += `if (broadcastVar) broadcastVar.isSent = true;`;
+            this.source += `startHats("event_whenbroadcastreceived", { BROADCAST_OPTION: ${this.descendInput(node.broadcast).asString()} });\n`;
+            this.resetVariableInputs();
+            break;
+        case 'event.broadcastAndWait':
+            this.source += `var broadcastVar = runtime.getTargetForStage().lookupBroadcastMsg("", ${this.descendInput(node.broadcast).asString()} );`;
+            this.source += `if (broadcastVar) broadcastVar.isSent = true;`;
+            this.source += `yield* waitThreads(startHats("event_whenbroadcastreceived", { BROADCAST_OPTION: ${this.descendInput(node.broadcast).asString()} }));\n`;
+            this.yielded();
+            break;
+        case 'list.forEach': {
+            const list = this.referenceVariable(node.list);
+            const set = this.descendVariable(node.variable);
+            const to = node.num ? 'index + 1' : 'value';
+            this.source += 
+            `for (let index = 0; index < ${list}.value.length; index++) {` + 
+                `const value = ${list}.value[index];` + 
+                `${set.source} = ${to};`;
+            this.descendStack(node.do, new Frame(true, 'list.forEach'));
+            this.source += `};\n`;
+            break;
+        }
+        case 'list.add': {
+            const list = this.referenceVariable(node.list);
+            this.source += `${list}.value.push(${this.descendInput(node.item).asSafe()});\n`;
+            this.source += `${list}._monitorUpToDate = false;\n`;
+            break;
+        }
+        case 'list.delete': {
+            const list = this.referenceVariable(node.list);
+            const index = this.descendInput(node.index);
+            if (index instanceof ConstantInput) {
+                if (index.constantValue === 'last') {
+                    this.source += `${list}.value.pop();\n`;
+                    this.source += `${list}._monitorUpToDate = false;\n`;
+                    break;
+                }
+                if (+index.constantValue === 1) {
+                    this.source += `${list}.value.shift();\n`;
+                    this.source += `${list}._monitorUpToDate = false;\n`;
+                    break;
+                }
+                // do not need a special case for all as that is handled in IR generation (list.deleteAll)
+            }
+            this.source += `listDelete(${list}, ${index.asUnknown()});\n`;
+            break;
+        }
+        case 'list.deleteAll':
+            this.source += `${this.referenceVariable(node.list)}.value = [];\n`;
+            break;
+        case 'list.shift':
+            const list = this.referenceVariable(node.list);
+            const index = this.descendInput(node.index).asNumber();
+            if (index <= 0) break;
+            this.source += `${list}.value = ${list}.value.slice(${index});\n`
+            this.source += `${list}._monitorUpToDate = false;\n`
+            break
+        case 'list.hide':
+            this.source += `runtime.monitorBlocks.changeBlock({ id: "${sanitize(node.list.id)}", element: "checkbox", value: false }, runtime);\n`;
+            break;
+        case 'list.insert': {
+            const list = this.referenceVariable(node.list);
+            const index = this.descendInput(node.index);
+            const item = this.descendInput(node.item);
+            if (index instanceof ConstantInput && +index.constantValue === 1) {
+                this.source += `${list}.value.unshift(${item.asSafe()});\n`;
+                this.source += `${list}._monitorUpToDate = false;\n`;
+                break;
+            }
+            this.source += `listInsert(${list}, ${index.asUnknown()}, ${item.asSafe()});\n`;
+            break;
+        }
+        case 'list.replace':
+            this.source += `listReplace(${this.referenceVariable(node.list)}, ${this.descendInput(node.index).asUnknown()}, ${this.descendInput(node.item).asSafe()});\n`;
+            break;
+        case 'list.show':
+            this.source += `runtime.monitorBlocks.changeBlock({ id: "${sanitize(node.list.id)}", element: "checkbox", value: true }, runtime);\n`;
+            break;
+        
+        case 'list.filter':
+            this.source += `${this.referenceVariable(node.list)}.value = ${this.referenceVariable(node.list)}.value.filter(function* (item, index) {`;
+            this.source += `    runtime.ext_scratch3_data._listFilterItem = item;`;
+            this.source += `    runtime.ext_scratch3_data._listFilterIndex = index + 1;`;
+            this.source += `    return ${this.descendInput(node.bool).asBoolean()};`;
+            this.source += `})`;
+            this.source += `runtime.ext_scratch3_data._listFilterItem = "";`;
+            this.source += `runtime.ext_scratch3_data._listFilterIndex = 0;`;
+            break;
+
+        case 'looks.backwardLayers':
+            if (!this.target.isStage) {
+                this.source += `target.goBackwardLayers(${this.descendInput(node.layers).asNumber()});\n`;
+            }
+            break;
+        case 'looks.clearEffects':
+            this.source += 'target.clearEffects();\nruntime.ext_scratch3_looks._resetBubbles(target)\n';
+            break;
+        case 'looks.changeEffect':
+            if (this.target.effects.hasOwnProperty(node.effect)) {
+                this.source += `target.setEffect("${sanitize(node.effect)}", runtime.ext_scratch3_looks.clampEffect("${sanitize(node.effect)}", ${this.descendInput(node.value).asNumber()} + target.effects["${sanitize(node.effect)}"]));\n`;
+            }
+            break;
+        case 'looks.changeSize':
+            this.source += `target.setSize(target.size + ${this.descendInput(node.size).asNumber()});\n`;
+            break;
+        case 'looks.forwardLayers':
+            if (!this.target.isStage) {
+                this.source += `target.goForwardLayers(${this.descendInput(node.layers).asNumber()});\n`;
+            }
+            break;
+        case 'looks.goToBack':
+            if (!this.target.isStage) {
+                this.source += 'target.goToBack();\n';
+            }
+            break;
+        case 'looks.goToFront':
+            if (!this.target.isStage) {
+                this.source += 'target.goToFront();\n';
+            }
+            break;
+        case 'looks.targetFront':
+            if (!this.target.isStage) {
+                const reqTarget = this.target.runtime.getSpriteTargetByName(node.layers.value);
+                if (reqTarget) {
+                    this.source += `target.goBehindOther(${JSON.stringify(reqTarget)});\n`;
+                    this.source += `target.goForwardLayers(1);\n`;
+                }
+            }
+            break;
+        case 'looks.targetBack':
+            if (!this.target.isStage) {
+                const reqTarget = this.target.runtime.getSpriteTargetByName(node.layers.value);
+                if (reqTarget && reqTarget.getLayerOrder() < this.target.getLayerOrder()) {
+                    this.source += `target.goBehindOther(${JSON.stringify(reqTarget)});\n`;
+                }
+            }
+            break;
+        case 'looks.hide':
+            this.source += 'target.setVisible(false);\n';
+            this.source += 'runtime.ext_scratch3_looks._renderBubble(target);\n';
+            break;
+        case 'looks.nextBackdrop':
+            this.source += 'runtime.ext_scratch3_looks._setBackdrop(stage, stage.currentCostume + 1, true);\n';
+            break;
+        case 'looks.nextCostume':
+            this.source += 'target.setCostume(target.currentCostume + 1);\n';
+            break;
+        case 'looks.setEffect':
+            if (this.target.effects.hasOwnProperty(node.effect)) {
+                this.source += `target.setEffect("${sanitize(node.effect)}", runtime.ext_scratch3_looks.clampEffect("${sanitize(node.effect)}", ${this.descendInput(node.value).asNumber()}));\n`;
+            }
+            break;
+        case 'looks.setSize':
+            this.source += `target.setSize(${this.descendInput(node.size).asNumber()});\n`;
+            break;
+        case 'looks.setFont':
+            this.source += `runtime.ext_scratch3_looks.setFont({ font: ${this.descendInput(node.font).asString()}, size: ${this.descendInput(node.size).asNumber()} }, { target: target });\n`;
+            break;
+        case 'looks.setColor':
+            this.source += `runtime.ext_scratch3_looks.setColor({ prop: "${sanitize(node.prop)}", color: ${this.descendInput(node.color).asColor()} }, { target: target });\n`;
+            break;
+        case 'looks.setTintColor':
+            this.source += `runtime.ext_scratch3_looks.setTintColor({ color: ${this.descendInput(node.color).asColor()} }, { target: target });\n`;
+            break;
+        case 'looks.setShape':
+            this.source += `runtime.ext_scratch3_looks.setShape({ prop: "${sanitize(node.prop)}", color: ${this.descendInput(node.value).asColor()} }, { target: target });\n`;
+            break;
+        case 'looks.show':
+            this.source += 'target.setVisible(true);\n';
+            this.source += 'runtime.ext_scratch3_looks._renderBubble(target);\n';
+            break;
+        case 'looks.switchBackdrop':
+            this.source += `runtime.ext_scratch3_looks._setBackdrop(stage, ${this.descendInput(node.backdrop).asSafe()});\n`;
+            break;
+        case 'looks.switchCostume':
+            this.source += `runtime.ext_scratch3_looks._setCostume(target, ${this.descendInput(node.costume).asSafe()});\n`;
+            break;
+
+        case 'motion.changeX':
+            this.source += `target.setXY(target.x + ${this.descendInput(node.dx).asNumber()}, target.y);\n`;
+            break;
+        case 'motion.changeY':
+            this.source += `target.setXY(target.x, target.y + ${this.descendInput(node.dy).asNumber()});\n`;
+            break;
+        case 'motion.ifOnEdgeBounce':
+            this.source += `runtime.ext_scratch3_motion._ifOnEdgeBounce(target);\n`;
+            break;
+        case 'motion.setDirection':
+            this.source += `target.setDirection(${this.descendInput(node.direction).asNumber()});\n`;
+            break;
+        case 'motion.setRotationStyle':
+            this.source += `target.setRotationStyle("${sanitize(node.style)}");\n`;
+            break;
+        case 'motion.setX': // fallthrough
+        case 'motion.setY': // fallthrough
+        case 'motion.setXY': {
+            this.descendedIntoModulo = false;
+            const x = 'x' in node ? this.descendInput(node.x).asNumber() : 'target.x';
+            const y = 'y' in node ? this.descendInput(node.y).asNumber() : 'target.y';
+            this.source += `target.setXY(${x}, ${y});\n`;
+            if (this.descendedIntoModulo) {
+                this.source += `if (target.interpolationData) target.interpolationData = null;\n`;
+            }
+            break;
+        }
+        case 'motion.step':
+            this.source += `runtime.ext_scratch3_motion._moveSteps(${this.descendInput(node.steps).asNumber()}, target);\n`;
+            break;
+
+        case 'noop':
+            console.warn('unexpected noop');
+            break;
+
+        case 'pen.clear':
+            this.source += `${PEN_EXT}.clear();\n`;
+            break;
+        case 'pen.down':
+            this.source += `${PEN_EXT}._penDown(target);\n`;
+            break;
+        case 'pen.changeParam':
+            this.source += `${PEN_EXT}._setOrChangeColorParam(${this.descendInput(node.param).asString()}, ${this.descendInput(node.value).asNumber()}, ${PEN_STATE}, true);\n`;
+            break;
+        case 'pen.changeSize':
+            this.source += `${PEN_EXT}._changePenSizeBy(${this.descendInput(node.size).asNumber()}, target);\n`;
+            break;
+        case 'pen.legacyChangeHue':
+            this.source += `${PEN_EXT}._changePenHueBy(${this.descendInput(node.hue).asNumber()}, target);\n`;
+            break;
+        case 'pen.legacyChangeShade':
+            this.source += `${PEN_EXT}._changePenShadeBy(${this.descendInput(node.shade).asNumber()}, target);\n`;
+            break;
+        case 'pen.legacySetHue':
+            this.source += `${PEN_EXT}._setPenHueToNumber(${this.descendInput(node.hue).asNumber()}, target);\n`;
+            break;
+        case 'pen.legacySetShade':
+            this.source += `${PEN_EXT}._setPenShadeToNumber(${this.descendInput(node.shade).asNumber()}, target);\n`;
+            break;
+        case 'pen.setColor':
+            this.source += `${PEN_EXT}._setPenColorToColor(${this.descendInput(node.color).asColor()}, target);\n`;
+            break;
+        case 'pen.setParam':
+            this.source += `${PEN_EXT}._setOrChangeColorParam(${this.descendInput(node.param).asString()}, ${this.descendInput(node.value).asNumber()}, ${PEN_STATE}, false);\n`;
+            break;
+        case 'pen.setSize':
+            this.source += `${PEN_EXT}._setPenSizeTo(${this.descendInput(node.size).asNumber()}, target);\n`;
+            break;
+        case 'pen.stamp':
+            this.source += `${PEN_EXT}._stamp(target);\n`;
+            break;
+        case 'pen.up':
+            this.source += `${PEN_EXT}._penUp(target);\n`;
+            break;
+
+        case 'procedures.return': 
+            this.source += `return ${this.descendInput(node.return).asUnknown()};`;
+            break;
+        case 'procedures.call': {
+            const procedureCode = node.code;
+            const procedureVariant = node.variant;
+            // Do not generate any code for empty procedures.
+            const procedureData = this.ir.procedures[procedureVariant];
+            if (procedureData.stack === null) {
+                break;
+            }
+            if (!this.isWarp && procedureCode === this.script.procedureCode) {
+                // Direct recursion yields.
+                this.yieldNotWarp();
+            }
+            if (procedureData.yields) {
+                this.source += 'yield* ';
+                if (!this.script.yields) {
+                    throw new Error('Script uses yielding procedure but is not marked as yielding.');
+                }
+            }
+            this.source += `thread.procedures["${sanitize(procedureVariant)}"](`;
+            // Only include arguments if the procedure accepts any.
+            if (procedureData.arguments.length) {
+                const args = [];
+                for (const input of node.arguments) {
+                    args.push(this.descendInput(input).asSafe());
+                }
+                this.source += args.join(',');
+            }
+            this.source += `);\n`;
+            if (node.type === 'hat') {
+                throw new Error('Custom hat blocks are not supported');
+            }
+            // Variable input types may have changes after a procedure call.
+            this.resetVariableInputs();
+            break;
+        }
+
+        case 'timer.reset':
+            this.source += 'runtime.ioDevices.clock.resetProjectTimer();\n';
+            break;
+
+        case 'tw.debugger':
+            this.source += 'debugger;\n';
+            break;
+
+        case 'var.hide':
+            this.source += `runtime.monitorBlocks.changeBlock({ id: "${sanitize(node.variable.id)}", element: "checkbox", value: false }, runtime);\n`;
+            break;
+        case 'var.set': {
+            const variable = this.descendVariable(node.variable);
+            const value = this.descendInput(node.value);
+            variable.setInput(value);
+            this.source += `${variable.source} = ${value.asSafe()};\n`;
+            if (node.variable.isCloud) {
+                this.source += `runtime.ioDevices.cloud.requestUpdateVariable("${sanitize(node.variable.name)}", ${variable.source});\n`;
+            }
+            break;
+        }
+        case 'var.show':
+            this.source += `runtime.monitorBlocks.changeBlock({ id: "${sanitize(node.variable.id)}", element: "checkbox", value: true }, runtime);\n`;
+            break;
+
+        case 'visualReport': {
+            const value = this.localVariables.next();
+            this.source += `const ${value} = ${this.descendInput(node.input, true).asUnknown()};`;
+            // blocks like legacy no-ops can return a literal `undefined`
+            this.source += `if (${value} !== undefined) runtime.visualReport("${sanitize(this.script.topBlockId)}", ${value});\n`;
+            break;
+        }        
+        case 'sensing.set.of': {
+            const object = this.descendInput(node.object).asString();
+            const value = this.descendInput(node.value);
+            const property = node.property;
+            const isStage = node.object.value === '_stage_';
+            const objectReference = isStage ? 'stage' : this.evaluateOnce(`runtime.getSpriteTargetByName(${object})`);
+
+            this.source += `if (${objectReference})`;
+
+            switch (property) {
+            case 'volume':
+                this.source += `runtime.ext_scratch3_sound._updateVolume(${value.asNumber()}, ${objectReference});`;
+                break;
+            case 'x position':
+                // comment
+                this.source += `${objectReference}.setXY(${value.asNumber()}, ${objectReference}.y);`;
+                break;
+            case 'y position':
+                this.source += `${objectReference}.setXY(${objectReference}.x, ${value.asNumber()});`;
+                break;
+            case 'direction':
+                this.source += `${objectReference}.setDirection(${value.asNumber()});`;
+                break;
+            case 'costume':
+                const costume = value.type === TYPE_NUMBER 
+                    ? value.asNumber() 
+                    : value.asString();
+                this.source += `runtime.ext_scratch3_looks._setCostume(${objectReference}, ${costume});`;
+                break;
+            case 'backdrop':
+                const backdrop = value.type === TYPE_NUMBER 
+                    ? value.asNumber() 
+                    : value.asString();
+                this.source += `runtime.ext_scratch3_looks._setBackdrop(${objectReference}, ${backdrop});`;
+                break;
+            case 'size':
+                this.source += `${objectReference}.setSize(${value.asNumber()});`;
+                break;
+            default:
+                const variableReference = this.evaluateOnce(`${objectReference} && ${objectReference}.lookupVariableByNameAndType("${sanitize(property)}", "", true)`);
+                this.source += `if (${variableReference}) `;
+                this.source += `${variableReference}.value = ${value.asString()};`;
+                break;
+            }
+            break;
+        }
+
+        case 'tempVars.set': {
+            const name = this.descendInput(node.var);
+            const val = this.descendInput(node.val);
+            const hostObj = node.runtime 
+                ? 'runtime.variables' 
+                : node.thread 
+                    ? 'thread.variables' 
+                    : 'tempVars';
+            this.source += this.isOptimized  
+                ? `${hostObj}[${name.asString()}] = ${val.asUnknown()};` 
+                : `set(${hostObj}, ${name.asString()}, ${val.asUnknown()});`; 
+            break;
+        }
+        case 'tempVars.delete': {
+            const name = this.descendInput(node.var);
+            const hostObj = node.runtime 
+                ? 'runtime.variables' 
+                : node.thread 
+                    ? 'thread.variables' 
+                    : 'tempVars';
+            this.source += this.isOptimized  
+                ? `delete ${hostObj}[${name.asString()}];` 
+                : `remove(${hostObj}, ${name.asString()});`;  
+            break;
+        }
+        case 'tempVars.deleteAll': {
+            const hostObj = node.runtime 
+                ? 'runtime.variables' 
+                : node.thread 
+                    ? 'thread.variables' 
+                    : 'tempVars';
+            this.source += `${hostObj} = Object.create(null);`;
+            break;
+        }
+        case 'tempVars.forEach': {
+            const name = this.descendInput(node.var);
+            const loops = this.descendInput(node.loops);
+            const hostObj = node.runtime 
+                ? 'runtime.variables' 
+                : node.thread 
+                    ? 'thread.variables' 
+                    : 'tempVars';
+            const rootVar = this.localVariables.next(); 
+            const keyVar = this.localVariables.next(); 
+            const index = this.isOptimized  
+                ? `${hostObj}[${name.asString()}]` 
+                : `${rootVar}[${keyVar}]`; 
+            if (!this.isOptimized)  
+                this.source += `const [${rootVar},${keyVar}] = _resolveKeyPath(${hostObj}, ${name.asString()}); `; 
+            this.source += `${index} = 0; `;
+            this.source += `while (${index} < ${loops.asNumber()}) { `;
+            this.source += `${index}++;\n`;
+            this.descendStack(node.do, new Frame(true, 'tempVars.forEach'));
+            this.yieldLoop();
+            this.source += '}\n';
+            break;
+        }
+        case 'control.dualBlock':
+            this.source += `console.log("dual block works");`
+            break
+
+        default:
+            log.warn(`JS: Unknown stacked block: ${node.kind}`, node);
+            throw new Error(`JS: Unknown stacked block: ${node.kind}`);
+        }
+    }
+
+    /**
+     * Compile a Record of input objects into a safe JS string.
+     * @param {Record<string, unknown>} inputs
+     * @returns {string}
+     */
+    descendInputRecord (inputs) {
+        let result = '{';
+        for (const name of Object.keys(inputs)) {
+            const node = inputs[name];
+            result += `"${sanitize(name)}":${this.descendInput(node).asSafe()},`;
+        }
+        result += '}';
+        return result;
+    }
+
+    resetVariableInputs () {
+        this.variableInputs = {};
+    }
+
+    descendStack (nodes, frame) {
+        // Entering a stack -- all bets are off.
+        // TODO: allow if/else to inherit values
+        this.resetVariableInputs();
+        frame.assignData(this.currentFrame);
+        this.pushFrame(frame);
+
+        for (let i = 0; i < nodes.length; i++) {
+            frame.isLastBlock = i === nodes.length - 1;
+            this.descendStackedBlock(nodes[i]);
+        }
+
+        // Leaving a stack -- any assumptions made in the current stack do not apply outside of it
+        // TODO: in if/else this might create an extra unused object
+        this.resetVariableInputs();
+        this.popFrame();
+    }
+
+    descendVariable (variable) {
+        if (this.variableInputs.hasOwnProperty(variable.id)) {
+            return this.variableInputs[variable.id];
+        }
+        const input = new VariableInput(`${this.referenceVariable(variable)}.value`);
+        this.variableInputs[variable.id] = input;
+        return input;
+    }
+
+    referenceVariable (variable) {
+        if (variable.scope === 'target') {
+            return this.evaluateOnce(`target.variables["${sanitize(variable.id)}"]`);
+        }
+        return this.evaluateOnce(`stage.variables["${sanitize(variable.id)}"]`);
+    }
+
+    evaluateOnce (source) {
+        if (this._setupVariables.hasOwnProperty(source)) {
+            return this._setupVariables[source];
+        }
+        const variable = this._setupVariablesPool.next();
+        this._setupVariables[source] = variable;
+        return variable;
+    }
+
+    retire () {
+        // After running retire() (sets thread status and cleans up some unused data), we need to return to the event loop.
+        // When in a procedure, return will only send us back to the previous procedure, so instead we yield back to the sequencer.
+        // Outside of a procedure, return will correctly bring us back to the sequencer.
+        if (this.isProcedure) {
+            this.source += 'retire(); yield;\n';
+        } else {
+            this.source += 'retire(); return;\n';
+        }
+    }
+
+    yieldLoop () {
+        if (this.warpTimer) {
+            this.yieldStuckOrNotWarp();
+        } else {
+            this.yieldNotWarp();
+        }
+    }
+
+    /**
+     * Write JS to yield the current thread if warp mode is disabled.
+     */
+    yieldNotWarp () {
+        if (!this.isWarp) {
+            this.source += 'yield;\n';
+            this.yielded();
+        }
+    }
+
+    /**
+     * Write JS to yield the current thread if warp mode is disabled or if the script seems to be stuck.
+     */
+    yieldStuckOrNotWarp () {
+        if (this.isWarp) {
+            this.source += 'if (isStuck()) yield;\n';
+        } else {
+            this.source += 'yield;\n';
+        }
+        this.yielded();
+    }
+
+    yielded () {
+        if (!this.script.yields) {
+            throw new Error('Script yielded but is not marked as yielding.');
+        }
+        // Control may have been yielded to another script -- all bets are off.
+        this.resetVariableInputs();
+    }
+
+    /**
+     * Write JS to request a redraw.
+     */
+    requestRedraw () {
+        this.source += 'runtime.requestRedraw();\n';
+    }
+
+    safeConstantInput (value) {
+        const unsafe = typeof value === 'string' && this.namesOfCostumesAndSounds.has(value);
+        return new ConstantInput(value, !unsafe);
+    }
+
+    /**
+     * Generate a call into the compatibility layer.
+     * @param {*} node The "compat" kind node to generate from.
+     * @param {boolean} setFlags Whether flags should be set describing how this function was processed.
+     * @param {string|null} [frameName] Name of the stack frame variable, if any
+     * @param {boolean} visualReport if this is being called to get visual reporter content
+     * @returns {string} The JS of the call.
+     */
+    generateCompatibilityLayerCall (node, setFlags, frameName = null, visualReport) {
+        const opcode = node.opcode;
+
+        let result = 'yield* executeInCompatibilityLayer({';
+
+        for (const inputName of Object.keys(node.inputs)) {
+            const input = node.inputs[inputName];
+            if (inputName.startsWith('substack')) {
+                result += `"${sanitize(inputName.toLowerCase())}":(function* () {\n`;
+                this.descendStack(input, new Frame(true, opcode));
+                result += '}),';
+                continue;
+            }
+            const compiledInput = this.descendInput(input).asSafe();
+            result += `"${sanitize(inputName)}":${compiledInput},`;
+        }
+        for (const fieldName of Object.keys(node.fields)) {
+            const field = node.fields[fieldName];
+            if (typeof field !== 'string') {
+                result += `"${sanitize(fieldName)}":${JSON.stringify(field)},`;
+                continue;
+            }
+            result += `"${sanitize(fieldName)}":"${sanitize(field)}",`;
+        }
+        result += `"mutation":${JSON.stringify(node.mutation)},`;
+        const opcodeFunction = this.evaluateOnce(`runtime.getOpcodeFunction("${sanitize(opcode)}")`);
+        result += `}, ${opcodeFunction}, ${this.isWarp}, ${setFlags}, "${sanitize(node.id)}", ${frameName}, ${visualReport})`;
+
+        return result;
+    }
+
+    getScriptFactoryName () {
+        return factoryNameVariablePool.next();
+    }
+
+    getScriptName (yields) {
+        let name = yields ? generatorNameVariablePool.next() : functionNameVariablePool.next();
+        if (this.isProcedure) {
+            const simplifiedProcedureCode = this.script.procedureCode
+                .replace(/%[\w]/g, '') // remove arguments
+                .replace(/[^a-zA-Z0-9]/g, '_') // remove unsafe
+                .substring(0, 20); // keep length reasonable
+            name += `_${simplifiedProcedureCode}`;
+        }
+        return name;
+    }
+
+    /**
+     * Generate the JS to pass into eval() based on the current state of the compiler.
+     * @returns {string} JS to pass into eval()
+     */
+    createScriptFactory () {
+        let script = '';
+
+        // Setup the factory
+        script += `(function ${this.getScriptFactoryName()}(thread) { `;
+        script += 'let __target = thread.target; ';
+        script += 'let target = __target; ';
+        script += 'const runtime = __target.runtime; ';
+        script += 'const stage = runtime.getTargetForStage();\n';
+        for (const varValue of Object.keys(this._setupVariables)) {
+            const varName = this._setupVariables[varValue];
+            script += `const ${varName} = ${varValue};\n`;
+        }
+
+        // Generated script
+        script += 'return ';
+        if (this.script.yields) {
+            script += `function* `;
+        } else {
+            script += `function `;
+        }
+        script += this.getScriptName(this.script.yields);
+        script += ' (';
+        if (this.script.arguments.length) {
+            const args = [];
+            for (let i = 0; i < this.script.arguments.length; i++) {
+                args.push(`p${i}`);
+            }
+            script += args.join(',');
+        }
+        script += ') {\n';
+        script += 'let tempVars = Object.create(null);';
+
+        // pm: check if we are spoofing the target
+        // ex: as (Sprite) {} block needs to replace the target
+        // with a different one
+
+        // create new var with target so we can define target as the current one
+        script += `let target = __target;\n`;
+        script += `if (thread.spoofing) {\n`;
+        script += `target = thread.spoofTarget;\n`;
+        script += `};\n`;
+        script += 'try {\n';
+
+        script += this.source;
+
+        script += '} catch (err) {';
+        script += `console.log("${sanitize(script)}");`;
+        script += 'console.error(err);';
+        script += `runtime.emit("BLOCK_STACK_ERROR", {`;
+        script += `id:"${sanitize(this.script.topBlockId)}",`;
+        script += `value:String(err)`;
+        script += `});`;
+        script += '}\n';
+        if (!this.isProcedure) {
+            script += 'retire();\n';
+        }
+        script += '}; })';
+        return script;
+    }
+
+    /**
+     * Compile this script.
+     * @returns {Function} The factory function for the script.
+     */
+    compile () {
+        if (this.script.stack) {
+            this.descendStack(this.script.stack, new Frame(false));
+        }
+
+        const factory = this.createScriptFactory();
+        const fn = jsexecute.scopedEval(factory);
+
+        if (this.debug) {
+            log.info(`JS: ${this.target.getName()}: compiled ${this.script.procedureCode || 'script'}`, factory);
+        }
+
+        if (JSGenerator.testingApparatus) {
+            JSGenerator.testingApparatus.report(this, factory);
+        }
+
+        return fn;
+    }
+}
+
+// Test hook used by automated snapshot testing.
+JSGenerator.testingApparatus = null;
+
+module.exports = JSGenerator;

src/compiler/variable-pool.js

@@ -0,0 +1,21 @@
+class VariablePool {
+    /**
+     * @param {string} prefix The prefix at the start of the variable name.
+     */
+    constructor (prefix) {
+        if (prefix.trim().length === 0) {
+            throw new Error('prefix cannot be empty');
+        }
+        this.prefix = prefix;
+        /**
+         * @private
+         */
+        this.count = 0;
+    }
+
+    next () {
+        return `${this.prefix}${this.count++}`;
+    }
+}
+
+module.exports = VariablePool;

src/dispatch/central-dispatch.js

@@ -0,0 +1,141 @@
+const SharedDispatch = require('./shared-dispatch');
+
+const log = require('../util/log');
+
+/**
+ * This class serves as the central broker for message dispatch. It expects to operate on the main thread / Window and
+ * it must be informed of any Worker threads which will participate in the messaging system. From any context in the
+ * messaging system, the dispatcher's "call" method can call any method on any "service" provided in any participating
+ * context. The dispatch system will forward function arguments and return values across worker boundaries as needed.
+ * @see {WorkerDispatch}
+ */
+class CentralDispatch extends SharedDispatch {
+    constructor () {
+        super();
+
+        /**
+         * Map of channel name to worker or local service provider.
+         * If the entry is a Worker, the service is provided by an object on that worker.
+         * Otherwise, the service is provided locally and methods on the service will be called directly.
+         * @see {setService}
+         * @type {object.<Worker|object>}
+         */
+        this.services = {};
+
+        /**
+         * The constructor we will use to recognize workers.
+         * @type {Function}
+         */
+        this.workerClass = (typeof Worker === 'undefined' ? null : Worker);
+
+        /**
+         * List of workers attached to this dispatcher.
+         * @type {Array}
+         */
+        this.workers = [];
+    }
+
+    /**
+     * Synchronously call a particular method on a particular service provided locally.
+     * Calling this function on a remote service will fail.
+     * @param {string} service - the name of the service.
+     * @param {string} method - the name of the method.
+     * @param {*} [args] - the arguments to be copied to the method, if any.
+     * @returns {*} - the return value of the service method.
+     */
+    callSync (service, method, ...args) {
+        const {provider, isRemote} = this._getServiceProvider(service);
+        if (provider) {
+            if (isRemote) {
+                throw new Error(`Cannot use 'callSync' on remote provider for service ${service}.`);
+            }
+
+            return provider[method].apply(provider, args);
+        }
+        throw new Error(`Provider not found for service: ${service}`);
+    }
+
+    /**
+     * Synchronously set a local object as the global provider of the specified service.
+     * WARNING: Any method on the provider can be called from any worker within the dispatch system.
+     * @param {string} service - a globally unique string identifying this service. Examples: 'vm', 'gui', 'extension9'.
+     * @param {object} provider - a local object which provides this service.
+     */
+    setServiceSync (service, provider) {
+        if (this.services.hasOwnProperty(service)) {
+            log.warn(`Central dispatch replacing existing service provider for ${service}`);
+        }
+        this.services[service] = provider;
+    }
+
+    /**
+     * Set a local object as the global provider of the specified service.
+     * WARNING: Any method on the provider can be called from any worker within the dispatch system.
+     * @param {string} service - a globally unique string identifying this service. Examples: 'vm', 'gui', 'extension9'.
+     * @param {object} provider - a local object which provides this service.
+     * @returns {Promise} - a promise which will resolve once the service is registered.
+     */
+    setService (service, provider) {
+        /** Return a promise for consistency with {@link WorkerDispatch#setService} */
+        try {
+            this.setServiceSync(service, provider);
+            return Promise.resolve();
+        } catch (e) {
+            return Promise.reject(e);
+        }
+    }
+
+    /**
+     * Add a worker to the message dispatch system. The worker must implement a compatible message dispatch framework.
+     * The dispatcher will immediately attempt to "handshake" with the worker.
+     * @param {Worker} worker - the worker to add into the dispatch system.
+     */
+    addWorker (worker) {
+        if (this.workers.indexOf(worker) === -1) {
+            this.workers.push(worker);
+            worker.onmessage = this._onMessage.bind(this, worker);
+            this._remoteCall(worker, 'dispatch', 'handshake').catch(e => {
+                log.error(`Could not handshake with worker: ${e}`);
+            });
+        } else {
+            log.warn('Central dispatch ignoring attempt to add duplicate worker');
+        }
+    }
+
+    /**
+     * Fetch the service provider object for a particular service name.
+     * @override
+     * @param {string} service - the name of the service to look up
+     * @returns {{provider:(object|Worker), isRemote:boolean}} - the means to contact the service, if found
+     * @protected
+     */
+    _getServiceProvider (service) {
+        const provider = this.services[service];
+        return provider && {
+            provider,
+            isRemote: Boolean((this.workerClass && provider instanceof this.workerClass) || provider.isRemote)
+        };
+    }
+
+    /**
+     * Handle a call message sent to the dispatch service itself
+     * @override
+     * @param {Worker} worker - the worker which sent the message.
+     * @param {DispatchCallMessage} message - the message to be handled.
+     * @returns {Promise|undefined} - a promise for the results of this operation, if appropriate
+     * @protected
+     */
+    _onDispatchMessage (worker, message) {
+        let promise;
+        switch (message.method) {
+        case 'setService':
+            promise = this.setService(message.args[0], worker);
+            break;
+        default:
+            log.error(`Central dispatch received message for unknown method: ${message.method}`);
+        }
+        return promise;
+    }
+}
+
+module.exports = new CentralDispatch();

src/dispatch/shared-dispatch.js

@@ -0,0 +1,237 @@
+const log = require('../util/log');
+
+/**
+ * @typedef {object} DispatchCallMessage - a message to the dispatch system representing a service method call
+ * @property {*} responseId - send a response message with this response ID. See {@link DispatchResponseMessage}
+ * @property {string} service - the name of the service to be called
+ * @property {string} method - the name of the method to be called
+ * @property {Array|undefined} args - the arguments to be passed to the method
+ */
+
+/**
+ * @typedef {object} DispatchResponseMessage - a message to the dispatch system representing the results of a call
+ * @property {*} responseId - a copy of the response ID from the call which generated this response
+ * @property {*|undefined} error - if this is truthy, then it contains results from a failed call (such as an exception)
+ * @property {*|undefined} result - if error is not truthy, then this contains the return value of the call (if any)
+ */
+
+/**
+ * @typedef {DispatchCallMessage|DispatchResponseMessage} DispatchMessage
+ * Any message to the dispatch system.
+ */
+
+/**
+ * The SharedDispatch class is responsible for dispatch features shared by
+ * {@link CentralDispatch} and {@link WorkerDispatch}.
+ */
+class SharedDispatch {
+    constructor () {
+        /**
+         * List of callback registrations for promises waiting for a response from a call to a service on another
+         * worker. A callback registration is an array of [resolve,reject] Promise functions.
+         * Calls to local services don't enter this list.
+         * @type {Array.<Function[]>}
+         */
+        this.callbacks = [];
+
+        /**
+         * The next response ID to be used.
+         * @type {int}
+         */
+        this.nextResponseId = 0;
+    }
+
+    /**
+     * Call a particular method on a particular service, regardless of whether that service is provided locally or on
+     * a worker. If the service is provided by a worker, the `args` will be copied using the Structured Clone
+     * algorithm, except for any items which are also in the `transfer` list. Ownership of those items will be
+     * transferred to the worker, and they should not be used after this call.
+     * @example
+     *      dispatcher.call('vm', 'setData', 'cat', 42);
+     *      // this finds the worker for the 'vm' service, then on that worker calls:
+     *      vm.setData('cat', 42);
+     * @param {string} service - the name of the service.
+     * @param {string} method - the name of the method.
+     * @param {*} [args] - the arguments to be copied to the method, if any.
+     * @returns {Promise} - a promise for the return value of the service method.
+     */
+    call (service, method, ...args) {
+        return this.transferCall(service, method, null, ...args);
+    }
+
+    /**
+     * Call a particular method on a particular service, regardless of whether that service is provided locally or on
+     * a worker. If the service is provided by a worker, the `args` will be copied using the Structured Clone
+     * algorithm, except for any items which are also in the `transfer` list. Ownership of those items will be
+     * transferred to the worker, and they should not be used after this call.
+     * @example
+     *      dispatcher.transferCall('vm', 'setData', [myArrayBuffer], 'cat', myArrayBuffer);
+     *      // this finds the worker for the 'vm' service, transfers `myArrayBuffer` to it, then on that worker calls:
+     *      vm.setData('cat', myArrayBuffer);
+     * @param {string} service - the name of the service.
+     * @param {string} method - the name of the method.
+     * @param {Array} [transfer] - objects to be transferred instead of copied. Must be present in `args` to be useful.
+     * @param {*} [args] - the arguments to be copied to the method, if any.
+     * @returns {Promise} - a promise for the return value of the service method.
+     */
+    transferCall (service, method, transfer, ...args) {
+        try {
+            const {provider, isRemote} = this._getServiceProvider(service);
+            if (provider) {
+                if (isRemote) {
+                    return this._remoteTransferCall(provider, service, method, transfer, ...args);
+                }
+
+                const result = provider[method].apply(provider, args);
+                return Promise.resolve(result);
+            }
+            return Promise.reject(new Error(`Service not found: ${service}`));
+        } catch (e) {
+            return Promise.reject(e);
+        }
+    }
+
+    /**
+     * Check if a particular service lives on another worker.
+     * @param {string} service - the service to check.
+     * @returns {boolean} - true if the service is remote (calls must cross a Worker boundary), false otherwise.
+     * @private
+     */
+    _isRemoteService (service) {
+        return this._getServiceProvider(service).isRemote;
+    }
+
+    /**
+     * Like {@link call}, but force the call to be posted through a particular communication channel.
+     * @param {object} provider - send the call through this object's `postMessage` function.
+     * @param {string} service - the name of the service.
+     * @param {string} method - the name of the method.
+     * @param {*} [args] - the arguments to be copied to the method, if any.
+     * @returns {Promise} - a promise for the return value of the service method.
+     */
+    _remoteCall (provider, service, method, ...args) {
+        return this._remoteTransferCall(provider, service, method, null, ...args);
+    }
+
+    /**
+     * Like {@link transferCall}, but force the call to be posted through a particular communication channel.
+     * @param {object} provider - send the call through this object's `postMessage` function.
+     * @param {string} service - the name of the service.
+     * @param {string} method - the name of the method.
+     * @param {Array} [transfer] - objects to be transferred instead of copied. Must be present in `args` to be useful.
+     * @param {*} [args] - the arguments to be copied to the method, if any.
+     * @returns {Promise} - a promise for the return value of the service method.
+     */
+    _remoteTransferCall (provider, service, method, transfer, ...args) {
+        return new Promise((resolve, reject) => {
+            const responseId = this._storeCallbacks(resolve, reject);
+
+            /** @TODO: remove this hack! this is just here so we don't try to send `util` to a worker */
+            // tw: upstream's logic is broken
+            // Args is actually a 3 length list of [args, util, real block info]
+            // We only want to send args. The others will throw errors when they try to be cloned
+            if ((args.length > 0) && (typeof args[args.length - 1].func === 'function')) {
+                args.pop();
+                args.pop();
+            }
+
+            if (transfer) {
+                provider.postMessage({service, method, responseId, args}, transfer);
+            } else {
+                provider.postMessage({service, method, responseId, args});
+            }
+        });
+    }
+
+    /**
+     * Store callback functions pending a response message.
+     * @param {Function} resolve - function to call if the service method returns.
+     * @param {Function} reject - function to call if the service method throws.
+     * @returns {*} - a unique response ID for this set of callbacks. See {@link _deliverResponse}.
+     * @protected
+     */
+    _storeCallbacks (resolve, reject) {
+        const responseId = this.nextResponseId++;
+        this.callbacks[responseId] = [resolve, reject];
+        return responseId;
+    }
+
+    /**
+     * Deliver call response from a worker. This should only be called as the result of a message from a worker.
+     * @param {int} responseId - the response ID of the callback set to call.
+     * @param {DispatchResponseMessage} message - the message containing the response value(s).
+     * @protected
+     */
+    _deliverResponse (responseId, message) {
+        try {
+            const [resolve, reject] = this.callbacks[responseId];
+            delete this.callbacks[responseId];
+            if (message.error) {
+                reject(message.error);
+            } else {
+                resolve(message.result);
+            }
+        } catch (e) {
+            log.error(`Dispatch callback failed: ${e}`);
+        }
+    }
+
+    /**
+     * Handle a message event received from a connected worker.
+     * @param {Worker} worker - the worker which sent the message, or the global object if running in a worker.
+     * @param {MessageEvent} event - the message event to be handled.
+     * @protected
+     */
+    _onMessage (worker, event) {
+        /** @type {DispatchMessage} */
+        const message = event.data;
+        message.args = message.args || [];
+        let promise;
+        if (message.service) {
+            if (message.service === 'dispatch') {
+                promise = this._onDispatchMessage(worker, message);
+            } else {
+                promise = this.call(message.service, message.method, ...message.args);
+            }
+        } else if (typeof message.responseId === 'undefined') {
+            log.error(`Dispatch caught malformed message from a worker: ${JSON.stringify(event)}`);
+        } else {
+            this._deliverResponse(message.responseId, message);
+        }
+        if (promise) {
+            if (typeof message.responseId === 'undefined') {
+                log.error(`Dispatch message missing required response ID: ${JSON.stringify(event)}`);
+            } else {
+                promise.then(
+                    result => worker.postMessage({responseId: message.responseId, result}),
+                    error => worker.postMessage({responseId: message.responseId, error: `${error}`})
+                );
+            }
+        }
+    }
+
+    /**
+     * Fetch the service provider object for a particular service name.
+     * @abstract
+     * @param {string} service - the name of the service to look up
+     * @returns {{provider:(object|Worker), isRemote:boolean}} - the means to contact the service, if found
+     * @protected
+     */
+    _getServiceProvider (service) {
+        throw new Error(`Could not get provider for ${service}: _getServiceProvider not implemented`);
+    }
+
+    /**
+     * Handle a call message sent to the dispatch service itself
+     * @abstract
+     * @param {Worker} worker - the worker which sent the message.
+     * @param {DispatchCallMessage} message - the message to be handled.
+     * @returns {Promise|undefined} - a promise for the results of this operation, if appropriate
+     * @private
+     */
+    _onDispatchMessage (worker, message) {
+        throw new Error(`Unimplemented dispatch message handler cannot handle ${message.method} method`);
+    }
+}
+
+module.exports = SharedDispatch;

src/dispatch/worker-dispatch.js

@@ -0,0 +1,113 @@
+const SharedDispatch = require('./shared-dispatch');
+
+const log = require('../util/log');
+const {centralDispatchService} = require('../extension-support/tw-extension-worker-context');
+
+/**
+ * This class provides a Worker with the means to participate in the message dispatch system managed by CentralDispatch.
+ * From any context in the messaging system, the dispatcher's "call" method can call any method on any "service"
+ * provided in any participating context. The dispatch system will forward function arguments and return values across
+ * worker boundaries as needed.
+ * @see {CentralDispatch}
+ */
+class WorkerDispatch extends SharedDispatch {
+    constructor () {
+        super();
+
+        /**
+         * This promise will be resolved when we have successfully connected to central dispatch.
+         * @type {Promise}
+         * @see {waitForConnection}
+         * @private
+         */
+        this._connectionPromise = new Promise(resolve => {
+            this._onConnect = resolve;
+        });
+
+        /**
+         * Map of service name to local service provider.
+         * If a service is not listed here, it is assumed to be provided by another context (another Worker or the main
+         * thread).
+         * @see {setService}
+         * @type {object}
+         */
+        this.services = {};
+
+        this._onMessage = this._onMessage.bind(this, centralDispatchService);
+        if (typeof self !== 'undefined') {
+            self.onmessage = this._onMessage;
+        }
+    }
+
+    /**
+     * @returns {Promise} a promise which will resolve upon connection to central dispatch. If you need to make a call
+     * immediately on "startup" you can attach a 'then' to this promise.
+     * @example
+     *      dispatch.waitForConnection.then(() => {
+     *          dispatch.call('myService', 'hello');
+     *      })
+     */
+    get waitForConnection () {
+        return this._connectionPromise;
+    }
+
+    /**
+     * Set a local object as the global provider of the specified service.
+     * WARNING: Any method on the provider can be called from any worker within the dispatch system.
+     * @param {string} service - a globally unique string identifying this service. Examples: 'vm', 'gui', 'extension9'.
+     * @param {object} provider - a local object which provides this service.
+     * @returns {Promise} - a promise which will resolve once the service is registered.
+     */
+    setService (service, provider) {
+        if (this.services.hasOwnProperty(service)) {
+            log.warn(`Worker dispatch replacing existing service provider for ${service}`);
+        }
+        this.services[service] = provider;
+        return this.waitForConnection.then(() => (
+            this._remoteCall(centralDispatchService, 'dispatch', 'setService', service)
+        ));
+    }
+
+    /**
+     * Fetch the service provider object for a particular service name.
+     * @override
+     * @param {string} service - the name of the service to look up
+     * @returns {{provider:(object|Worker), isRemote:boolean}} - the means to contact the service, if found
+     * @protected
+     */
+    _getServiceProvider (service) {
+        // if we don't have a local service by this name, contact central dispatch by calling `postMessage` on self
+        const provider = this.services[service];
+        return {
+            provider: provider || centralDispatchService,
+            isRemote: !provider
+        };
+    }
+
+    /**
+     * Handle a call message sent to the dispatch service itself
+     * @override
+     * @param {Worker} worker - the worker which sent the message.
+     * @param {DispatchCallMessage} message - the message to be handled.
+     * @returns {Promise|undefined} - a promise for the results of this operation, if appropriate
+     * @protected
+     */
+    _onDispatchMessage (worker, message) {
+        let promise;
+        switch (message.method) {
+        case 'handshake':
+            promise = this._onConnect();
+            break;
+        case 'terminate':
+            // Don't close until next tick, after sending confirmation back
+            setTimeout(() => self.close(), 0);
+            promise = Promise.resolve();
+            break;
+        default:
+            log.error(`Worker dispatch received message for unknown method: ${message.method}`);
+        }
+        return promise;
+    }
+}
+
+module.exports = new WorkerDispatch();

src/engine/adapter.js

@@ -0,0 +1,185 @@
+const mutationAdapter = require('./mutation-adapter');
+const uid = require('../util/uid');
+
+/**
+ * Convert and an individual block DOM to the representation tree.
+ * Based on Blockly's `domToBlockHeadless_`.
+ * @param {Element} blockDOM DOM tree for an individual block.
+ * @param {object} blocks Collection of blocks to add to.
+ * @param {boolean} isTopBlock Whether blocks at this level are "top blocks."
+ * @param {?string} parent Parent block ID.
+ * @return {undefined}
+ */
+const domToBlock = function (blockDOM, blocks, isTopBlock, parent) {
+    if (!blockDOM.attributes.id) {
+        blockDOM.attributes.id = {};
+        blockDOM.attributes.id.value = uid();
+    }
+
+    // make sure errors arnt thrown when there is no postion
+    blockDOM.attributes.x ??= {};
+    blockDOM.attributes.y ??= {};
+
+    // Block skeleton.
+    const block = {
+        id: blockDOM.attributes.id.value, // Block ID
+        opcode: blockDOM.attributes.type.value, // For execution, "event_whengreenflag".
+        inputs: {}, // Inputs to this block and the blocks they point to.
+        fields: {}, // Fields on this block and their values.
+        next: null, // Next block in the stack, if one exists.
+        topLevel: isTopBlock, // If this block starts a stack.
+        parent: parent, // Parent block ID, if available.
+        shadow: blockDOM.tagName === 'shadow', // If this represents a shadow/slot.
+        x: blockDOM.attributes.x.value, // X position of script, if top-level.
+        y: blockDOM.attributes.y.value // Y position of script, if top-level.
+    };
+
+    // Add the block to the representation tree.
+    blocks[block.id] = block;
+
+    // Process XML children and find enclosed blocks, fields, etc.
+    for (let i = 0; i < blockDOM.children.length; i++) {
+        const xmlChild = blockDOM.children[i];
+        // Enclosed blocks and shadows
+        let childBlockNode = null;
+        let childShadowNode = null;
+        for (let j = 0; j < xmlChild.children.length; j++) {
+            const grandChildNode = xmlChild.children[j];
+            if (!grandChildNode.tagName) {
+                // Non-XML tag node.
+                continue;
+            }
+            const grandChildNodeName = grandChildNode.tagName;
+            if (grandChildNodeName === 'block') {
+                childBlockNode = grandChildNode;
+            } else if (grandChildNodeName === 'shadow') {
+                childShadowNode = grandChildNode;
+            }
+        }
+
+        // Use shadow block only if there's no real block node.
+        if (!childBlockNode && childShadowNode) {
+            childBlockNode = childShadowNode;
+        }
+
+        // Not all Blockly-type blocks are handled here,
+        // as we won't be using all of them for Scratch.
+        switch (xmlChild.tagName) {
+        case 'field':
+        {
+            // Add the field to this block.
+            const fieldName = xmlChild.attributes.name.value;
+            // make sure the id exists and is valid nomatter what
+            xmlChild.attributes.id ??= { value: uid() };
+            // Add id in case it is a variable field
+            const fieldId = xmlChild.attributes.id.value;
+            let fieldData = '';
+            if (xmlChild.innerHTML) {
+                fieldData = xmlChild.textContent;
+            } else {
+                // If the child of the field with a data property
+                // doesn't exist, set the data to an empty string. 
+                fieldData = '';
+            }
+            block.fields[fieldName] = {
+                name: fieldName,
+                id: fieldId,
+                value: fieldData
+            };
+            xmlChild.attributes.variabletype ??= {};
+            const fieldVarType = xmlChild.attributes.variabletype.value;
+            if (typeof fieldVarType === 'string') {
+                block.fields[fieldName].variableType = fieldVarType;
+            }
+            break;
+        }
+        case 'comment':
+        {
+            block.comment = xmlChild.attributes.id.value;
+            break;
+        }
+        case 'value':
+        case 'statement':
+        {
+            // Recursively generate block structure for input block.
+            domToBlock(childBlockNode, blocks, false, block.id);
+            if (childShadowNode && childBlockNode !== childShadowNode) {
+                // Also generate the shadow block.
+                domToBlock(childShadowNode, blocks, false, block.id);
+            }
+            // Link this block's input to the child block.
+            const inputName = xmlChild.attributes.name.value;
+            block.inputs[inputName] = {
+                name: inputName,
+                block: childBlockNode.attributes.id.value,
+                shadow: childShadowNode ? childShadowNode.attributes.id.value : null
+            };
+            break;
+        }
+        case 'next':
+        {
+            if (!childBlockNode || !childBlockNode.attributes) {
+                // Invalid child block.
+                continue;
+            }
+            // Recursively generate block structure for next block.
+            domToBlock(childBlockNode, blocks, false, block.id);
+            // Link next block to this block.
+            block.next = childBlockNode.attributes.id.value;
+            break;
+        }
+        case 'mutation':
+        {
+            block.mutation = mutationAdapter(xmlChild);
+            break;
+        }
+        }
+    }
+};
+
+/**
+ * Convert outer blocks DOM from a Blockly CREATE event
+ * to a usable form for the Scratch runtime.
+ * This structure is based on Blockly xml.js:`domToWorkspace` and `domToBlock`.
+ * @param {Element} blocksDOM DOM tree for this event.
+ * @return {Array.<object>} Usable list of blocks from this CREATE event.
+ */
+const domToBlocks = function (blocksDOM) {
+    // At this level, there could be multiple blocks adjacent in the DOM tree.
+    const blocks = {};
+    for (let i = 0; i < blocksDOM.length; i++) {
+        const block = blocksDOM[i];
+
+        if (!block.tagName || !block.attributes) {
+            continue;
+        }
+        const tagName = block.tagName;
+        if (tagName === 'block' || tagName === 'shadow') {
+            domToBlock(block, blocks, true, null);
+        }
+    }
+    // Flatten blocks object into a list.
+    const blocksList = [];
+    for (const b in blocks) {
+        if (!blocks.hasOwnProperty(b)) continue;
+        blocksList.push(blocks[b]);
+    }
+    return blocksList;
+};
+
+/**
+ * Adapter between block creation events and block representation which can be
+ * used by the Scratch runtime.
+ * @param {object} e `Blockly.events.create` or `Blockly.events.endDrag`
+ * @return {Array.<object>} List of blocks from this CREATE event.
+ */
+const adapter = function (e) {
+    // Validate input
+    if (typeof e !== 'object') return;
+    if (typeof e.xml !== 'object') return;
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(e.xml.outerHTML, "application/xml");
+    return domToBlocks(doc.childNodes);
+};
+
+module.exports = adapter;

src/engine/block-utility.js

@@ -0,0 +1,261 @@
+const Thread = require('./thread');
+const Timer = require('../util/timer');
+
+/**
+ * @fileoverview
+ * Interface provided to block primitive functions for interacting with the
+ * runtime, thread, target, and convenient methods.
+ */
+
+class BlockUtility {
+    constructor (sequencer = null, thread = null) {
+        /**
+         * A sequencer block primitives use to branch or start procedures with
+         * @type {?Sequencer}
+         */
+        this.sequencer = sequencer;
+
+        /**
+         * The block primitives thread with the block's target, stackFrame and
+         * modifiable status.
+         * @type {?Thread}
+         */
+        this.thread = thread;
+
+        this._nowObj = {
+            now: () => this.sequencer.runtime.currentMSecs
+        };
+    }
+
+    /**
+     * The target the primitive is working on.
+     * @type {Target}
+     */
+    get target () {
+        return this.thread.target;
+    }
+
+    /**
+     * The runtime the block primitive is running in.
+     * @type {Runtime}
+     */
+    get runtime () {
+        return this.sequencer.runtime;
+    }
+
+    /**
+     * Use the runtime's currentMSecs value as a timestamp value for now
+     * This is useful in some cases where we need compatibility with Scratch 2
+     * @type {function}
+     */
+    get nowObj () {
+        if (this.runtime) {
+            return this._nowObj;
+        }
+        return null;
+    }
+
+    /**
+     * The stack frame used by loop and other blocks to track internal state.
+     * @type {object}
+     */
+    get stackFrame () {
+        const frame = this.thread.peekStackFrame();
+        if (frame.executionContext === null) {
+            frame.executionContext = {};
+        }
+        return frame.executionContext;
+    }
+
+    /**
+     * Check the stack timer and return a boolean based on whether it has finished or not.
+     * @return {boolean} - true if the stack timer has finished.
+     */
+    stackTimerFinished () {
+        const timeElapsed = this.stackFrame.timer.timeElapsed();
+        if (timeElapsed < this.stackFrame.duration) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Check if the stack timer needs initialization.
+     * @return {boolean} - true if the stack timer needs to be initialized.
+     */
+    stackTimerNeedsInit () {
+        return !this.stackFrame.timer;
+    }
+
+    /**
+     * Create and start a stack timer
+     * @param {number} duration - a duration in milliseconds to set the timer for.
+     */
+    startStackTimer (duration) {
+        if (this.nowObj) {
+            this.stackFrame.timer = new Timer(this.nowObj);
+        } else {
+            this.stackFrame.timer = new Timer();
+        }
+        this.stackFrame.timer.start();
+        this.stackFrame.duration = duration;
+    }
+
+    /**
+     * Set the thread to yield.
+     */
+    yield () {
+        this.thread.status = Thread.STATUS_YIELD;
+    }
+
+    /**
+     * pm: Set the thread to the running state.
+     */
+    defaultStatus () {
+        this.thread.status = Thread.STATUS_RUNNING;
+    }
+
+    /**
+     * Set the thread to yield until the next tick of the runtime.
+     */
+    yieldTick () {
+        this.thread.status = Thread.STATUS_YIELD_TICK;
+    }
+
+    /**
+     * Start a branch in the current block.
+     * @param {number} branchNum Which branch to step to (i.e., 1, 2).
+     * @param {boolean} isLoop Whether this block is a loop.
+     */
+    startBranch (branchNum, isLoop) {
+        this.sequencer.stepToBranch(this.thread, branchNum, isLoop);
+    }
+
+    /**
+     * Get the branch for a particular C-shaped block, and it's target.
+     * @param {string} id ID for block to get the branch for.
+     * @param {string} branchId Which branch to select (e.g. for if-else).
+     * @return {string} ID of block in the branch.
+     */
+    getBranchAndTarget (id, branchId) {
+        const result = this.thread.blockContainer.getBranch(id, branchId);
+        if (result) {
+            return [result, this.thread.target];
+        }
+        return this.sequencer.runtime.getBranchAndTarget(id, branchId);
+    }
+
+    /**
+     * Stop all threads.
+     */
+    stopAll () {
+        this.sequencer.runtime.stopAll();
+    }
+
+    /**
+     * Stop threads other on this target other than the thread holding the
+     * executed block.
+     */
+    stopOtherTargetThreads () {
+        this.sequencer.runtime.stopForTarget(this.thread.target, this.thread);
+    }
+
+    /**
+     * Stop this thread.
+     */
+    stopThisScript () {
+        this.thread.stopThisScript();
+    }
+
+    /**
+     * Start a specified procedure on this thread.
+     * @param {string} procedureCode Procedure code for procedure to start.
+     */
+    startProcedure (procedureCode) {
+        this.sequencer.stepToProcedure(this.thread, procedureCode);
+    }
+
+    /**
+     * Get names and ids of parameters for the given procedure.
+     * @param {string} procedureCode Procedure code for procedure to query.
+     * @return {Array.<string>} List of param names for a procedure.
+     */
+    getProcedureParamNamesAndIds (procedureCode) {
+        return this.thread.target.blocks.getProcedureParamNamesAndIds(procedureCode);
+    }
+
+    /**
+     * Get names, ids, and defaults of parameters for the given procedure.
+     * @param {string} procedureCode Procedure code for procedure to query.
+     * @return {Array.<string>} List of param names for a procedure.
+     */
+    getProcedureParamNamesIdsAndDefaults (procedureCode) {
+        return this.thread.target.blocks.getProcedureParamNamesIdsAndDefaults(procedureCode);
+    }
+
+    /**
+     * Initialize procedure parameters in the thread before pushing parameters.
+     */
+    initParams () {
+        this.thread.initParams();
+    }
+
+    /**
+     * Store a procedure parameter value by its name.
+     * @param {string} paramName The procedure's parameter name.
+     * @param {*} paramValue The procedure's parameter value.
+     */
+    pushParam (paramName, paramValue) {
+        this.thread.pushParam(paramName, paramValue);
+    }
+
+    /**
+     * Retrieve the stored parameter value for a given parameter name.
+     * @param {string} paramName The procedure's parameter name.
+     * @return {*} The parameter's current stored value.
+     */
+    getParam (paramName) {
+        return this.thread.getParam(paramName);
+    }
+
+    /**
+     * Start all relevant hats.
+     * @param {!string} requestedHat Opcode of hats to start.
+     * @param {object=} optMatchFields Optionally, fields to match on the hat.
+     * @param {Target=} optTarget Optionally, a target to restrict to.
+     * @return {Array.<Thread>} List of threads started by this function.
+     */
+    startHats (requestedHat, optMatchFields, optTarget) {
+        // Store thread and sequencer to ensure we can return to the calling block's context.
+        // startHats may execute further blocks and dirty the BlockUtility's execution context
+        // and confuse the calling block when we return to it.
+        const callerThread = this.thread;
+        const callerSequencer = this.sequencer;
+        const result = this.sequencer.runtime.startHats(requestedHat, optMatchFields, optTarget);
+
+        // Restore thread and sequencer to prior values before we return to the calling block.
+        this.thread = callerThread;
+        this.sequencer = callerSequencer;
+
+        return result;
+    }
+
+    /**
+     * Query a named IO device.
+     * @param {string} device The name of like the device, like keyboard.
+     * @param {string} func The name of the device's function to query.
+     * @param {Array.<*>} args Arguments to pass to the device's function.
+     * @return {*} The expected output for the device's function.
+     */
+    ioQuery (device, func, args) {
+        // Find the I/O device and execute the query/function call.
+        if (
+            this.sequencer.runtime.ioDevices[device] &&
+            this.sequencer.runtime.ioDevices[device][func]) {
+            const devObject = this.sequencer.runtime.ioDevices[device];
+            return devObject[func].apply(devObject, args);
+        }
+    }
+}
+
+module.exports = BlockUtility;

src/engine/blocks-execute-cache.js

@@ -0,0 +1,19 @@
+/**
+ * @fileoverview
+ * Access point for private method shared between blocks.js and execute.js for
+ * caching execute information.
+ */
+
+/**
+ * A private method shared with execute to build an object containing the block
+ * information execute needs and that is reset when other cached Blocks info is
+ * reset.
+ * @param {Blocks} blocks Blocks containing the expected blockId
+ * @param {string} blockId blockId for the desired execute cache
+ */
+exports.getCached = function () {
+    throw new Error('blocks.js has not initialized BlocksExecuteCache');
+};
+
+// Call after the default throwing getCached is assigned for Blocks to replace.
+require('./blocks');