mixio 1.10.0

blockly/.clang-format

@@ -0,0 +1,3 @@
+Language:        JavaScript
+BasedOnStyle:    Google
+ColumnLimit:     80

blockly/.eslintignore

@@ -0,0 +1,21 @@
+*_compressed*.js
+*_uncompressed*.js
+gulpfile.js
+/msg/*
+/dist/*
+/core/utils/global.js
+/tests/blocks/*
+/tests/themes/*
+/tests/compile/*
+/tests/jsunit/*
+/tests/generators/*
+/tests/mocha/run_mocha_tests_in_browser.js
+/tests/screenshot/*
+/tests/test_runner.js
+/tests/workspace_svg/*
+/generators/*
+/demos/*
+/appengine/*
+/externs/*
+/closure/*
+/scripts/gulpfiles/*

blockly/.eslintrc.json

@@ -0,0 +1,87 @@
+{
+    "rules": {
+        "curly": ["error"],
+        "eol-last": ["error"],
+        // Blockly/Google use 2-space indents.
+        // Blockly/Google uses +4 space indents for line continuations.
+        // Ignore default rules for ternary expressions.
+        "indent": [
+            "error", 2,
+            {
+                "SwitchCase": 1,
+                "MemberExpression": 2,
+                "ObjectExpression": 1,
+                "FunctionDeclaration": {
+                    "body": 1,
+                    "parameters": 2
+                },
+                "FunctionExpression": {
+                    "body": 1,
+                    "parameters": 2
+                },
+                "CallExpression": {
+                    "arguments": 2
+                },
+                "ignoredNodes": ["ConditionalExpression"]
+            }
+        ],
+        "keyword-spacing": ["error"],
+        "linebreak-style": ["error", "unix"],
+        "max-len": [
+            "error",
+            {
+                "code": 100,
+                "tabWidth": 4,
+                "ignoreStrings": true,
+                "ignoreRegExpLiterals": true,
+                "ignoreUrls": true
+            }
+        ],
+        "no-trailing-spaces": ["error", { "skipBlankLines": true }],
+        "no-unused-vars": [
+            "error",
+            {
+                "args": "after-used",
+                // Ignore vars starting with an underscore.
+                "varsIgnorePattern": "^_",
+                // Ignore arguments starting with an underscore.
+                "argsIgnorePattern": "^_"
+            }
+        ],
+        "no-use-before-define": ["error"],
+        // Blockly uses for exporting symbols. no-self-assign added in eslint 5.
+        "no-self-assign": ["off"],
+        // Blockly uses single quotes except for JSON blobs, which must use double quotes.
+        "quotes": ["off"],
+        "semi": ["error", "always"],
+        // Blockly doesn't have space before function paren when defining functions.
+        "space-before-function-paren": ["error", "never"],
+        // Blockly doesn't have space before function paren when calling functions.
+        "func-call-spacing": ["error", "never"],
+        "space-infix-ops": ["error"],
+        // Blockly uses 'use strict' in files.
+        "strict": ["off"],
+        // Closure style allows redeclarations.
+        "no-redeclare": ["off"],
+        "valid-jsdoc": ["error", {"requireReturn": false}],
+        "no-console": ["off"],
+        "no-multi-spaces": ["error", { "ignoreEOLComments": true }],
+        "operator-linebreak": ["error", "after"],
+        "spaced-comment": ["error", "always", {
+            "block": {
+                "balanced": true
+            },
+            "exceptions": ["*"]
+        }]
+    },
+    "env": {
+        "browser": true
+    },
+    "globals": {
+        "Blockly": true,
+        "goog": true
+    },
+    "extends": [
+        "eslint:recommended"
+    ]
+}

blockly/.github/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing to Blockly
+
+Want to contribute? Great!
+- First, read this page (including the small print at the end).
+- Second, please make pull requests against develop, not master. If your patch
+  needs to go into master immediately, include a note in your PR.
+
+For more information on style guide and other details, head over to the [Blockly Developers site](https://developers.google.com/blockly/guides/modify/contributing).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement](https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+
+### Larger changes
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use Github pull requests for this purpose.
+
+### Browser compatibility
+We care strongly about making Blockly work on all browsers.  As of 2017 we 
+support IE 10 and 11, Edge, Chrome, Safari, and Firefox.  We will not accept
+changes that only work on a subset of those browsers.  You can check [caniuse.com](https://caniuse.com/) 
+for compatibility information.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement](https://cla.developers.google.com/about/google-corporate).

blockly/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,65 @@
+---
+name: Bug Report
+about: Create a report to help us improve
+labels: 'type: bug, triage'
+assignees: ''
+
+---
+
+<!--
+  - Thanks for opening an issue for us!  Before you open an issue,
+  - please check if a similar issue exists or has been closed before.
+  -
+  - If you're asking a question about how to use Blockly in your application,
+  - please ask questions on the mailing list, instead of filing issues:
+  -       https://groups.google.com/forum/#!forum/blockly
+  -->
+
+**Describe the bug**
+
+<!-- A clear and concise description of what the bug is. -->
+
+**To Reproduce**
+
+<!-- Explain what someone needs to do in order to see what's described above -->
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+
+<!-- A clear and concise description of what you expected to happen. -->
+
+**Screenshots**
+
+<!-- If applicable, add screenshots to help explain your problem. -->
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Stack Traces**
+
+<!-- Please open up the console.  If you see any Blockly-related errors,
+  -        paste them between the quotes below.
+  -
+  - Ignore any instances of...
+  - "Uncaught (in promise) DOMException: The play() request was interrupted by a call to pause()."
+  -->
+
+```
+Replace with error stack trace.
+```
+
+**Additional context**
+
+<!-- Add any other context about the problem here. -->

blockly/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,7 @@
+contact_links:
+  - name: Blockly Forum
+    url: https://groups.google.com/forum/#!forum/blockly
+    about: The Blockly developer forum, where you can ask and answer questions.
+  - name: Plugins and examples
+    url: https://github.com/google/blockly-samples/issues/new/choose
+    about: File bugs or feature requests about plugins and samples in our blockly-samples repository.

blockly/.github/ISSUE_TEMPLATE/documentation.md

@@ -0,0 +1,44 @@
+---
+name: Documentation
+about: Report an issue with our documentation
+labels: 'type: documentation, triage'
+assignees: ''
+
+---
+
+<!--
+  - Thanks for helping us improve our developer site documentation!
+  - Use this template to describe issues with the content at
+  - developers.google.com/blockly/guides
+  -->
+
+**Where**
+
+<!-- A link to the page with the documentation you want us to update.
+  -  More specific is better.  If no page exists, describe what the page
+  -  should be, and where.
+  -->
+
+**What**
+
+<!-- What kind of content is it? 
+  -  Check a box with an 'x' between the brackets: [x] 
+  -->
+  
+- [ ] Text
+- [ ] Image or Gif
+- [ ] Other
+
+**Old content**
+
+<!-- What the documentation currently says -->
+
+**Suggested content**
+
+<!-- Your suggestion for improved documentation -->
+
+**Additional context**
+
+<!-- Add any other context about the problem here. 
+  -  If this is related to a specific pull request, link to it.
+  -->

blockly/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,23 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+labels: 'type: feature request, triage'
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+
+<!-- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->
+
+**Describe the solution you'd like**
+
+<!-- A clear and concise description of what you want to happen. -->
+
+**Describe alternatives you've considered**
+
+<!-- A clear and concise description of any alternative solutions or features you've considered. -->
+
+**Additional context**
+
+<!-- Add any other context or screenshots about the feature request here. -->

blockly/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,67 @@
+<!--
+  - Thanks for submitting code to Blockly!  Please fill out the following as part of
+  - your pull request so we can review your code more easily.
+  -->
+
+## The basics
+
+<!-- TODO: Verify the following, checking each box with an 'x' between the brackets: [x] -->
+
+- [ ] I branched from develop
+- [ ] My pull request is against develop
+- [ ] My code follows the [style guide](https://developers.google.com/blockly/guides/modify/web/style-guide)
+
+## The details
+### Resolves
+
+<!-- TODO: What Github issue does this resolve? Please include a link. -->
+
+### Proposed Changes
+
+<!-- TODO: Describe what this Pull Request does.  Include screenshots if applicable. -->
+
+#### Behavior Before Change
+
+<!--TODO: Image, gif or explanation of behavior before this pull request. -->
+
+#### Behavior After Change
+
+<!--TODO: Image, gif or explanation of behavior after this pull request. -->
+
+### Reason for Changes
+
+<!--TODO: Explain why these changes should be made.  Include screenshots if applicable. -->
+
+### Test Coverage
+
+<!-- TODO: Please show how you have added tests to cover your changes,
+  -        or tell us how you tested it. For each systems you tested,
+  -        uncomment the systems in the list below.
+  -->
+
+<!-- Tested on: -->
+<!-- * Desktop Chrome -->
+<!-- * Desktop Firefox -->
+<!-- * Desktop Safari -->
+<!-- * Desktop Opera -->
+<!-- * Windows Internet Explorer 10 -->
+<!-- * Windows Internet Explorer 11 -->
+<!-- * Windows Edge -->
+
+<!--
+* Smartphone/Tablet/Chromebook (please complete the following information):
+  * Device: [e.g. iPhone6]
+  * OS: [e.g. iOS8.1]
+  * Browser [e.g. stock browser, safari]
+  * Version [e.g. 22]
+-->
+
+### Documentation
+
+<!-- TODO: Does any documentation need to be created or updated because of this PR?
+  -        If so please explain.
+  -->
+
+### Additional Information
+
+<!-- Anything else we should know? -->

blockly/.github/PULL_REQUEST_TEMPLATE/goog_module.md

@@ -0,0 +1,24 @@
+<!-- Suggested PR title: Migrate PATH/TO/FILE.js to goog.module syntax -->
+
+## The basics
+
+- [ ] I branched from `goog_module`
+- [ ] My pull request is against `goog_module`
+- [ ] My code follows the [style guide](
+      https://developers.google.com/blockly/guides/modify/web/style-guide)
+- [ ] My code is presented in the form suggested in the [module
+      conversion guide](https://github.com/google/blockly/issues/5026)
+- [ ] I have run `npm test`.
+
+## The details
+### Resolves
+
+Part of #5026
+
+### Proposed Changes
+
+Converts `PATH/TO/FILE.js` to `goog.module` with ES6 `const`/`let`.
+
+### Additional Information
+
+<!-- Anything else we should know? -->

blockly/.github/dependabot.yml

@@ -0,0 +1,23 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    target-branch: "develop"
+    schedule:
+      interval: "weekly"
+    ignore:
+      - dependency-name: "jsdom"
+        # For jsdom, ignore all updates for version 16.
+        # We should test that this does not cause issue 
+        # google/blockly-samples#665 when version 17 is released.
+        versions: "16.x"
+    commit-message:
+      prefix: "chore(deps)"
+    labels:
+      - "PR: chore"
+      - "PR: dependencies"

blockly/.github/release.yml

@@ -0,0 +1,26 @@
+# release.yml
+
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+    authors:
+      - dependabot
+  categories:
+    - title: Breaking Changes 🛠
+      labels:
+        - breaking change
+    - title: New Features
+      labels:
+        - "PR: feature"
+    - title: Bug fixes
+      labels:
+        - "PR: fix"
+    - title: Cleanup ♻️
+      labels:
+        - "PR: chore"
+        - "PR: docs"
+        - "PR: refactor"
+    - title: Other Changes
+      labels:
+        - "*"

blockly/.github/workflows/appengine_deploy.yml

@@ -0,0 +1,54 @@
+# Workflow that prepares files and deploys to appengine
+
+name: Deploy to App Engine
+
+# Controls when the workflow will run
+on:
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  prepare:
+    name: Prepare
+    runs-on: ubuntu-latest
+
+    steps:
+      # Checks-out the repository under $GITHUB_WORKSPACE.
+      # When running manually this checks out the master branch.
+      - uses: actions/checkout@v2
+
+      - name: Prepare demo files
+        # Install all dependencies, then copy all the files needed for demos.
+        run: |
+          npm install
+          npm run prepareDemos
+
+      - name: Upload
+        uses: actions/upload-artifact@v2
+        with:
+          name: appengine_files
+          path: _deploy/
+
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+    # The prepare step must succeed for this step to run.
+    needs: prepare
+    steps:
+      - name: Download prepared files
+        uses: actions/download-artifact@v2
+        with:
+          name: appengine_files
+          path: _deploy/
+
+      - name: Deploy to App Engine
+        uses: google-github-actions/deploy-appengine@v0.2.0
+        # For parameters see:
+        # https://github.com/google-github-actions/deploy-appengine#inputs
+        with:
+          working_directory: _deploy/
+          deliverables: app.yaml
+          project_id: ${{ secrets.GCP_PROJECT }}
+          credentials: ${{ secrets.GCP_SA_KEY }}
+          promote: false
+          version: vtest

blockly/.github/workflows/build.yml

@@ -0,0 +1,43 @@
+# This workflow will do a clean install, start the selenium server, and run
+# all of our tests.
+
+name: Node.js CI
+
+on: [pull_request]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        # TODO (#2114): re-enable osx build.
+        # os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest]
+        node-version: [10.x, 12.x, 14.x, 16.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Npm Install
+      run: npm install
+
+    - name: Linux Test Setup
+      if: runner.os == 'Linux'
+      run: source ./tests/scripts/setup_linux_env.sh
+
+    - name: MacOS Test Setup
+      if: runner.os == 'macOS'
+      run: source ./tests/scripts/setup_osx_env.sh
+
+    - name: Run
+      run: npm run test
+
+      env:
+        CI: true

blockly/.gitignore

@@ -0,0 +1,20 @@
+node_modules
+npm-debug.log
+build-debug.log
+.DS_Store
+.settings
+.project
+*.gz
+*.pyc
+*.komodoproject
+/nbproject/private/
+
+tests/compile/main_compressed.js
+tests/compile/main_compressed.js.map
+tests/compile/*compiler*.jar
+tests/screenshot/outputs/*
+local_build/*compiler*.jar
+local_build/local_*_compressed.js
+chromedriver
+typings/tmp/*
+dist/

blockly/.npmrc

@@ -0,0 +1 @@
+registry=https://registry.npmjs.org/

blockly/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

blockly/README.md

@@ -0,0 +1,88 @@
+# Blockly [![Build Status]( https://travis-ci.org/google/blockly.svg?branch=master)](https://travis-ci.org/google/blockly)
+
+Google's Blockly is a library that adds a visual code editor to web and mobile apps. The Blockly editor uses interlocking, graphical blocks to represent code concepts like variables, logical expressions, loops, and more. It allows users to apply programming principles without having to worry about syntax or the intimidation of a blinking cursor on the command line.  All code is free and open source.
+
+![](https://developers.google.com/blockly/images/sample.png)
+
+## Getting Started with Blockly
+
+Blockly has many resources for learning how to use the library. Start at our [Google Developers Site](https://developers.google.com/blockly) to read the documentation on how to get started, configure Blockly, and integrate it into your application. The developers site also contains links to:
+
+* [Getting Started article](https://developers.google.com/blockly/guides/get-started/web)
+* [Getting Started codelab](https://blocklycodelabs.dev/codelabs/getting-started/index.html#0)
+* [More codelabs](https://blocklycodelabs.dev/)
+* [Demos and plugins](https://google.github.io/blockly-samples/)
+
+Help us focus our development efforts by telling us [what you are doing with
+Blockly](https://developers.google.com/blockly/registration).  The questionnaire only takes
+a few minutes and will help us better support the Blockly community.
+
+### Installing Blockly
+
+Blockly is [available on npm](https://www.npmjs.com/package/blockly).
+
+```bash
+npm install blockly
+```
+
+For more information on installing and using Blockly, see the [Getting Started article](https://developers.google.com/blockly/guides/get-started/web).
+
+### Getting Help
+* [Report a bug](https://developers.google.com/blockly/guides/modify/contribute/write_a_good_issue) or file a feature request on GitHub
+* Ask a question, or search others' questions, on our [developer forum](https://groups.google.com/forum/#!forum/blockly). You can also drop by to say hello and show us your prototypes; collectively we have a lot of experience and can offer hints which will save you time. We actively monitor the forums and typically respond to questions within 2 working days.
+
+### blockly-samples
+
+We have a number of resources such as example code, demos, and plugins in another repository called [blockly-samples](https://github.com/google/blockly-samples/). A plugin is a self-contained piece of code that adds functionality to Blockly. Plugins can add fields, define themes, create renderers, and much more. For more information, see the [Plugins documentation](https://developers.google.com/blockly/guides/plugins/overview).
+
+## Contributing to Blockly
+
+Want to make Blockly better? We welcome contributions to Blockly in the form of pull requests, bug reports, documentation, answers on the forum, and more! Check out our [Contributing Guidelines](https://developers.google.com/blockly/guides/modify/contributing) for more information. You might also want to look for issues tagged "[Help Wanted](https://github.com/google/blockly/labels/help%20wanted)" which are issues we think would be great for external contributors to help with.
+
+## Releases
+
+The next major release will be **September 30th, 2021**.
+
+We release by pushing the latest code to the master branch, followed by updating the npm package, our [docs](https://developers.google.com/blockly), and [demo pages](https://google.github.io/blockly-samples/). We typically release a new version of Blockly once a quarter (every 3 months). If there are breaking bugs, such as a crash when performing a standard action or a rendering issue that makes Blockly unusable, we will cherry-pick fixes to master between releases to fix them. The [releases page](https://github.com/google/blockly/releases) has a list of all releases.
+
+Releases are tagged by the release date (YYYYMMDD) with a leading '4.' and a trailing '.0' in case we ever need a major or patch version (such as [2.20190722.1](https://github.com/google/blockly/tree/2.20190722.1)). Releases that have breaking changes or are otherwise not backwards compatible will have a new major version. Patch versions are reserved for bug-fix patches between scheduled releases.
+
+We now have a [beta release on npm](https://www.npmjs.com/package/blockly?activeTab=versions). If you'd like to test the upcoming release, or try out a not-yet-released new API, you can use the beta channel with:
+
+```bash
+npm install blockly@beta
+```
+As it is a beta channel, it may be less stable, and the APIs there are subject to change.
+
+### Branches
+
+There are two main branches for Blockly.
+
+**[master](https://github.com/google/blockly)** - This is the (mostly) stable current release of Blockly.
+
+**[develop](https://github.com/google/blockly/tree/develop)** - This is where most of our work happens. Pull requests should always be made against develop. This branch will generally be usable, but may be less stable than the master branch. Once something is in develop we expect it to merge to master in the next release.
+
+**other branches:** - Larger changes may have their own branches until they are good enough for people to try out. These will be developed separately until we think they are almost ready for release. These branches typically get merged into develop immediately after a release to allow extra time for testing.
+
+### New APIs
+
+Once a new API is merged into master it is considered beta until the following release. We generally try to avoid changing an API after it has been merged to master, but sometimes we need to make changes after seeing how an API is used. If an API has been around for at least two releases we'll do our best to avoid breaking it.
+
+Unreleased APIs may change radically. Anything that is in `develop` but not `master` is subject to change without warning.
+
+## Issues and Milestones
+
+We typically triage all bugs within 2 working days, which includes adding any appropriate labels and assigning it to a milestone. Please keep in mind, we are a small team so even feature requests that everyone agrees on may not be prioritized.
+
+### Milestones
+
+**Upcoming release** - The upcoming release milestone is for all bugs we plan on fixing before the next release. This typically has the form of `year_quarter_release` (such as `2019_q2_release`). Some bugs will be added to this release when they are triaged, others may be added closer to a release.
+
+**Bug Bash Backlog** - These are bugs that we're still prioritizing. They haven't been added to a specific release yet, but we'll consider them for each release depending on relative priority and available time.
+
+**Icebox** - These are bugs that we do not intend to spend time on. They are either too much work or minor enough that we don't expect them to ever take priority. We are still happy to accept pull requests for these bugs.
+
+## Good to Know
+
+* Cross-browser Testing Platform and Open Source <3 Provided by [Sauce Labs](https://saucelabs.com)
+* We support IE11 and test it using [BrowserStack](https://browserstack.com)

blockly/appengine/.gcloudignore

@@ -0,0 +1,20 @@
+# Do not upload these files.
+.*
+*.soy
+*.komodoproject
+deploy
+/static/appengine/
+/static/demos/plane/soy/*.jar
+/static/demos/plane/xlf/
+/static/externs/
+/static/msg/json/
+/static/scripts/
+/static/typings/
+
+/static/eslintrc.json
+/static/gulpfile.js
+/static/jsconfig.json
+/static/LICENSE
+/static/package-lock.json
+/static/package.json
+/static/README.md

blockly/appengine/README.txt

@@ -0,0 +1,42 @@
+
+  Running an App Engine server
+
+This directory contains the files needed to setup the optional Blockly server.
+Although Blockly itself is 100% client-side, the server enables cloud storage
+and sharing.  Store your programs in Datastore and get a unique URL that allows
+you to load the program on any computer.
+
+To run your own App Engine instance you'll need to create this directory
+structure:
+
+blockly/
+ |- app.yaml
+ |- deploy
+ |- index.yaml
+ |- main.py
+ |- README.txt
+ |- requirements.txt
+ |- storage.js
+ |- storage.py
+ `- static/
+     |- blocks/
+     |- core/
+     |- demos/
+     |- generators/
+     |- media/
+     |- msg/
+     |- tests/
+     |- blockly_compressed.js
+     |- blockly_uncompressed.js
+     |- blocks_compressed.js
+     |- dart_compressed.js
+     |- javascript_compressed.js
+     |- lua_compressed.js
+     |- php_compressed.js
+     `- python_compressed.js
+
+Go to https://appengine.google.com/ and create your App Engine application.
+Modify the 'PROJECT' name in the 'deploy' file to your App Engine application name.
+
+Finally, upload this directory structure to your App Engine account,
+then go to http://YOURAPPNAME.appspot.com/

blockly/appengine/add_timestamps.py

@@ -0,0 +1,69 @@
+"""Blockly Demo: Add timestamps
+
+Copyright 2020 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""A script to get all Xml entries in the datastore for Blockly demos
+and reinsert any that do not have a last_accessed time.
+
+This script should only need to be run once, but may take a long time
+to complete.
+
+NDB does not provide a way to query for all entities that are missing a
+given property, so we have to get all of them and discard any that
+already have a last_accessed time.
+
+Auth: `gcloud auth login`
+
+Set the correct project: `gcloud config set project blockly-demo`
+
+See the current project: `gcloud config get-value project`
+
+Start a venv: `python3 -m venv venv && source venv/bin/activate`
+Inside your vm run `pip install google-cloud-ndb`
+Run the script: `python add_timestamps.py`
+"""
+
+__author__ = "fenichel@google.com (Rachel Fenichel)"
+
+
+from google.cloud import ndb
+from storage import Xml
+import datetime
+
+PAGE_SIZE = 1000
+
+def handle_results(results):
+  for x in results:
+    if (x.last_accessed is None):
+      x.put()
+
+def run_query():
+  client = ndb.Client()
+  with client.context():
+    query = Xml.query()
+    print(f'Total entries: {query.count()}')
+    cursor = None
+    more = True
+    page_count = 0
+    result_count = 0
+    while more:
+      results, cursor, more = query.fetch_page(PAGE_SIZE, start_cursor=cursor)
+      handle_results(results)
+      page_count = page_count + 1
+      result_count = result_count + len(results)
+      print(f'{datetime.datetime.now().strftime("%I:%M:%S %p")} : page {page_count} : {result_count}')
+
+run_query()

blockly/appengine/app.yaml

@@ -0,0 +1,53 @@
+runtime: python37
+
+handlers:
+# Redirect obsolete URLs.
+# Blockly files moved from /blockly to /static on 5 Dec 2012.
+- url: /blockly/.*
+  static_files: redirect.html
+  upload: redirect.html
+# Code, Maze and Turtle moved from demos on 29 Dec 2012.
+- url: /static/demos/(maze|turtle)/.*
+  static_files: redirect.html
+  upload: redirect.html
+# Apps was disbanded on 20 Nov 2014.
+- url: /static/apps/.*
+  static_files: redirect.html
+  upload: redirect.html
+
+# Blockly files.
+- url: /static
+  static_dir: static
+  secure: always
+
+# Storage API.
+- url: /storage\.js
+  static_files: storage.js
+  upload: storage\.js
+  secure: always
+
+# Favicon.
+- url: /favicon\.ico
+  static_files: favicon.ico
+  upload: favicon\.ico
+  secure: always
+  expiration: "30d"
+
+# Apple icon.
+- url: /apple-touch-icon\.png
+  static_files: apple-touch-icon.png
+  upload: apple-touch-icon\.png
+  secure: always
+  expiration: "30d"
+
+# robot.txt
+- url: /robots\.txt
+  static_files: robots.txt
+  upload: robots\.txt
+  secure: always
+
+# Dynamic content.
+- url: /.*
+  script: auto
+  secure: always
+  

blockly/appengine/expiration.py

@@ -0,0 +1,51 @@
+"""
+Copyright 2020 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""Delete expired XML.
+"""
+
+__author__ = "fenichel@google.com (Rachel Fenichel)"
+
+
+import storage
+import datetime
+
+from google.cloud import ndb
+
+
+EXPIRATION_DAYS = 365
+# Limit the query to avoid timeouts.
+QUERY_LIMIT = 1000
+
+def delete_expired():
+  """Deletes entries that have not been accessed in more than a year."""
+  bestBefore = datetime.datetime.utcnow() - datetime.timedelta(days=EXPIRATION_DAYS)
+  client = ndb.Client()
+  with client.context():
+    query = storage.Xml.query(storage.Xml.last_accessed < bestBefore)
+    results = query.fetch(limit=QUERY_LIMIT, keys_only=True)
+    for x in results:
+      x.delete()
+
+
+def app(environ, start_response):
+  out = ""
+  headers = [
+    ("Content-Type", "text/plain")
+  ]
+  start_response("200 OK", headers)
+  delete_expired()
+  return [out.encode("utf-8")]

blockly/appengine/index.yaml

@@ -0,0 +1,11 @@
+indexes:
+
+# AUTOGENERATED
+
+# This index.yaml is automatically updated whenever the dev_appserver
+# detects that a new type of query is run.  If you want to manage the
+# index.yaml file manually, remove the above marker line (the line
+# saying "# AUTOGENERATED").  If you want to manage some indexes
+# manually, move them above the marker line.  The index.yaml file is
+# automatically uploaded to the admin console when you next deploy
+# your application using appcfg.py.

blockly/appengine/main.py

@@ -0,0 +1,39 @@
+"""
+Copyright 2020 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import storage
+import expiration
+
+
+# Route to requested handler.
+def app(environ, start_response):
+  if environ["PATH_INFO"] == "/":
+    return redirect(environ, start_response)
+  if environ["PATH_INFO"] == "/storage":
+    return storage.app(environ, start_response)
+  if environ["PATH_INFO"] == "/expiration":
+    return expiration.app(environ, start_response)
+  start_response("404 Not Found", [])
+  return [b"Page not found."]
+
+
+# Redirect for root directory.
+def redirect(environ, start_response):
+  headers = [
+    ("Location", "static/demos/index.html")
+  ]
+  start_response("301 Found", headers)
+  return []

blockly/appengine/redirect.html

@@ -0,0 +1,68 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <script>
+var loc = location.href;
+
+// Blockly files moved from /blockly to /static on 5 Dec 2012.
+if (loc.match('/blockly/')) {
+  loc = loc.replace('/blockly/', '/static/');
+}
+
+// Maze and Turtle moved from demos to apps on 29 Dec 2012.
+if (loc.match(/\/demos\/(maze|turtle)\//)) {
+  loc = loc.replace('/demos/', '/apps/');
+}
+
+// Vietnamese apps moved from vn to vi on 9 Jun 2012.
+if (loc.match('/vn.html')) {
+  loc = loc.replace('/vn.html', '/vi.html');
+}
+
+if (loc.match('/code/code.html')) {
+  // Code moved to index.html on 7 Aug 2013.
+  loc = loc.replace('/code.html', '/index.html');
+} else if (loc.match('/apps/code/zh_tw.html')) {
+  // zh-tw was changed to zh-hans on 25 Nov 2013.
+  loc = loc.replace('/zh_tw.html', '/index.html?lang=zh-hans');
+} else if (loc.match('/apps/code/index.html')) {
+  // NOP.
+} else if (loc.match(/\/apps\/code\/[-a-z]+\.html/)) {
+  // Code became language-agnostic on 20 Jul 2013.
+  loc = loc.replace(/\/([-a-z]+)\.html/, '/index.html?lang=$1');
+}
+
+if (loc.match('/apps/plane/plane.html')) {
+  // Plane moved to index.html on 7 Aug 2013.
+  loc = loc.replace('/plane.html', '/index.html');
+} else if (loc.match('/apps/code/plane.html')) {
+  // NOP.
+} else if (loc.match(/\/apps\/plane\/[\d_]*[-a-z]+\.html/)) {
+  // Plane became language-agnostic on 20 Jul 2013.
+  loc = loc.replace('vn.html', 'vi.html');
+  if (location.search) {
+    loc = loc.replace(/\/[\d_]*([-a-z]+)\.html\?/, '/index.html?lang=$1&');
+  } else {
+    loc = loc.replace(/\/[\d_]*([-a-z]+)\.html/, '/index.html?lang=$1');
+  }
+}
+
+if (loc.match('/apps/puzzle/')) {
+  // Puzzle moved to Blockly Games on 15 Oct 2014.
+  loc = 'https://blockly.games/puzzle';
+} else if (loc.match('/apps/maze/')) {
+  // Maze moved to Blockly Games on 10 Nov 2014.
+  loc = 'https://blockly.games/maze';
+} else if (loc.match('/apps/turtle/')) {
+  // Turtle moved to Blockly Games on 10 Nov 2014.
+  loc = 'https://blockly.games/turtle';
+} else if (loc.match('/apps/')) {
+  // Remaining apps moved to demos on 20 Nov 2014.
+  loc = loc.replace('/apps/', '/demos/');
+}
+
+location = loc;
+
+    </script>
+  </head>
+</html>

blockly/appengine/requirements.txt

@@ -0,0 +1 @@
+google-cloud-ndb

blockly/appengine/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /storage

blockly/appengine/storage.js

@@ -0,0 +1,189 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Loading and saving blocks with localStorage and cloud storage.
+ * @author q.neutron@gmail.com (Quynh Neutron)
+ */
+'use strict';
+
+// Create a namespace.
+var BlocklyStorage = {};
+
+/**
+ * Backup code blocks to localStorage.
+ * @param {!Blockly.WorkspaceSvg} workspace Workspace.
+ * @private
+ */
+BlocklyStorage.backupBlocks_ = function(workspace) {
+  if ('localStorage' in window) {
+    var xml = Blockly.Xml.workspaceToDom(workspace);
+    // Gets the current URL, not including the hash.
+    var url = window.location.href.split('#')[0];
+    window.localStorage.setItem(url, Blockly.Xml.domToText(xml));
+  }
+};
+
+/**
+ * Bind the localStorage backup function to the unload event.
+ * @param {Blockly.WorkspaceSvg=} opt_workspace Workspace.
+ */
+BlocklyStorage.backupOnUnload = function(opt_workspace) {
+  var workspace = opt_workspace || Blockly.getMainWorkspace();
+  window.addEventListener('unload',
+      function() {BlocklyStorage.backupBlocks_(workspace);}, false);
+};
+
+/**
+ * Restore code blocks from localStorage.
+ * @param {Blockly.WorkspaceSvg=} opt_workspace Workspace.
+ */
+BlocklyStorage.restoreBlocks = function(opt_workspace) {
+  var url = window.location.href.split('#')[0];
+  if ('localStorage' in window && window.localStorage[url]) {
+    var workspace = opt_workspace || Blockly.getMainWorkspace();
+    var xml = Blockly.Xml.textToDom(window.localStorage[url]);
+    Blockly.Xml.domToWorkspace(xml, workspace);
+  }
+};
+
+/**
+ * Save blocks to database and return a link containing key to XML.
+ * @param {Blockly.WorkspaceSvg=} opt_workspace Workspace.
+ */
+BlocklyStorage.link = function(opt_workspace) {
+  var workspace = opt_workspace || Blockly.getMainWorkspace();
+  var xml = Blockly.Xml.workspaceToDom(workspace, true);
+  // Remove x/y coordinates from XML if there's only one block stack.
+  // There's no reason to store this, removing it helps with anonymity.
+  if (workspace.getTopBlocks(false).length == 1 && xml.querySelector) {
+    var block = xml.querySelector('block');
+    if (block) {
+      block.removeAttribute('x');
+      block.removeAttribute('y');
+    }
+  }
+  var data = Blockly.Xml.domToText(xml);
+  BlocklyStorage.makeRequest_('/storage', 'xml', data, workspace);
+};
+
+/**
+ * Retrieve XML text from database using given key.
+ * @param {string} key Key to XML, obtained from href.
+ * @param {Blockly.WorkspaceSvg=} opt_workspace Workspace.
+ */
+BlocklyStorage.retrieveXml = function(key, opt_workspace) {
+  var workspace = opt_workspace || Blockly.getMainWorkspace();
+  BlocklyStorage.makeRequest_('/storage', 'key', key, workspace);
+};
+
+/**
+ * Global reference to current AJAX request.
+ * @type {XMLHttpRequest}
+ * @private
+ */
+BlocklyStorage.httpRequest_ = null;
+
+/**
+ * Fire a new AJAX request.
+ * @param {string} url URL to fetch.
+ * @param {string} name Name of parameter.
+ * @param {string} content Content of parameter.
+ * @param {!Blockly.WorkspaceSvg} workspace Workspace.
+ * @private
+ */
+BlocklyStorage.makeRequest_ = function(url, name, content, workspace) {
+  if (BlocklyStorage.httpRequest_) {
+    // AJAX call is in-flight.
+    BlocklyStorage.httpRequest_.abort();
+  }
+  BlocklyStorage.httpRequest_ = new XMLHttpRequest();
+  BlocklyStorage.httpRequest_.name = name;
+  BlocklyStorage.httpRequest_.onreadystatechange =
+      BlocklyStorage.handleRequest_;
+  BlocklyStorage.httpRequest_.open('POST', url);
+  BlocklyStorage.httpRequest_.setRequestHeader('Content-Type',
+      'application/x-www-form-urlencoded');
+  BlocklyStorage.httpRequest_.send(name + '=' + encodeURIComponent(content));
+  BlocklyStorage.httpRequest_.workspace = workspace;
+};
+
+/**
+ * Callback function for AJAX call.
+ * @private
+ */
+BlocklyStorage.handleRequest_ = function() {
+  if (BlocklyStorage.httpRequest_.readyState == 4) {
+    if (BlocklyStorage.httpRequest_.status != 200) {
+      BlocklyStorage.alert(BlocklyStorage.HTTPREQUEST_ERROR + '\n' +
+          'httpRequest_.status: ' + BlocklyStorage.httpRequest_.status);
+    } else {
+      var data = BlocklyStorage.httpRequest_.responseText.trim();
+      if (BlocklyStorage.httpRequest_.name == 'xml') {
+        window.location.hash = data;
+        BlocklyStorage.alert(BlocklyStorage.LINK_ALERT.replace('%1',
+            window.location.href));
+      } else if (BlocklyStorage.httpRequest_.name == 'key') {
+        if (!data.length) {
+          BlocklyStorage.alert(BlocklyStorage.HASH_ERROR.replace('%1',
+              window.location.hash));
+        } else {
+          BlocklyStorage.loadXml_(data, BlocklyStorage.httpRequest_.workspace);
+        }
+      }
+      BlocklyStorage.monitorChanges_(BlocklyStorage.httpRequest_.workspace);
+    }
+    BlocklyStorage.httpRequest_ = null;
+  }
+};
+
+/**
+ * Start monitoring the workspace.  If a change is made that changes the XML,
+ * clear the key from the URL.  Stop monitoring the workspace once such a
+ * change is detected.
+ * @param {!Blockly.WorkspaceSvg} workspace Workspace.
+ * @private
+ */
+BlocklyStorage.monitorChanges_ = function(workspace) {
+  var startXmlDom = Blockly.Xml.workspaceToDom(workspace);
+  var startXmlText = Blockly.Xml.domToText(startXmlDom);
+  function change() {
+    var xmlDom = Blockly.Xml.workspaceToDom(workspace);
+    var xmlText = Blockly.Xml.domToText(xmlDom);
+    if (startXmlText != xmlText) {
+      window.location.hash = '';
+      workspace.removeChangeListener(change);
+    }
+  }
+  workspace.addChangeListener(change);
+};
+
+/**
+ * Load blocks from XML.
+ * @param {string} xml Text representation of XML.
+ * @param {!Blockly.WorkspaceSvg} workspace Workspace.
+ * @private
+ */
+BlocklyStorage.loadXml_ = function(xml, workspace) {
+  try {
+    xml = Blockly.Xml.textToDom(xml);
+  } catch (e) {
+    BlocklyStorage.alert(BlocklyStorage.XML_ERROR + '\nXML: ' + xml);
+    return;
+  }
+  // Clear the workspace to avoid merge.
+  workspace.clear();
+  Blockly.Xml.domToWorkspace(xml, workspace);
+};
+
+/**
+ * Present a text message to the user.
+ * Designed to be overridden if an app has custom dialogs, or a butter bar.
+ * @param {string} message Text to alert.
+ */
+BlocklyStorage.alert = function(message) {
+  window.alert(message);
+};

blockly/appengine/storage.py

@@ -0,0 +1,99 @@
+"""Blockly Demo: Storage
+
+Copyright 2012 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""Store and retrieve XML with App Engine.
+"""
+
+__author__ = "q.neutron@gmail.com (Quynh Neutron)"
+
+import cgi
+import hashlib
+from random import randint
+from google.cloud import ndb
+
+
+class Xml(ndb.Model):
+  # A row in the database.
+  xml_hash = ndb.IntegerProperty()
+  xml_content = ndb.TextProperty()
+  last_accessed = ndb.DateTimeProperty(auto_now=True)
+
+def keyGen():
+  # Generate a random string of length KEY_LEN.
+  KEY_LEN = 6
+  CHARS = "abcdefghijkmnopqrstuvwxyz23456789"  # Exclude l, 0, 1.
+  max_index = len(CHARS) - 1
+  return "".join([CHARS[randint(0, max_index)] for x in range(KEY_LEN)])
+
+
+def xmlToKey(xml_content):
+  # Store XML and return a generated key.
+  xml_hash = int(hashlib.sha1(xml_content.encode("utf-8")).hexdigest(), 16)
+  xml_hash = int(xml_hash % (2 ** 64) - (2 ** 63))
+  lookup_query = Xml.query(Xml.xml_hash == xml_hash)
+  client = ndb.Client()
+  with client.context():
+    lookup_result = lookup_query.get()
+    if lookup_result:
+      xml_key = lookup_result.key.string_id()
+    else:
+      trials = 0
+      result = True
+      while result:
+        trials += 1
+        if trials == 100:
+          raise Exception("Sorry, the generator failed to get a key for you.")
+        xml_key = keyGen()
+        result = Xml.get_by_id(xml_key)
+      row = Xml(id = xml_key, xml_hash = xml_hash, xml_content = xml_content)
+      row.put()
+  return xml_key
+
+
+def keyToXml(key_provided):
+  # Retrieve stored XML based on the provided key.
+  # Normalize the string.
+  key_provided = key_provided.lower().strip()
+  # Check datastore for a match.
+  client = ndb.Client()
+  with client.context():
+    result = Xml.get_by_id(key_provided)
+  if not result:
+    xml = ""
+  else:
+    # Put it back into the datastore immediately, which updates the last
+    # accessed time.
+    with client.context():
+      result.put()
+    xml = result.xml_content
+  return xml
+
+
+def app(environ, start_response):
+  forms = cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ)
+  if "xml" in forms:
+    out = xmlToKey(forms["xml"].value)
+  elif "key" in forms:
+    out = keyToXml(forms["key"].value)
+  else:
+    out = ""
+
+  headers = [
+    ("Content-Type", "text/plain")
+  ]
+  start_response("200 OK", headers)
+  return [out.encode("utf-8")]

blockly/blockly_uncompressed.js

@@ -0,0 +1,244 @@
+// Do not edit this file; automatically generated by gulp.
+'use strict';
+
+this.IS_NODE_JS = !!(typeof module !== 'undefined' && module.exports);
+
+this.BLOCKLY_DIR = (function(root) {
+  if (!root.IS_NODE_JS) {
+    // Find name of current directory.
+    var scripts = document.getElementsByTagName('script');
+    var re = new RegExp('(.+)[\/]blockly_(.*)uncompressed\.js$');
+    for (var i = 0, script; script = scripts[i]; i++) {
+      var match = re.exec(script.src);
+      if (match) {
+        return match[1];
+      }
+    }
+    alert('Could not detect Blockly\'s directory name.');
+  }
+  return '';
+})(this);
+
+this.BLOCKLY_BOOT = function(root) {
+  // Execute after Closure has loaded.
+goog.addDependency('../../core/block.js', ['Blockly.Block'], ['Blockly.ASTNode', 'Blockly.Blocks', 'Blockly.Connection', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Events.BlockCreate', 'Blockly.Events.BlockDelete', 'Blockly.Events.BlockMove', 'Blockly.Extensions', 'Blockly.IASTNodeLocation', 'Blockly.IDeletable', 'Blockly.Input', 'Blockly.Tooltip', 'Blockly.Workspace', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.fieldRegistry', 'Blockly.inputTypes', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Size', 'Blockly.utils.object'], {'lang': 'es5'});
+goog.addDependency('../../core/block_animations.js', ['Blockly.blockAnimations'], ['Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/block_drag_surface.js', ['Blockly.BlockDragSurfaceSvg'], ['Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/block_dragger.js', ['Blockly.BlockDragger'], ['Blockly.Events', 'Blockly.Events.BlockDrag', 'Blockly.Events.BlockMove', 'Blockly.IBlockDragger', 'Blockly.InsertionMarkerManager', 'Blockly.blockAnimations', 'Blockly.constants', 'Blockly.registry', 'Blockly.utils.Coordinate', 'Blockly.utils.dom']);
+goog.addDependency('../../core/block_svg.js', ['Blockly.BlockSvg'], ['Blockly.ASTNode', 'Blockly.Block', 'Blockly.ContextMenu', 'Blockly.ContextMenuRegistry', 'Blockly.Events', 'Blockly.Events.BlockMove', 'Blockly.Events.Selected', 'Blockly.IASTNodeLocationSvg', 'Blockly.IBoundedElement', 'Blockly.ICopyable', 'Blockly.IDraggable', 'Blockly.Msg', 'Blockly.RenderedConnection', 'Blockly.TabNavigateCursor', 'Blockly.Tooltip', 'Blockly.Touch', 'Blockly.Xml', 'Blockly.blockAnimations', 'Blockly.blockRendering.IPathObject', 'Blockly.browserEvents', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Rect', 'Blockly.utils.Svg', 'Blockly.utils.deprecation', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/blockly.js', ['Blockly'], ['Blockly.ComponentManager', 'Blockly.DropDownDiv', 'Blockly.Events', 'Blockly.Events.BlockCreate', 'Blockly.Events.FinishedLoading', 'Blockly.Events.Ui', 'Blockly.Events.UiBase', 'Blockly.Events.VarCreate', 'Blockly.Procedures', 'Blockly.ShortcutRegistry', 'Blockly.Tooltip', 'Blockly.Touch', 'Blockly.Variables', 'Blockly.WidgetDiv', 'Blockly.WorkspaceSvg', 'Blockly.Xml', 'Blockly.browserEvents', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.inject', 'Blockly.inputTypes', 'Blockly.utils', 'Blockly.utils.Size', 'Blockly.utils.colour', 'Blockly.utils.deprecation', 'Blockly.utils.toolbox']);
+goog.addDependency('../../core/blocks.js', ['Blockly.Blocks'], []);
+goog.addDependency('../../core/browser_events.js', ['Blockly.browserEvents'], ['Blockly.Touch', 'Blockly.utils.global']);
+goog.addDependency('../../core/bubble.js', ['Blockly.Bubble'], ['Blockly.IBubble', 'Blockly.Scrollbar', 'Blockly.Touch', 'Blockly.Workspace', 'Blockly.browserEvents', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Size', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.math', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/bubble_dragger.js', ['Blockly.BubbleDragger'], ['Blockly.Bubble', 'Blockly.ComponentManager', 'Blockly.Events', 'Blockly.Events.CommentMove', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.Coordinate']);
+goog.addDependency('../../core/comment.js', ['Blockly.Comment'], ['Blockly.Bubble', 'Blockly.Css', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Events.BubbleOpen', 'Blockly.Icon', 'Blockly.Warning', 'Blockly.browserEvents', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/component_manager.js', ['Blockly.ComponentManager'], []);
+goog.addDependency('../../core/connection.js', ['Blockly.Connection'], ['Blockly.Events', 'Blockly.Events.BlockMove', 'Blockly.IASTNodeLocationWithBlock', 'Blockly.Xml', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.deprecation']);
+goog.addDependency('../../core/connection_checker.js', ['Blockly.ConnectionChecker'], ['Blockly.Connection', 'Blockly.IConnectionChecker', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.registry']);
+goog.addDependency('../../core/connection_db.js', ['Blockly.ConnectionDB'], ['Blockly.RenderedConnection', 'Blockly.connectionTypes', 'Blockly.constants']);
+goog.addDependency('../../core/connection_types.js', ['Blockly.connectionTypes'], []);
+goog.addDependency('../../core/constants.js', ['Blockly.constants'], ['Blockly.connectionTypes']);
+goog.addDependency('../../core/contextmenu.js', ['Blockly.ContextMenu'], ['Blockly.Events', 'Blockly.Events.BlockCreate', 'Blockly.Menu', 'Blockly.MenuItem', 'Blockly.Msg', 'Blockly.WidgetDiv', 'Blockly.Xml', 'Blockly.browserEvents', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Rect', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/contextmenu_items.js', ['Blockly.ContextMenuItems'], ['Blockly.ContextMenuRegistry', 'Blockly.Events', 'Blockly.constants', 'Blockly.inputTypes'], {'lang': 'es5'});
+goog.addDependency('../../core/contextmenu_registry.js', ['Blockly.ContextMenuRegistry'], [], {'lang': 'es5'});
+goog.addDependency('../../core/css.js', ['Blockly.Css'], [], {'lang': 'es5'});
+goog.addDependency('../../core/delete_area.js', ['Blockly.DeleteArea'], ['Blockly.BlockSvg', 'Blockly.DragTarget', 'Blockly.IDeleteArea']);
+goog.addDependency('../../core/drag_target.js', ['Blockly.DragTarget'], ['Blockly.IDragTarget']);
+goog.addDependency('../../core/dropdowndiv.js', ['Blockly.DropDownDiv'], ['Blockly.utils.Rect', 'Blockly.utils.dom', 'Blockly.utils.math', 'Blockly.utils.style']);
+goog.addDependency('../../core/events/block_events.js', ['Blockly.Events.BlockBase', 'Blockly.Events.BlockChange', 'Blockly.Events.BlockCreate', 'Blockly.Events.BlockDelete', 'Blockly.Events.BlockMove', 'Blockly.Events.Change', 'Blockly.Events.Create', 'Blockly.Events.Delete', 'Blockly.Events.Move'], ['Blockly.Events', 'Blockly.Events.Abstract', 'Blockly.Xml', 'Blockly.connectionTypes', 'Blockly.registry', 'Blockly.utils.Coordinate', 'Blockly.utils.object', 'Blockly.utils.xml']);
+goog.addDependency('../../core/events/events.js', ['Blockly.Events'], ['Blockly.registry', 'Blockly.utils']);
+goog.addDependency('../../core/events/events_abstract.js', ['Blockly.Events.Abstract'], ['Blockly.Events']);
+goog.addDependency('../../core/events/events_block_drag.js', ['Blockly.Events.BlockDrag'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/events_bubble_open.js', ['Blockly.Events.BubbleOpen'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/events_click.js', ['Blockly.Events.Click'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/events_marker_move.js', ['Blockly.Events.MarkerMove'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/events_selected.js', ['Blockly.Events.Selected'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/events_theme_change.js', ['Blockly.Events.ThemeChange'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/events_toolbox_item_select.js', ['Blockly.Events.ToolboxItemSelect'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/events_trashcan_open.js', ['Blockly.Events.TrashcanOpen'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/events_viewport.js', ['Blockly.Events.ViewportChange'], ['Blockly.Events', 'Blockly.Events.UiBase', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/ui_events.js', ['Blockly.Events.Ui', 'Blockly.Events.UiBase'], ['Blockly.Events', 'Blockly.Events.Abstract', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/variable_events.js', ['Blockly.Events.VarBase', 'Blockly.Events.VarCreate', 'Blockly.Events.VarDelete', 'Blockly.Events.VarRename'], ['Blockly.Events', 'Blockly.Events.Abstract', 'Blockly.registry', 'Blockly.utils.object']);
+goog.addDependency('../../core/events/workspace_events.js', ['Blockly.Events.FinishedLoading'], ['Blockly.Events', 'Blockly.Events.Abstract', 'Blockly.registry', 'Blockly.utils.object'], {'lang': 'es5'});
+goog.addDependency('../../core/events/ws_comment_events.js', ['Blockly.Events.CommentBase', 'Blockly.Events.CommentChange', 'Blockly.Events.CommentCreate', 'Blockly.Events.CommentDelete', 'Blockly.Events.CommentMove'], ['Blockly.Events', 'Blockly.Events.Abstract', 'Blockly.Xml', 'Blockly.registry', 'Blockly.utils.Coordinate', 'Blockly.utils.object', 'Blockly.utils.xml']);
+goog.addDependency('../../core/extensions.js', ['Blockly.Extensions'], ['Blockly.utils']);
+goog.addDependency('../../core/field.js', ['Blockly.Field'], ['Blockly.DropDownDiv', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Gesture', 'Blockly.IASTNodeLocationSvg', 'Blockly.IASTNodeLocationWithBlock', 'Blockly.IKeyboardAccessible', 'Blockly.IRegistrable', 'Blockly.MarkerManager', 'Blockly.Tooltip', 'Blockly.WidgetDiv', 'Blockly.browserEvents', 'Blockly.utils', 'Blockly.utils.Rect', 'Blockly.utils.Size', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.style', 'Blockly.utils.userAgent'], {'lang': 'es5'});
+goog.addDependency('../../core/field_angle.js', ['Blockly.FieldAngle'], ['Blockly.Css', 'Blockly.DropDownDiv', 'Blockly.FieldTextInput', 'Blockly.WidgetDiv', 'Blockly.browserEvents', 'Blockly.fieldRegistry', 'Blockly.utils.KeyCodes', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.math', 'Blockly.utils.object', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/field_checkbox.js', ['Blockly.FieldCheckbox'], ['Blockly.Events.BlockChange', 'Blockly.Field', 'Blockly.fieldRegistry', 'Blockly.utils.dom', 'Blockly.utils.object']);
+goog.addDependency('../../core/field_colour.js', ['Blockly.FieldColour'], ['Blockly.Css', 'Blockly.DropDownDiv', 'Blockly.Events.BlockChange', 'Blockly.Field', 'Blockly.browserEvents', 'Blockly.fieldRegistry', 'Blockly.utils.IdGenerator', 'Blockly.utils.KeyCodes', 'Blockly.utils.Size', 'Blockly.utils.aria', 'Blockly.utils.colour', 'Blockly.utils.dom', 'Blockly.utils.object']);
+goog.addDependency('../../core/field_dropdown.js', ['Blockly.FieldDropdown'], ['Blockly.DropDownDiv', 'Blockly.Field', 'Blockly.Menu', 'Blockly.MenuItem', 'Blockly.fieldRegistry', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Svg', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.string', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/field_image.js', ['Blockly.FieldImage'], ['Blockly.Field', 'Blockly.fieldRegistry', 'Blockly.utils', 'Blockly.utils.Size', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object']);
+goog.addDependency('../../core/field_label.js', ['Blockly.FieldLabel'], ['Blockly.Field', 'Blockly.fieldRegistry', 'Blockly.utils', 'Blockly.utils.dom', 'Blockly.utils.object']);
+goog.addDependency('../../core/field_label_serializable.js', ['Blockly.FieldLabelSerializable'], ['Blockly.FieldLabel', 'Blockly.fieldRegistry', 'Blockly.utils', 'Blockly.utils.object']);
+goog.addDependency('../../core/field_multilineinput.js', ['Blockly.FieldMultilineInput'], ['Blockly.Css', 'Blockly.Field', 'Blockly.FieldTextInput', 'Blockly.WidgetDiv', 'Blockly.fieldRegistry', 'Blockly.utils', 'Blockly.utils.KeyCodes', 'Blockly.utils.Svg', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.userAgent'], {'lang': 'es5'});
+goog.addDependency('../../core/field_number.js', ['Blockly.FieldNumber'], ['Blockly.FieldTextInput', 'Blockly.fieldRegistry', 'Blockly.utils.aria', 'Blockly.utils.object']);
+goog.addDependency('../../core/field_registry.js', ['Blockly.fieldRegistry'], ['Blockly.registry']);
+goog.addDependency('../../core/field_textinput.js', ['Blockly.FieldTextInput'], ['Blockly.DropDownDiv', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Field', 'Blockly.Msg', 'Blockly.WidgetDiv', 'Blockly.browserEvents', 'Blockly.fieldRegistry', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.KeyCodes', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/field_variable.js', ['Blockly.FieldVariable'], ['Blockly.Events.BlockChange', 'Blockly.FieldDropdown', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Variables', 'Blockly.Xml', 'Blockly.constants', 'Blockly.fieldRegistry', 'Blockly.utils', 'Blockly.utils.Size', 'Blockly.utils.object']);
+goog.addDependency('../../core/flyout_base.js', ['Blockly.Flyout'], ['Blockly.Block', 'Blockly.ComponentManager', 'Blockly.DeleteArea', 'Blockly.Events', 'Blockly.Events.BlockCreate', 'Blockly.Events.VarCreate', 'Blockly.FlyoutMetricsManager', 'Blockly.Gesture', 'Blockly.IFlyout', 'Blockly.ScrollbarPair', 'Blockly.Tooltip', 'Blockly.Touch', 'Blockly.WorkspaceSvg', 'Blockly.Xml', 'Blockly.blockRendering', 'Blockly.browserEvents', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.toolbox', 'Blockly.utils.xml']);
+goog.addDependency('../../core/flyout_button.js', ['Blockly.FlyoutButton'], ['Blockly.Css', 'Blockly.browserEvents', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.style'], {'lang': 'es5'});
+goog.addDependency('../../core/flyout_horizontal.js', ['Blockly.HorizontalFlyout'], ['Blockly.Block', 'Blockly.DropDownDiv', 'Blockly.Flyout', 'Blockly.Scrollbar', 'Blockly.WidgetDiv', 'Blockly.constants', 'Blockly.registry', 'Blockly.utils', 'Blockly.utils.Rect', 'Blockly.utils.object', 'Blockly.utils.toolbox']);
+goog.addDependency('../../core/flyout_vertical.js', ['Blockly.VerticalFlyout'], ['Blockly.Block', 'Blockly.DropDownDiv', 'Blockly.Flyout', 'Blockly.Scrollbar', 'Blockly.WidgetDiv', 'Blockly.constants', 'Blockly.registry', 'Blockly.utils', 'Blockly.utils.Rect', 'Blockly.utils.object', 'Blockly.utils.toolbox']);
+goog.addDependency('../../core/generator.js', ['Blockly.Generator'], ['Blockly.Block', 'Blockly.constants', 'Blockly.utils.deprecation']);
+goog.addDependency('../../core/gesture.js', ['Blockly.Gesture'], ['Blockly.BlockDragger', 'Blockly.BubbleDragger', 'Blockly.Events', 'Blockly.Events.Click', 'Blockly.Tooltip', 'Blockly.Touch', 'Blockly.Workspace', 'Blockly.WorkspaceDragger', 'Blockly.blockAnimations', 'Blockly.browserEvents', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.Coordinate']);
+goog.addDependency('../../core/grid.js', ['Blockly.Grid'], ['Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/icon.js', ['Blockly.Icon'], ['Blockly.browserEvents', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Size', 'Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/inject.js', ['Blockly.inject'], ['Blockly.BlockDragSurfaceSvg', 'Blockly.Css', 'Blockly.DropDownDiv', 'Blockly.Events', 'Blockly.Grid', 'Blockly.Msg', 'Blockly.Options', 'Blockly.ScrollbarPair', 'Blockly.Tooltip', 'Blockly.WidgetDiv', 'Blockly.Workspace', 'Blockly.WorkspaceDragSurfaceSvg', 'Blockly.WorkspaceSvg', 'Blockly.browserEvents', 'Blockly.utils', 'Blockly.utils.Svg', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.math', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/input.js', ['Blockly.Input'], ['Blockly.Connection', 'Blockly.FieldLabel', 'Blockly.constants', 'Blockly.fieldRegistry', 'Blockly.inputTypes'], {'lang': 'es5'});
+goog.addDependency('../../core/input_types.js', ['Blockly.inputTypes'], ['Blockly.connectionTypes']);
+goog.addDependency('../../core/insertion_marker_manager.js', ['Blockly.InsertionMarkerManager'], ['Blockly.ComponentManager', 'Blockly.Events', 'Blockly.blockAnimations', 'Blockly.connectionTypes', 'Blockly.constants'], {'lang': 'es5'});
+goog.addDependency('../../core/interfaces/i_accessibility.js', ['Blockly.IASTNodeLocation', 'Blockly.IASTNodeLocationSvg', 'Blockly.IASTNodeLocationWithBlock', 'Blockly.IKeyboardAccessible'], []);
+goog.addDependency('../../core/interfaces/i_autohideable.js', ['Blockly.IAutoHideable'], ['Blockly.IComponent']);
+goog.addDependency('../../core/interfaces/i_block_dragger.js', ['Blockly.IBlockDragger'], []);
+goog.addDependency('../../core/interfaces/i_bounded_element.js', ['Blockly.IBoundedElement'], []);
+goog.addDependency('../../core/interfaces/i_bubble.js', ['Blockly.IBubble'], ['Blockly.IContextMenu', 'Blockly.IDraggable']);
+goog.addDependency('../../core/interfaces/i_component.js', ['Blockly.IComponent'], []);
+goog.addDependency('../../core/interfaces/i_connection_checker.js', ['Blockly.IConnectionChecker'], []);
+goog.addDependency('../../core/interfaces/i_contextmenu.js', ['Blockly.IContextMenu'], []);
+goog.addDependency('../../core/interfaces/i_copyable.js', ['Blockly.ICopyable'], []);
+goog.addDependency('../../core/interfaces/i_deletable.js', ['Blockly.IDeletable'], []);
+goog.addDependency('../../core/interfaces/i_delete_area.js', ['Blockly.IDeleteArea'], ['Blockly.IDragTarget']);
+goog.addDependency('../../core/interfaces/i_drag_target.js', ['Blockly.IDragTarget'], ['Blockly.IComponent']);
+goog.addDependency('../../core/interfaces/i_draggable.js', ['Blockly.IDraggable'], ['Blockly.IDeletable']);
+goog.addDependency('../../core/interfaces/i_flyout.js', ['Blockly.IFlyout'], []);
+goog.addDependency('../../core/interfaces/i_metrics_manager.js', ['Blockly.IMetricsManager'], []);
+goog.addDependency('../../core/interfaces/i_movable.js', ['Blockly.IMovable'], []);
+goog.addDependency('../../core/interfaces/i_positionable.js', ['Blockly.IPositionable'], ['Blockly.IComponent']);
+goog.addDependency('../../core/interfaces/i_registrable.js', ['Blockly.IRegistrable'], []);
+goog.addDependency('../../core/interfaces/i_registrable_field.js', ['Blockly.IRegistrableField'], []);
+goog.addDependency('../../core/interfaces/i_selectable.js', ['Blockly.ISelectable'], []);
+goog.addDependency('../../core/interfaces/i_styleable.js', ['Blockly.IStyleable'], []);
+goog.addDependency('../../core/interfaces/i_toolbox.js', ['Blockly.IToolbox'], []);
+goog.addDependency('../../core/interfaces/i_toolbox_item.js', ['Blockly.ICollapsibleToolboxItem', 'Blockly.ISelectableToolboxItem', 'Blockly.IToolboxItem'], []);
+goog.addDependency('../../core/keyboard_nav/ast_node.js', ['Blockly.ASTNode'], ['Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.Coordinate'], {'lang': 'es5'});
+goog.addDependency('../../core/keyboard_nav/basic_cursor.js', ['Blockly.BasicCursor'], ['Blockly.ASTNode', 'Blockly.Cursor', 'Blockly.registry'], {'lang': 'es5'});
+goog.addDependency('../../core/keyboard_nav/cursor.js', ['Blockly.Cursor'], ['Blockly.ASTNode', 'Blockly.Marker', 'Blockly.registry', 'Blockly.utils.object'], {'lang': 'es5'});
+goog.addDependency('../../core/keyboard_nav/marker.js', ['Blockly.Marker'], ['Blockly.ASTNode']);
+goog.addDependency('../../core/keyboard_nav/tab_navigate_cursor.js', ['Blockly.TabNavigateCursor'], ['Blockly.ASTNode', 'Blockly.BasicCursor', 'Blockly.utils.object']);
+goog.addDependency('../../core/marker_manager.js', ['Blockly.MarkerManager'], ['Blockly.Cursor', 'Blockly.Marker']);
+goog.addDependency('../../core/menu.js', ['Blockly.Menu'], ['Blockly.browserEvents', 'Blockly.utils.Coordinate', 'Blockly.utils.KeyCodes', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.style']);
+goog.addDependency('../../core/menuitem.js', ['Blockly.MenuItem'], ['Blockly.utils.IdGenerator', 'Blockly.utils.aria', 'Blockly.utils.dom']);
+goog.addDependency('../../core/metrics_manager.js', ['Blockly.FlyoutMetricsManager', 'Blockly.MetricsManager'], ['Blockly.IMetricsManager', 'Blockly.registry', 'Blockly.utils.Size', 'Blockly.utils.toolbox'], {'lang': 'es5'});
+goog.addDependency('../../core/msg.js', ['Blockly.Msg'], ['Blockly.utils.global']);
+goog.addDependency('../../core/mutator.js', ['Blockly.Mutator'], ['Blockly.Bubble', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Events.BubbleOpen', 'Blockly.Icon', 'Blockly.Options', 'Blockly.WorkspaceSvg', 'Blockly.Xml', 'Blockly.utils', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.toolbox', 'Blockly.utils.xml']);
+goog.addDependency('../../core/names.js', ['Blockly.Names'], ['Blockly.Msg', 'Blockly.constants']);
+goog.addDependency('../../core/options.js', ['Blockly.Options'], ['Blockly.Theme', 'Blockly.Themes.Classic', 'Blockly.registry', 'Blockly.utils.IdGenerator', 'Blockly.utils.Metrics', 'Blockly.utils.toolbox']);
+goog.addDependency('../../core/positionable_helpers.js', ['Blockly.uiPosition'], ['Blockly.Scrollbar', 'Blockly.utils.Rect', 'Blockly.utils.toolbox']);
+goog.addDependency('../../core/procedures.js', ['Blockly.Procedures'], ['Blockly.Blocks', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Field', 'Blockly.Msg', 'Blockly.Names', 'Blockly.Workspace', 'Blockly.Xml', 'Blockly.constants', 'Blockly.utils.xml']);
+goog.addDependency('../../core/registry.js', ['Blockly.registry'], []);
+goog.addDependency('../../core/rendered_connection.js', ['Blockly.RenderedConnection'], ['Blockly.Connection', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Svg', 'Blockly.utils.deprecation', 'Blockly.utils.dom', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/common/block_rendering.js', ['Blockly.blockRendering'], ['Blockly.registry']);
+goog.addDependency('../../core/renderers/common/constants.js', ['Blockly.blockRendering.ConstantProvider'], ['Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.Svg', 'Blockly.utils.colour', 'Blockly.utils.dom', 'Blockly.utils.svgPaths', 'Blockly.utils.userAgent'], {'lang': 'es5'});
+goog.addDependency('../../core/renderers/common/debugger.js', ['Blockly.blockRendering.Debug'], ['Blockly.blockRendering.Measurable', 'Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.Row', 'Blockly.blockRendering.Types', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.Svg', 'Blockly.utils.dom'], {'lang': 'es5'});
+goog.addDependency('../../core/renderers/common/drawer.js', ['Blockly.blockRendering.Drawer'], ['Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.Row', 'Blockly.blockRendering.Types', 'Blockly.utils.svgPaths']);
+goog.addDependency('../../core/renderers/common/i_path_object.js', ['Blockly.blockRendering.IPathObject'], []);
+goog.addDependency('../../core/renderers/common/info.js', ['Blockly.blockRendering.RenderInfo'], ['Blockly.blockRendering.BottomRow', 'Blockly.blockRendering.ExternalValueInput', 'Blockly.blockRendering.Field', 'Blockly.blockRendering.Hat', 'Blockly.blockRendering.InRowSpacer', 'Blockly.blockRendering.InlineInput', 'Blockly.blockRendering.InputRow', 'Blockly.blockRendering.JaggedEdge', 'Blockly.blockRendering.Measurable', 'Blockly.blockRendering.NextConnection', 'Blockly.blockRendering.OutputConnection', 'Blockly.blockRendering.PreviousConnection', 'Blockly.blockRendering.RoundCorner', 'Blockly.blockRendering.Row', 'Blockly.blockRendering.SpacerRow', 'Blockly.blockRendering.SquareCorner', 'Blockly.blockRendering.StatementInput', 'Blockly.blockRendering.TopRow', 'Blockly.blockRendering.Types', 'Blockly.constants', 'Blockly.inputTypes']);
+goog.addDependency('../../core/renderers/common/marker_svg.js', ['Blockly.blockRendering.MarkerSvg'], ['Blockly.ASTNode', 'Blockly.Events', 'Blockly.Events.MarkerMove', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/renderers/common/path_object.js', ['Blockly.blockRendering.PathObject'], ['Blockly.Theme', 'Blockly.blockRendering.ConstantProvider', 'Blockly.blockRendering.IPathObject', 'Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/renderers/common/renderer.js', ['Blockly.blockRendering.Renderer'], ['Blockly.IRegistrable', 'Blockly.InsertionMarkerManager', 'Blockly.blockRendering.ConstantProvider', 'Blockly.blockRendering.Debug', 'Blockly.blockRendering.Drawer', 'Blockly.blockRendering.IPathObject', 'Blockly.blockRendering.MarkerSvg', 'Blockly.blockRendering.PathObject', 'Blockly.blockRendering.RenderInfo', 'Blockly.connectionTypes', 'Blockly.constants']);
+goog.addDependency('../../core/renderers/geras/constants.js', ['Blockly.geras.ConstantProvider'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.utils.object'], {'lang': 'es5'});
+goog.addDependency('../../core/renderers/geras/drawer.js', ['Blockly.geras.Drawer'], ['Blockly.blockRendering.Drawer', 'Blockly.geras.Highlighter', 'Blockly.geras.RenderInfo', 'Blockly.utils.object', 'Blockly.utils.svgPaths']);
+goog.addDependency('../../core/renderers/geras/highlight_constants.js', ['Blockly.geras.HighlightConstantProvider'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.utils.svgPaths'], {'lang': 'es5'});
+goog.addDependency('../../core/renderers/geras/highlighter.js', ['Blockly.geras.Highlighter'], ['Blockly.blockRendering.Types', 'Blockly.utils.svgPaths']);
+goog.addDependency('../../core/renderers/geras/info.js', ['Blockly.geras', 'Blockly.geras.RenderInfo'], ['Blockly.blockRendering.ExternalValueInput', 'Blockly.blockRendering.InRowSpacer', 'Blockly.blockRendering.InputRow', 'Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.Types', 'Blockly.constants', 'Blockly.geras.InlineInput', 'Blockly.geras.StatementInput', 'Blockly.inputTypes', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/geras/measurables/inputs.js', ['Blockly.geras.InlineInput', 'Blockly.geras.StatementInput'], ['Blockly.blockRendering.InlineInput', 'Blockly.blockRendering.StatementInput', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/geras/path_object.js', ['Blockly.geras.PathObject'], ['Blockly.Theme', 'Blockly.blockRendering.PathObject', 'Blockly.geras.ConstantProvider', 'Blockly.utils.Svg', 'Blockly.utils.colour', 'Blockly.utils.dom', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/geras/renderer.js', ['Blockly.geras.Renderer'], ['Blockly.blockRendering', 'Blockly.blockRendering.Renderer', 'Blockly.geras.ConstantProvider', 'Blockly.geras.Drawer', 'Blockly.geras.HighlightConstantProvider', 'Blockly.geras.PathObject', 'Blockly.geras.RenderInfo', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/measurables/base.js', ['Blockly.blockRendering.Measurable'], ['Blockly.blockRendering.Types']);
+goog.addDependency('../../core/renderers/measurables/connections.js', ['Blockly.blockRendering.Connection', 'Blockly.blockRendering.NextConnection', 'Blockly.blockRendering.OutputConnection', 'Blockly.blockRendering.PreviousConnection'], ['Blockly.blockRendering.Measurable', 'Blockly.blockRendering.Types', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/measurables/inputs.js', ['Blockly.blockRendering.ExternalValueInput', 'Blockly.blockRendering.InlineInput', 'Blockly.blockRendering.InputConnection', 'Blockly.blockRendering.StatementInput'], ['Blockly.blockRendering.Connection', 'Blockly.blockRendering.Types', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/measurables/row_elements.js', ['Blockly.blockRendering.Field', 'Blockly.blockRendering.Hat', 'Blockly.blockRendering.Icon', 'Blockly.blockRendering.InRowSpacer', 'Blockly.blockRendering.JaggedEdge', 'Blockly.blockRendering.RoundCorner', 'Blockly.blockRendering.SquareCorner'], ['Blockly.blockRendering.Measurable', 'Blockly.blockRendering.Types', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/measurables/rows.js', ['Blockly.blockRendering.BottomRow', 'Blockly.blockRendering.InputRow', 'Blockly.blockRendering.Row', 'Blockly.blockRendering.SpacerRow', 'Blockly.blockRendering.TopRow'], ['Blockly.blockRendering.InRowSpacer', 'Blockly.blockRendering.InputConnection', 'Blockly.blockRendering.Measurable', 'Blockly.blockRendering.NextConnection', 'Blockly.blockRendering.PreviousConnection', 'Blockly.blockRendering.Types', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/measurables/types.js', ['Blockly.blockRendering.Types'], []);
+goog.addDependency('../../core/renderers/minimalist/constants.js', ['Blockly.minimalist.ConstantProvider'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/minimalist/drawer.js', ['Blockly.minimalist.Drawer'], ['Blockly.blockRendering.Drawer', 'Blockly.minimalist.RenderInfo', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/minimalist/info.js', ['Blockly.minimalist', 'Blockly.minimalist.RenderInfo'], ['Blockly.utils.object']);
+goog.addDependency('../../core/renderers/minimalist/renderer.js', ['Blockly.minimalist.Renderer'], ['Blockly.blockRendering', 'Blockly.blockRendering.Renderer', 'Blockly.minimalist.ConstantProvider', 'Blockly.minimalist.Drawer', 'Blockly.minimalist.RenderInfo', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/thrasos/info.js', ['Blockly.thrasos', 'Blockly.thrasos.RenderInfo'], ['Blockly.blockRendering.InRowSpacer', 'Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.Types', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/thrasos/renderer.js', ['Blockly.thrasos.Renderer'], ['Blockly.blockRendering', 'Blockly.blockRendering.Renderer', 'Blockly.thrasos.RenderInfo', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/zelos/constants.js', ['Blockly.zelos.ConstantProvider'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.Svg', 'Blockly.utils.colour', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.svgPaths'], {'lang': 'es5'});
+goog.addDependency('../../core/renderers/zelos/drawer.js', ['Blockly.zelos.Drawer'], ['Blockly.blockRendering.Drawer', 'Blockly.utils.object', 'Blockly.utils.svgPaths', 'Blockly.zelos.RenderInfo']);
+goog.addDependency('../../core/renderers/zelos/info.js', ['Blockly.zelos', 'Blockly.zelos.RenderInfo'], ['Blockly.FieldImage', 'Blockly.FieldLabel', 'Blockly.FieldTextInput', 'Blockly.blockRendering.InRowSpacer', 'Blockly.blockRendering.Measurable', 'Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.Types', 'Blockly.constants', 'Blockly.inputTypes', 'Blockly.utils.object', 'Blockly.zelos.BottomRow', 'Blockly.zelos.RightConnectionShape', 'Blockly.zelos.TopRow']);
+goog.addDependency('../../core/renderers/zelos/marker_svg.js', ['Blockly.zelos.MarkerSvg'], ['Blockly.blockRendering.MarkerSvg', 'Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/renderers/zelos/measurables/inputs.js', ['Blockly.zelos.StatementInput'], ['Blockly.blockRendering.StatementInput', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/zelos/measurables/row_elements.js', ['Blockly.zelos.RightConnectionShape'], ['Blockly.blockRendering.Measurable', 'Blockly.blockRendering.Types', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/zelos/measurables/rows.js', ['Blockly.zelos.BottomRow', 'Blockly.zelos.TopRow'], ['Blockly.blockRendering.BottomRow', 'Blockly.blockRendering.TopRow', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/zelos/path_object.js', ['Blockly.zelos.PathObject'], ['Blockly.blockRendering.PathObject', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.zelos.ConstantProvider']);
+goog.addDependency('../../core/renderers/zelos/renderer.js', ['Blockly.zelos.Renderer'], ['Blockly.InsertionMarkerManager', 'Blockly.blockRendering', 'Blockly.blockRendering.Renderer', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.object', 'Blockly.zelos.ConstantProvider', 'Blockly.zelos.Drawer', 'Blockly.zelos.MarkerSvg', 'Blockly.zelos.PathObject', 'Blockly.zelos.RenderInfo']);
+goog.addDependency('../../core/requires.js', ['Blockly.requires'], ['Blockly', 'Blockly.Comment', 'Blockly.ContextMenuItems', 'Blockly.FieldAngle', 'Blockly.FieldCheckbox', 'Blockly.FieldColour', 'Blockly.FieldDropdown', 'Blockly.FieldImage', 'Blockly.FieldLabelSerializable', 'Blockly.FieldMultilineInput', 'Blockly.FieldNumber', 'Blockly.FieldTextInput', 'Blockly.FieldVariable', 'Blockly.FlyoutButton', 'Blockly.Generator', 'Blockly.HorizontalFlyout', 'Blockly.Mutator', 'Blockly.ShortcutItems', 'Blockly.Themes.Classic', 'Blockly.Themes.Dark', 'Blockly.Themes.Deuteranopia', 'Blockly.Themes.HighContrast', 'Blockly.Themes.Tritanopia', 'Blockly.Toolbox', 'Blockly.Trashcan', 'Blockly.VariablesDynamic', 'Blockly.VerticalFlyout', 'Blockly.Warning', 'Blockly.ZoomControls', 'Blockly.geras.Renderer', 'Blockly.thrasos.Renderer', 'Blockly.zelos.Renderer']);
+goog.addDependency('../../core/scrollbar.js', ['Blockly.Scrollbar', 'Blockly.ScrollbarPair'], ['Blockly.Events', 'Blockly.Touch', 'Blockly.browserEvents', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Metrics', 'Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/shortcut_items.js', ['Blockly.ShortcutItems'], ['Blockly.Gesture', 'Blockly.ShortcutRegistry', 'Blockly.utils.KeyCodes']);
+goog.addDependency('../../core/shortcut_registry.js', ['Blockly.ShortcutRegistry'], ['Blockly.utils.KeyCodes', 'Blockly.utils.object']);
+goog.addDependency('../../core/theme.js', ['Blockly.Theme'], ['Blockly.registry', 'Blockly.utils', 'Blockly.utils.object']);
+goog.addDependency('../../core/theme/classic.js', ['Blockly.Themes.Classic'], ['Blockly.Theme']);
+goog.addDependency('../../core/theme/dark.js', ['Blockly.Themes.Dark'], ['Blockly.Theme']);
+goog.addDependency('../../core/theme/deuteranopia.js', ['Blockly.Themes.Deuteranopia'], ['Blockly.Theme']);
+goog.addDependency('../../core/theme/highcontrast.js', ['Blockly.Themes.HighContrast'], ['Blockly.Theme']);
+goog.addDependency('../../core/theme/modern.js', ['Blockly.Themes.Modern'], ['Blockly.Theme']);
+goog.addDependency('../../core/theme/tritanopia.js', ['Blockly.Themes.Tritanopia'], ['Blockly.Theme']);
+goog.addDependency('../../core/theme/zelos.js', ['Blockly.Themes.Zelos'], ['Blockly.Theme']);
+goog.addDependency('../../core/theme_manager.js', ['Blockly.ThemeManager'], ['Blockly.Theme']);
+goog.addDependency('../../core/toolbox/category.js', ['Blockly.ToolboxCategory'], ['Blockly.ISelectableToolboxItem', 'Blockly.ToolboxItem', 'Blockly.registry', 'Blockly.utils', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.toolbox'], {'lang': 'es5'});
+goog.addDependency('../../core/toolbox/collapsible_category.js', ['Blockly.CollapsibleToolboxCategory'], ['Blockly.ICollapsibleToolboxItem', 'Blockly.ToolboxCategory', 'Blockly.ToolboxItem', 'Blockly.ToolboxSeparator', 'Blockly.registry', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.toolbox']);
+goog.addDependency('../../core/toolbox/separator.js', ['Blockly.ToolboxSeparator'], ['Blockly.IToolboxItem', 'Blockly.ToolboxItem', 'Blockly.registry', 'Blockly.utils.dom'], {'lang': 'es5'});
+goog.addDependency('../../core/toolbox/toolbox.js', ['Blockly.Toolbox'], ['Blockly.BlockSvg', 'Blockly.CollapsibleToolboxCategory', 'Blockly.ComponentManager', 'Blockly.Css', 'Blockly.DeleteArea', 'Blockly.Events', 'Blockly.Events.ToolboxItemSelect', 'Blockly.IAutoHideable', 'Blockly.IKeyboardAccessible', 'Blockly.IStyleable', 'Blockly.IToolbox', 'Blockly.Options', 'Blockly.Touch', 'Blockly.browserEvents', 'Blockly.constants', 'Blockly.registry', 'Blockly.utils', 'Blockly.utils.Rect', 'Blockly.utils.aria', 'Blockly.utils.dom', 'Blockly.utils.toolbox'], {'lang': 'es5'});
+goog.addDependency('../../core/toolbox/toolbox_item.js', ['Blockly.ToolboxItem'], ['Blockly.IToolboxItem']);
+goog.addDependency('../../core/tooltip.js', ['Blockly.Tooltip'], ['Blockly.browserEvents', 'Blockly.utils.string']);
+goog.addDependency('../../core/touch.js', ['Blockly.Touch'], ['Blockly.constants', 'Blockly.utils', 'Blockly.utils.global', 'Blockly.utils.string']);
+goog.addDependency('../../core/touch_gesture.js', ['Blockly.TouchGesture'], ['Blockly.Gesture', 'Blockly.browserEvents', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.object']);
+goog.addDependency('../../core/trashcan.js', ['Blockly.Trashcan'], ['Blockly.ComponentManager', 'Blockly.DeleteArea', 'Blockly.Events', 'Blockly.Events.TrashcanOpen', 'Blockly.IAutoHideable', 'Blockly.IPositionable', 'Blockly.Options', 'Blockly.Xml', 'Blockly.browserEvents', 'Blockly.constants', 'Blockly.registry', 'Blockly.uiPosition', 'Blockly.utils', 'Blockly.utils.Rect', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.toolbox'], {'lang': 'es5'});
+goog.addDependency('../../core/utils.js', ['Blockly.utils'], ['Blockly.Msg', 'Blockly.constants', 'Blockly.utils.Coordinate', 'Blockly.utils.Rect', 'Blockly.utils.colour', 'Blockly.utils.global', 'Blockly.utils.string', 'Blockly.utils.style', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/utils/aria.js', ['Blockly.utils.aria'], []);
+goog.addDependency('../../core/utils/colour.js', ['Blockly.utils.colour'], []);
+goog.addDependency('../../core/utils/coordinate.js', ['Blockly.utils.Coordinate'], []);
+goog.addDependency('../../core/utils/deprecation.js', ['Blockly.utils.deprecation'], []);
+goog.addDependency('../../core/utils/dom.js', ['Blockly.utils.dom'], ['Blockly.utils.Svg', 'Blockly.utils.userAgent']);
+goog.addDependency('../../core/utils/global.js', ['Blockly.utils.global'], []);
+goog.addDependency('../../core/utils/idgenerator.js', ['Blockly.utils.IdGenerator'], []);
+goog.addDependency('../../core/utils/keycodes.js', ['Blockly.utils.KeyCodes'], []);
+goog.addDependency('../../core/utils/math.js', ['Blockly.utils.math'], []);
+goog.addDependency('../../core/utils/metrics.js', ['Blockly.utils.Metrics'], []);
+goog.addDependency('../../core/utils/object.js', ['Blockly.utils.object'], []);
+goog.addDependency('../../core/utils/rect.js', ['Blockly.utils.Rect'], []);
+goog.addDependency('../../core/utils/size.js', ['Blockly.utils.Size'], []);
+goog.addDependency('../../core/utils/string.js', ['Blockly.utils.string'], []);
+goog.addDependency('../../core/utils/style.js', ['Blockly.utils.style'], ['Blockly.utils.Coordinate', 'Blockly.utils.Size']);
+goog.addDependency('../../core/utils/svg.js', ['Blockly.utils.Svg'], []);
+goog.addDependency('../../core/utils/svg_paths.js', ['Blockly.utils.svgPaths'], []);
+goog.addDependency('../../core/utils/toolbox.js', ['Blockly.utils.toolbox'], ['Blockly.Xml', 'Blockly.constants']);
+goog.addDependency('../../core/utils/useragent.js', ['Blockly.utils.userAgent'], ['Blockly.utils.global']);
+goog.addDependency('../../core/utils/xml.js', ['Blockly.utils.xml'], []);
+goog.addDependency('../../core/variable_map.js', ['Blockly.VariableMap'], ['Blockly.Events', 'Blockly.Events.VarDelete', 'Blockly.Events.VarRename', 'Blockly.Msg', 'Blockly.utils', 'Blockly.utils.object']);
+goog.addDependency('../../core/variable_model.js', ['Blockly.VariableModel'], ['Blockly.Events', 'Blockly.Events.VarCreate', 'Blockly.utils']);
+goog.addDependency('../../core/variables.js', ['Blockly.Variables'], ['Blockly.Blocks', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Xml', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.xml']);
+goog.addDependency('../../core/variables_dynamic.js', ['Blockly.VariablesDynamic'], ['Blockly.Blocks', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Variables', 'Blockly.utils.xml']);
+goog.addDependency('../../core/warning.js', ['Blockly.Warning'], ['Blockly.Bubble', 'Blockly.Events', 'Blockly.Events.BubbleOpen', 'Blockly.Icon', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object']);
+goog.addDependency('../../core/widgetdiv.js', ['Blockly.WidgetDiv'], ['Blockly.utils.dom']);
+goog.addDependency('../../core/workspace.js', ['Blockly.Workspace'], ['Blockly.ConnectionChecker', 'Blockly.Events', 'Blockly.IASTNodeLocation', 'Blockly.Options', 'Blockly.VariableMap', 'Blockly.registry', 'Blockly.utils', 'Blockly.utils.math']);
+goog.addDependency('../../core/workspace_audio.js', ['Blockly.WorkspaceAudio'], ['Blockly.constants', 'Blockly.utils', 'Blockly.utils.global', 'Blockly.utils.userAgent'], {'lang': 'es5'});
+goog.addDependency('../../core/workspace_comment.js', ['Blockly.WorkspaceComment'], ['Blockly.Events', 'Blockly.Events.CommentChange', 'Blockly.Events.CommentCreate', 'Blockly.Events.CommentDelete', 'Blockly.Events.CommentMove', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.xml']);
+goog.addDependency('../../core/workspace_comment_render_svg.js', ['Blockly.WorkspaceCommentSvg.render'], ['Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/workspace_comment_svg.js', ['Blockly.WorkspaceCommentSvg'], ['Blockly.Css', 'Blockly.Events', 'Blockly.Events.CommentCreate', 'Blockly.Events.CommentDelete', 'Blockly.Events.CommentMove', 'Blockly.Events.Selected', 'Blockly.WorkspaceComment', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Rect', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object']);
+goog.addDependency('../../core/workspace_drag_surface_svg.js', ['Blockly.WorkspaceDragSurfaceSvg'], ['Blockly.utils', 'Blockly.utils.Svg', 'Blockly.utils.dom']);
+goog.addDependency('../../core/workspace_dragger.js', ['Blockly.WorkspaceDragger'], ['Blockly.utils.Coordinate']);
+goog.addDependency('../../core/workspace_svg.js', ['Blockly.WorkspaceSvg'], ['Blockly.BlockSvg', 'Blockly.ComponentManager', 'Blockly.ConnectionDB', 'Blockly.ContextMenu', 'Blockly.ContextMenuRegistry', 'Blockly.Events', 'Blockly.Events.BlockCreate', 'Blockly.Events.ThemeChange', 'Blockly.Events.ViewportChange', 'Blockly.Gesture', 'Blockly.Grid', 'Blockly.IASTNodeLocationSvg', 'Blockly.MarkerManager', 'Blockly.MetricsManager', 'Blockly.Msg', 'Blockly.Options', 'Blockly.ThemeManager', 'Blockly.Themes.Classic', 'Blockly.TouchGesture', 'Blockly.Workspace', 'Blockly.WorkspaceAudio', 'Blockly.WorkspaceDragSurfaceSvg', 'Blockly.Xml', 'Blockly.blockRendering', 'Blockly.browserEvents', 'Blockly.constants', 'Blockly.registry', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Metrics', 'Blockly.utils.Rect', 'Blockly.utils.Size', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.toolbox'], {'lang': 'es5'});
+goog.addDependency('../../core/xml.js', ['Blockly.Xml'], ['Blockly.Events', 'Blockly.constants', 'Blockly.inputTypes', 'Blockly.utils', 'Blockly.utils.Size', 'Blockly.utils.dom', 'Blockly.utils.xml']);
+goog.addDependency('../../core/zoom_controls.js', ['Blockly.ZoomControls'], ['Blockly.ComponentManager', 'Blockly.Css', 'Blockly.Events', 'Blockly.Events.Click', 'Blockly.IPositionable', 'Blockly.Touch', 'Blockly.browserEvents', 'Blockly.constants', 'Blockly.uiPosition', 'Blockly.utils', 'Blockly.utils.Rect', 'Blockly.utils.Svg', 'Blockly.utils.dom'], {'lang': 'es5'});
+goog.addDependency("base.js", [], []);
+
+// Load Blockly.
+goog.require('Blockly.requires');
+
+delete root.BLOCKLY_DIR;
+delete root.BLOCKLY_BOOT;
+delete root.IS_NODE_JS;
+};
+
+if (this.IS_NODE_JS) {
+  this.BLOCKLY_BOOT(this);
+  module.exports = Blockly;
+} else {
+  document.write('<script src="' + this.BLOCKLY_DIR +
+      '/closure/goog/base.js"></script>');
+  document.write('<script>this.BLOCKLY_BOOT(this);</script>');
+}

blockly/blocks/colour.js

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Colour blocks for Blockly.
+ *
+ * This file is scraped to extract a .json file of block definitions. The array
+ * passed to defineBlocksWithJsonArray(..) must be strict JSON: double quotes
+ * only, no outside references, no functions, no trailing commas, etc. The one
+ * exception is end-of-line comments, which the scraper will remove.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.colour');  // Deprecated
+goog.provide('Blockly.Constants.Colour');
+
+goog.require('Blockly');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.FieldColour');
+goog.require('Blockly.FieldLabel');
+
+
+/**
+ * Unused constant for the common HSV hue for all blocks in this category.
+ * @deprecated Use Blockly.Msg['COLOUR_HUE']. (2018 April 5)
+ */
+Blockly.Constants.Colour.HUE = 20;
+
+Blockly.defineBlocksWithJsonArray([  // BEGIN JSON EXTRACT
+  // Block for colour picker.
+  {
+    "type": "colour_picker",
+    "message0": "%1",
+    "args0": [
+      {
+        "type": "field_colour",
+        "name": "COLOUR",
+        "colour": "#ff0000"
+      }
+    ],
+    "output": "Colour",
+    "helpUrl": "%{BKY_COLOUR_PICKER_HELPURL}",
+    "style": "colour_blocks",
+    "tooltip": "%{BKY_COLOUR_PICKER_TOOLTIP}",
+    "extensions": ["parent_tooltip_when_inline"]
+  },
+
+  // Block for random colour.
+  {
+    "type": "colour_random",
+    "message0": "%{BKY_COLOUR_RANDOM_TITLE}",
+    "output": "Colour",
+    "helpUrl": "%{BKY_COLOUR_RANDOM_HELPURL}",
+    "style": "colour_blocks",
+    "tooltip": "%{BKY_COLOUR_RANDOM_TOOLTIP}"
+  },
+
+  // Block for composing a colour from RGB components.
+  {
+    "type": "colour_rgb",
+    "message0": "%{BKY_COLOUR_RGB_TITLE} %{BKY_COLOUR_RGB_RED} %1 %{BKY_COLOUR_RGB_GREEN} %2 %{BKY_COLOUR_RGB_BLUE} %3",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "RED",
+        "check": "Number",
+        "align": "RIGHT"
+      },
+      {
+        "type": "input_value",
+        "name": "GREEN",
+        "check": "Number",
+        "align": "RIGHT"
+      },
+      {
+        "type": "input_value",
+        "name": "BLUE",
+        "check": "Number",
+        "align": "RIGHT"
+      }
+    ],
+    "output": "Colour",
+    "helpUrl": "%{BKY_COLOUR_RGB_HELPURL}",
+    "style": "colour_blocks",
+    "tooltip": "%{BKY_COLOUR_RGB_TOOLTIP}"
+  },
+
+  // Block for blending two colours together.
+  {
+    "type": "colour_blend",
+    "message0": "%{BKY_COLOUR_BLEND_TITLE} %{BKY_COLOUR_BLEND_COLOUR1} " +
+        "%1 %{BKY_COLOUR_BLEND_COLOUR2} %2 %{BKY_COLOUR_BLEND_RATIO} %3",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "COLOUR1",
+        "check": "Colour",
+        "align": "RIGHT"
+      },
+      {
+        "type": "input_value",
+        "name": "COLOUR2",
+        "check": "Colour",
+        "align": "RIGHT"
+      },
+      {
+        "type": "input_value",
+        "name": "RATIO",
+        "check": "Number",
+        "align": "RIGHT"
+      }
+    ],
+    "output": "Colour",
+    "helpUrl": "%{BKY_COLOUR_BLEND_HELPURL}",
+    "style": "colour_blocks",
+    "tooltip": "%{BKY_COLOUR_BLEND_TOOLTIP}"
+  }
+]);  // END JSON EXTRACT (Do not delete this comment.)

blockly/blocks/lists.js

@@ -0,0 +1,861 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview List blocks for Blockly.
+ *
+ * This file is scraped to extract a .json file of block definitions. The array
+ * passed to defineBlocksWithJsonArray(..) must be strict JSON: double quotes
+ * only, no outside references, no functions, no trailing commas, etc. The one
+ * exception is end-of-line comments, which the scraper will remove.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Constants.Lists');
+
+goog.require('Blockly');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.FieldDropdown');
+goog.require('Blockly.FieldLabel');
+goog.require('Blockly.Mutator');
+
+
+/**
+ * Unused constant for the common HSV hue for all blocks in this category.
+ * @deprecated Use Blockly.Msg['LISTS_HUE']. (2018 April 5)
+ */
+Blockly.Constants.Lists.HUE = 260;
+
+Blockly.defineBlocksWithJsonArray([  // BEGIN JSON EXTRACT
+  // Block for creating an empty list
+  // The 'list_create_with' block is preferred as it is more flexible.
+  // <block type="lists_create_with">
+  //   <mutation items="0"></mutation>
+  // </block>
+  {
+    "type": "lists_create_empty",
+    "message0": "%{BKY_LISTS_CREATE_EMPTY_TITLE}",
+    "output": "Array",
+    "style": "list_blocks",
+    "tooltip": "%{BKY_LISTS_CREATE_EMPTY_TOOLTIP}",
+    "helpUrl": "%{BKY_LISTS_CREATE_EMPTY_HELPURL}"
+  },
+  // Block for creating a list with one element repeated.
+  {
+    "type": "lists_repeat",
+    "message0": "%{BKY_LISTS_REPEAT_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "ITEM"
+      },
+      {
+        "type": "input_value",
+        "name": "NUM",
+        "check": "Number"
+      }
+    ],
+    "output": "Array",
+    "style": "list_blocks",
+    "tooltip": "%{BKY_LISTS_REPEAT_TOOLTIP}",
+    "helpUrl": "%{BKY_LISTS_REPEAT_HELPURL}"
+  },
+  // Block for reversing a list.
+  {
+    "type": "lists_reverse",
+    "message0": "%{BKY_LISTS_REVERSE_MESSAGE0}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "LIST",
+        "check": "Array"
+      }
+    ],
+    "output": "Array",
+    "inputsInline": true,
+    "style": "list_blocks",
+    "tooltip": "%{BKY_LISTS_REVERSE_TOOLTIP}",
+    "helpUrl": "%{BKY_LISTS_REVERSE_HELPURL}"
+  },
+  // Block for checking if a list is empty
+  {
+    "type": "lists_isEmpty",
+    "message0": "%{BKY_LISTS_ISEMPTY_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "VALUE",
+        "check": ["String", "Array"]
+      }
+    ],
+    "output": "Boolean",
+    "style": "list_blocks",
+    "tooltip": "%{BKY_LISTS_ISEMPTY_TOOLTIP}",
+    "helpUrl": "%{BKY_LISTS_ISEMPTY_HELPURL}"
+  },
+  // Block for getting the list length
+  {
+    "type": "lists_length",
+    "message0": "%{BKY_LISTS_LENGTH_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "VALUE",
+        "check": ["String", "Array"]
+      }
+    ],
+    "output": "Number",
+    "style": "list_blocks",
+    "tooltip": "%{BKY_LISTS_LENGTH_TOOLTIP}",
+    "helpUrl": "%{BKY_LISTS_LENGTH_HELPURL}"
+  }
+]);  // END JSON EXTRACT (Do not delete this comment.)
+
+Blockly.Blocks['lists_create_with'] = {
+  /**
+   * Block for creating a list with any number of elements of any type.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.setHelpUrl(Blockly.Msg['LISTS_CREATE_WITH_HELPURL']);
+    this.setStyle('list_blocks');
+    this.itemCount_ = 3;
+    this.updateShape_();
+    this.setOutput(true, 'Array');
+    this.setMutator(new Blockly.Mutator(['lists_create_with_item']));
+    this.setTooltip(Blockly.Msg['LISTS_CREATE_WITH_TOOLTIP']);
+  },
+  /**
+   * Create XML to represent list inputs.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    container.setAttribute('items', this.itemCount_);
+    return container;
+  },
+  /**
+   * Parse XML to restore the list inputs.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    this.itemCount_ = parseInt(xmlElement.getAttribute('items'), 10);
+    this.updateShape_();
+  },
+  /**
+   * Populate the mutator's dialog with this block's components.
+   * @param {!Blockly.Workspace} workspace Mutator's workspace.
+   * @return {!Blockly.Block} Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  decompose: function(workspace) {
+    var containerBlock = workspace.newBlock('lists_create_with_container');
+    containerBlock.initSvg();
+    var connection = containerBlock.getInput('STACK').connection;
+    for (var i = 0; i < this.itemCount_; i++) {
+      var itemBlock = workspace.newBlock('lists_create_with_item');
+      itemBlock.initSvg();
+      connection.connect(itemBlock.previousConnection);
+      connection = itemBlock.nextConnection;
+    }
+    return containerBlock;
+  },
+  /**
+   * Reconfigure this block based on the mutator dialog's components.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  compose: function(containerBlock) {
+    var itemBlock = containerBlock.getInputTargetBlock('STACK');
+    // Count number of inputs.
+    var connections = [];
+    while (itemBlock && !itemBlock.isInsertionMarker()) {
+      connections.push(itemBlock.valueConnection_);
+      itemBlock = itemBlock.nextConnection &&
+          itemBlock.nextConnection.targetBlock();
+    }
+    // Disconnect any children that don't belong.
+    for (var i = 0; i < this.itemCount_; i++) {
+      var connection = this.getInput('ADD' + i).connection.targetConnection;
+      if (connection && connections.indexOf(connection) == -1) {
+        connection.disconnect();
+      }
+    }
+    this.itemCount_ = connections.length;
+    this.updateShape_();
+    // Reconnect any child blocks.
+    for (var i = 0; i < this.itemCount_; i++) {
+      Blockly.Mutator.reconnect(connections[i], this, 'ADD' + i);
+    }
+  },
+  /**
+   * Store pointers to any connected child blocks.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  saveConnections: function(containerBlock) {
+    var itemBlock = containerBlock.getInputTargetBlock('STACK');
+    var i = 0;
+    while (itemBlock) {
+      var input = this.getInput('ADD' + i);
+      itemBlock.valueConnection_ = input && input.connection.targetConnection;
+      i++;
+      itemBlock = itemBlock.nextConnection &&
+          itemBlock.nextConnection.targetBlock();
+    }
+  },
+  /**
+   * Modify this block to have the correct number of inputs.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateShape_: function() {
+    if (this.itemCount_ && this.getInput('EMPTY')) {
+      this.removeInput('EMPTY');
+    } else if (!this.itemCount_ && !this.getInput('EMPTY')) {
+      this.appendDummyInput('EMPTY')
+          .appendField(Blockly.Msg['LISTS_CREATE_EMPTY_TITLE']);
+    }
+    // Add new inputs.
+    for (var i = 0; i < this.itemCount_; i++) {
+      if (!this.getInput('ADD' + i)) {
+        var input = this.appendValueInput('ADD' + i)
+            .setAlign(Blockly.ALIGN_RIGHT);
+        if (i == 0) {
+          input.appendField(Blockly.Msg['LISTS_CREATE_WITH_INPUT_WITH']);
+        }
+      }
+    }
+    // Remove deleted inputs.
+    while (this.getInput('ADD' + i)) {
+      this.removeInput('ADD' + i);
+      i++;
+    }
+  }
+};
+
+Blockly.Blocks['lists_create_with_container'] = {
+  /**
+   * Mutator block for list container.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.setStyle('list_blocks');
+    this.appendDummyInput()
+        .appendField(Blockly.Msg['LISTS_CREATE_WITH_CONTAINER_TITLE_ADD']);
+    this.appendStatementInput('STACK');
+    this.setTooltip(Blockly.Msg['LISTS_CREATE_WITH_CONTAINER_TOOLTIP']);
+    this.contextMenu = false;
+  }
+};
+
+Blockly.Blocks['lists_create_with_item'] = {
+  /**
+   * Mutator block for adding items.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.setStyle('list_blocks');
+    this.appendDummyInput()
+        .appendField(Blockly.Msg['LISTS_CREATE_WITH_ITEM_TITLE']);
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setTooltip(Blockly.Msg['LISTS_CREATE_WITH_ITEM_TOOLTIP']);
+    this.contextMenu = false;
+  }
+};
+
+Blockly.Blocks['lists_indexOf'] = {
+  /**
+   * Block for finding an item in the list.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    var OPERATORS =
+        [
+          [Blockly.Msg['LISTS_INDEX_OF_FIRST'], 'FIRST'],
+          [Blockly.Msg['LISTS_INDEX_OF_LAST'], 'LAST']
+        ];
+    this.setHelpUrl(Blockly.Msg['LISTS_INDEX_OF_HELPURL']);
+    this.setStyle('list_blocks');
+    this.setOutput(true, 'Number');
+    this.appendValueInput('VALUE')
+        .setCheck('Array')
+        .appendField(Blockly.Msg['LISTS_INDEX_OF_INPUT_IN_LIST']);
+    this.appendValueInput('FIND')
+        .appendField(new Blockly.FieldDropdown(OPERATORS), 'END');
+    this.setInputsInline(true);
+    // Assign 'this' to a variable for use in the tooltip closure below.
+    var thisBlock = this;
+    this.setTooltip(function() {
+      return Blockly.Msg['LISTS_INDEX_OF_TOOLTIP'].replace('%1',
+          thisBlock.workspace.options.oneBasedIndex ? '0' : '-1');
+    });
+  }
+};
+
+Blockly.Blocks['lists_getIndex'] = {
+  /**
+   * Block for getting element at index.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    var MODE =
+        [
+          [Blockly.Msg['LISTS_GET_INDEX_GET'], 'GET'],
+          [Blockly.Msg['LISTS_GET_INDEX_GET_REMOVE'], 'GET_REMOVE'],
+          [Blockly.Msg['LISTS_GET_INDEX_REMOVE'], 'REMOVE']
+        ];
+    this.WHERE_OPTIONS =
+        [
+          [Blockly.Msg['LISTS_GET_INDEX_FROM_START'], 'FROM_START'],
+          [Blockly.Msg['LISTS_GET_INDEX_FROM_END'], 'FROM_END'],
+          [Blockly.Msg['LISTS_GET_INDEX_FIRST'], 'FIRST'],
+          [Blockly.Msg['LISTS_GET_INDEX_LAST'], 'LAST'],
+          [Blockly.Msg['LISTS_GET_INDEX_RANDOM'], 'RANDOM']
+        ];
+    this.setHelpUrl(Blockly.Msg['LISTS_GET_INDEX_HELPURL']);
+    this.setStyle('list_blocks');
+    var modeMenu = new Blockly.FieldDropdown(MODE, function(value) {
+      var isStatement = (value == 'REMOVE');
+      this.getSourceBlock().updateStatement_(isStatement);
+    });
+    this.appendValueInput('VALUE')
+        .setCheck('Array')
+        .appendField(Blockly.Msg['LISTS_GET_INDEX_INPUT_IN_LIST']);
+    this.appendDummyInput()
+        .appendField(modeMenu, 'MODE')
+        .appendField('', 'SPACE');
+    this.appendDummyInput('AT');
+    if (Blockly.Msg['LISTS_GET_INDEX_TAIL']) {
+      this.appendDummyInput('TAIL')
+          .appendField(Blockly.Msg['LISTS_GET_INDEX_TAIL']);
+    }
+    this.setInputsInline(true);
+    this.setOutput(true);
+    this.updateAt_(true);
+    // Assign 'this' to a variable for use in the tooltip closure below.
+    var thisBlock = this;
+    this.setTooltip(function() {
+      var mode = thisBlock.getFieldValue('MODE');
+      var where = thisBlock.getFieldValue('WHERE');
+      var tooltip = '';
+      switch (mode + ' ' + where) {
+        case 'GET FROM_START':
+        case 'GET FROM_END':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_GET_FROM'];
+          break;
+        case 'GET FIRST':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_GET_FIRST'];
+          break;
+        case 'GET LAST':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_GET_LAST'];
+          break;
+        case 'GET RANDOM':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_GET_RANDOM'];
+          break;
+        case 'GET_REMOVE FROM_START':
+        case 'GET_REMOVE FROM_END':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM'];
+          break;
+        case 'GET_REMOVE FIRST':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST'];
+          break;
+        case 'GET_REMOVE LAST':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST'];
+          break;
+        case 'GET_REMOVE RANDOM':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM'];
+          break;
+        case 'REMOVE FROM_START':
+        case 'REMOVE FROM_END':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM'];
+          break;
+        case 'REMOVE FIRST':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST'];
+          break;
+        case 'REMOVE LAST':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST'];
+          break;
+        case 'REMOVE RANDOM':
+          tooltip = Blockly.Msg['LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM'];
+          break;
+      }
+      if (where == 'FROM_START' || where == 'FROM_END') {
+        var msg = (where == 'FROM_START') ?
+            Blockly.Msg['LISTS_INDEX_FROM_START_TOOLTIP'] :
+            Blockly.Msg['LISTS_INDEX_FROM_END_TOOLTIP'];
+        tooltip += '  ' + msg.replace('%1',
+                thisBlock.workspace.options.oneBasedIndex ? '#1' : '#0');
+      }
+      return tooltip;
+    });
+  },
+  /**
+   * Create XML to represent whether the block is a statement or a value.
+   * Also represent whether there is an 'AT' input.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    var isStatement = !this.outputConnection;
+    container.setAttribute('statement', isStatement);
+    var isAt = this.getInput('AT').type == Blockly.INPUT_VALUE;
+    container.setAttribute('at', isAt);
+    return container;
+  },
+  /**
+   * Parse XML to restore the 'AT' input.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    // Note: Until January 2013 this block did not have mutations,
+    // so 'statement' defaults to false and 'at' defaults to true.
+    var isStatement = (xmlElement.getAttribute('statement') == 'true');
+    this.updateStatement_(isStatement);
+    var isAt = (xmlElement.getAttribute('at') != 'false');
+    this.updateAt_(isAt);
+  },
+  /**
+   * Switch between a value block and a statement block.
+   * @param {boolean} newStatement True if the block should be a statement.
+   *     False if the block should be a value.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateStatement_: function(newStatement) {
+    var oldStatement = !this.outputConnection;
+    if (newStatement != oldStatement) {
+      this.unplug(true, true);
+      if (newStatement) {
+        this.setOutput(false);
+        this.setPreviousStatement(true);
+        this.setNextStatement(true);
+      } else {
+        this.setPreviousStatement(false);
+        this.setNextStatement(false);
+        this.setOutput(true);
+      }
+    }
+  },
+  /**
+   * Create or delete an input for the numeric index.
+   * @param {boolean} isAt True if the input should exist.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateAt_: function(isAt) {
+    // Destroy old 'AT' and 'ORDINAL' inputs.
+    this.removeInput('AT');
+    this.removeInput('ORDINAL', true);
+    // Create either a value 'AT' input or a dummy input.
+    if (isAt) {
+      this.appendValueInput('AT').setCheck('Number');
+      if (Blockly.Msg['ORDINAL_NUMBER_SUFFIX']) {
+        this.appendDummyInput('ORDINAL')
+            .appendField(Blockly.Msg['ORDINAL_NUMBER_SUFFIX']);
+      }
+    } else {
+      this.appendDummyInput('AT');
+    }
+    var menu = new Blockly.FieldDropdown(this.WHERE_OPTIONS, function(value) {
+      var newAt = (value == 'FROM_START') || (value == 'FROM_END');
+      // The 'isAt' variable is available due to this function being a closure.
+      if (newAt != isAt) {
+        var block = this.getSourceBlock();
+        block.updateAt_(newAt);
+        // This menu has been destroyed and replaced.  Update the replacement.
+        block.setFieldValue(value, 'WHERE');
+        return null;
+      }
+      return undefined;
+    });
+    this.getInput('AT').appendField(menu, 'WHERE');
+    if (Blockly.Msg['LISTS_GET_INDEX_TAIL']) {
+      this.moveInputBefore('TAIL', null);
+    }
+  }
+};
+
+Blockly.Blocks['lists_setIndex'] = {
+  /**
+   * Block for setting the element at index.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    var MODE =
+        [
+          [Blockly.Msg['LISTS_SET_INDEX_SET'], 'SET'],
+          [Blockly.Msg['LISTS_SET_INDEX_INSERT'], 'INSERT']
+        ];
+    this.WHERE_OPTIONS =
+        [
+          [Blockly.Msg['LISTS_GET_INDEX_FROM_START'], 'FROM_START'],
+          [Blockly.Msg['LISTS_GET_INDEX_FROM_END'], 'FROM_END'],
+          [Blockly.Msg['LISTS_GET_INDEX_FIRST'], 'FIRST'],
+          [Blockly.Msg['LISTS_GET_INDEX_LAST'], 'LAST'],
+          [Blockly.Msg['LISTS_GET_INDEX_RANDOM'], 'RANDOM']
+        ];
+    this.setHelpUrl(Blockly.Msg['LISTS_SET_INDEX_HELPURL']);
+    this.setStyle('list_blocks');
+    this.appendValueInput('LIST')
+        .setCheck('Array')
+        .appendField(Blockly.Msg['LISTS_SET_INDEX_INPUT_IN_LIST']);
+    this.appendDummyInput()
+        .appendField(new Blockly.FieldDropdown(MODE), 'MODE')
+        .appendField('', 'SPACE');
+    this.appendDummyInput('AT');
+    this.appendValueInput('TO')
+        .appendField(Blockly.Msg['LISTS_SET_INDEX_INPUT_TO']);
+    this.setInputsInline(true);
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setTooltip(Blockly.Msg['LISTS_SET_INDEX_TOOLTIP']);
+    this.updateAt_(true);
+    // Assign 'this' to a variable for use in the tooltip closure below.
+    var thisBlock = this;
+    this.setTooltip(function() {
+      var mode = thisBlock.getFieldValue('MODE');
+      var where = thisBlock.getFieldValue('WHERE');
+      var tooltip = '';
+      switch (mode + ' ' + where) {
+        case 'SET FROM_START':
+        case 'SET FROM_END':
+          tooltip = Blockly.Msg['LISTS_SET_INDEX_TOOLTIP_SET_FROM'];
+          break;
+        case 'SET FIRST':
+          tooltip = Blockly.Msg['LISTS_SET_INDEX_TOOLTIP_SET_FIRST'];
+          break;
+        case 'SET LAST':
+          tooltip = Blockly.Msg['LISTS_SET_INDEX_TOOLTIP_SET_LAST'];
+          break;
+        case 'SET RANDOM':
+          tooltip = Blockly.Msg['LISTS_SET_INDEX_TOOLTIP_SET_RANDOM'];
+          break;
+        case 'INSERT FROM_START':
+        case 'INSERT FROM_END':
+          tooltip = Blockly.Msg['LISTS_SET_INDEX_TOOLTIP_INSERT_FROM'];
+          break;
+        case 'INSERT FIRST':
+          tooltip = Blockly.Msg['LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST'];
+          break;
+        case 'INSERT LAST':
+          tooltip = Blockly.Msg['LISTS_SET_INDEX_TOOLTIP_INSERT_LAST'];
+          break;
+        case 'INSERT RANDOM':
+          tooltip = Blockly.Msg['LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM'];
+          break;
+      }
+      if (where == 'FROM_START' || where == 'FROM_END') {
+        tooltip += '  ' + Blockly.Msg['LISTS_INDEX_FROM_START_TOOLTIP']
+            .replace('%1',
+                thisBlock.workspace.options.oneBasedIndex ? '#1' : '#0');
+      }
+      return tooltip;
+    });
+  },
+  /**
+   * Create XML to represent whether there is an 'AT' input.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    var isAt = this.getInput('AT').type == Blockly.INPUT_VALUE;
+    container.setAttribute('at', isAt);
+    return container;
+  },
+  /**
+   * Parse XML to restore the 'AT' input.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    // Note: Until January 2013 this block did not have mutations,
+    // so 'at' defaults to true.
+    var isAt = (xmlElement.getAttribute('at') != 'false');
+    this.updateAt_(isAt);
+  },
+  /**
+   * Create or delete an input for the numeric index.
+   * @param {boolean} isAt True if the input should exist.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateAt_: function(isAt) {
+    // Destroy old 'AT' and 'ORDINAL' input.
+    this.removeInput('AT');
+    this.removeInput('ORDINAL', true);
+    // Create either a value 'AT' input or a dummy input.
+    if (isAt) {
+      this.appendValueInput('AT').setCheck('Number');
+      if (Blockly.Msg['ORDINAL_NUMBER_SUFFIX']) {
+        this.appendDummyInput('ORDINAL')
+            .appendField(Blockly.Msg['ORDINAL_NUMBER_SUFFIX']);
+      }
+    } else {
+      this.appendDummyInput('AT');
+    }
+    var menu = new Blockly.FieldDropdown(this.WHERE_OPTIONS, function(value) {
+      var newAt = (value == 'FROM_START') || (value == 'FROM_END');
+      // The 'isAt' variable is available due to this function being a closure.
+      if (newAt != isAt) {
+        var block = this.getSourceBlock();
+        block.updateAt_(newAt);
+        // This menu has been destroyed and replaced.  Update the replacement.
+        block.setFieldValue(value, 'WHERE');
+        return null;
+      }
+      return undefined;
+    });
+    this.moveInputBefore('AT', 'TO');
+    if (this.getInput('ORDINAL')) {
+      this.moveInputBefore('ORDINAL', 'TO');
+    }
+
+    this.getInput('AT').appendField(menu, 'WHERE');
+  }
+};
+
+Blockly.Blocks['lists_getSublist'] = {
+  /**
+   * Block for getting sublist.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this['WHERE_OPTIONS_1'] =
+        [
+          [Blockly.Msg['LISTS_GET_SUBLIST_START_FROM_START'], 'FROM_START'],
+          [Blockly.Msg['LISTS_GET_SUBLIST_START_FROM_END'], 'FROM_END'],
+          [Blockly.Msg['LISTS_GET_SUBLIST_START_FIRST'], 'FIRST']
+        ];
+    this['WHERE_OPTIONS_2'] =
+        [
+          [Blockly.Msg['LISTS_GET_SUBLIST_END_FROM_START'], 'FROM_START'],
+          [Blockly.Msg['LISTS_GET_SUBLIST_END_FROM_END'], 'FROM_END'],
+          [Blockly.Msg['LISTS_GET_SUBLIST_END_LAST'], 'LAST']
+        ];
+    this.setHelpUrl(Blockly.Msg['LISTS_GET_SUBLIST_HELPURL']);
+    this.setStyle('list_blocks');
+    this.appendValueInput('LIST')
+        .setCheck('Array')
+        .appendField(Blockly.Msg['LISTS_GET_SUBLIST_INPUT_IN_LIST']);
+    this.appendDummyInput('AT1');
+    this.appendDummyInput('AT2');
+    if (Blockly.Msg['LISTS_GET_SUBLIST_TAIL']) {
+      this.appendDummyInput('TAIL')
+          .appendField(Blockly.Msg['LISTS_GET_SUBLIST_TAIL']);
+    }
+    this.setInputsInline(true);
+    this.setOutput(true, 'Array');
+    this.updateAt_(1, true);
+    this.updateAt_(2, true);
+    this.setTooltip(Blockly.Msg['LISTS_GET_SUBLIST_TOOLTIP']);
+  },
+  /**
+   * Create XML to represent whether there are 'AT' inputs.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    var isAt1 = this.getInput('AT1').type == Blockly.INPUT_VALUE;
+    container.setAttribute('at1', isAt1);
+    var isAt2 = this.getInput('AT2').type == Blockly.INPUT_VALUE;
+    container.setAttribute('at2', isAt2);
+    return container;
+  },
+  /**
+   * Parse XML to restore the 'AT' inputs.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    var isAt1 = (xmlElement.getAttribute('at1') == 'true');
+    var isAt2 = (xmlElement.getAttribute('at2') == 'true');
+    this.updateAt_(1, isAt1);
+    this.updateAt_(2, isAt2);
+  },
+  /**
+   * Create or delete an input for a numeric index.
+   * This block has two such inputs, independent of each other.
+   * @param {number} n Specify first or second input (1 or 2).
+   * @param {boolean} isAt True if the input should exist.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateAt_: function(n, isAt) {
+    // Create or delete an input for the numeric index.
+    // Destroy old 'AT' and 'ORDINAL' inputs.
+    this.removeInput('AT' + n);
+    this.removeInput('ORDINAL' + n, true);
+    // Create either a value 'AT' input or a dummy input.
+    if (isAt) {
+      this.appendValueInput('AT' + n).setCheck('Number');
+      if (Blockly.Msg['ORDINAL_NUMBER_SUFFIX']) {
+        this.appendDummyInput('ORDINAL' + n)
+            .appendField(Blockly.Msg['ORDINAL_NUMBER_SUFFIX']);
+      }
+    } else {
+      this.appendDummyInput('AT' + n);
+    }
+    var menu = new Blockly.FieldDropdown(this['WHERE_OPTIONS_' + n],
+        function(value) {
+          var newAt = (value == 'FROM_START') || (value == 'FROM_END');
+          // The 'isAt' variable is available due to this function being a
+          // closure.
+          if (newAt != isAt) {
+            var block = this.getSourceBlock();
+            block.updateAt_(n, newAt);
+            // This menu has been destroyed and replaced.
+            // Update the replacement.
+            block.setFieldValue(value, 'WHERE' + n);
+            return null;
+          }
+        });
+    this.getInput('AT' + n)
+        .appendField(menu, 'WHERE' + n);
+    if (n == 1) {
+      this.moveInputBefore('AT1', 'AT2');
+      if (this.getInput('ORDINAL1')) {
+        this.moveInputBefore('ORDINAL1', 'AT2');
+      }
+    }
+    if (Blockly.Msg['LISTS_GET_SUBLIST_TAIL']) {
+      this.moveInputBefore('TAIL', null);
+    }
+  }
+};
+
+Blockly.Blocks['lists_sort'] = {
+  /**
+   * Block for sorting a list.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg['LISTS_SORT_TITLE'],
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "TYPE",
+          "options": [
+            [Blockly.Msg['LISTS_SORT_TYPE_NUMERIC'], "NUMERIC"],
+            [Blockly.Msg['LISTS_SORT_TYPE_TEXT'], "TEXT"],
+            [Blockly.Msg['LISTS_SORT_TYPE_IGNORECASE'], "IGNORE_CASE"]
+          ]
+        },
+        {
+          "type": "field_dropdown",
+          "name": "DIRECTION",
+          "options": [
+            [Blockly.Msg['LISTS_SORT_ORDER_ASCENDING'], "1"],
+            [Blockly.Msg['LISTS_SORT_ORDER_DESCENDING'], "-1"]
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "LIST",
+          "check": "Array"
+        }
+      ],
+      "output": "Array",
+      "style": "list_blocks",
+      "tooltip": Blockly.Msg['LISTS_SORT_TOOLTIP'],
+      "helpUrl": Blockly.Msg['LISTS_SORT_HELPURL']
+    });
+  }
+};
+
+Blockly.Blocks['lists_split'] = {
+  /**
+   * Block for splitting text into a list, or joining a list into text.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    // Assign 'this' to a variable for use in the closures below.
+    var thisBlock = this;
+    var dropdown = new Blockly.FieldDropdown(
+        [
+          [Blockly.Msg['LISTS_SPLIT_LIST_FROM_TEXT'], 'SPLIT'],
+          [Blockly.Msg['LISTS_SPLIT_TEXT_FROM_LIST'], 'JOIN']
+        ],
+        function(newMode) {
+          thisBlock.updateType_(newMode);
+        });
+    this.setHelpUrl(Blockly.Msg['LISTS_SPLIT_HELPURL']);
+    this.setStyle('list_blocks');
+    this.appendValueInput('INPUT')
+        .setCheck('String')
+        .appendField(dropdown, 'MODE');
+    this.appendValueInput('DELIM')
+        .setCheck('String')
+        .appendField(Blockly.Msg['LISTS_SPLIT_WITH_DELIMITER']);
+    this.setInputsInline(true);
+    this.setOutput(true, 'Array');
+    this.setTooltip(function() {
+      var mode = thisBlock.getFieldValue('MODE');
+      if (mode == 'SPLIT') {
+        return Blockly.Msg['LISTS_SPLIT_TOOLTIP_SPLIT'];
+      } else if (mode == 'JOIN') {
+        return Blockly.Msg['LISTS_SPLIT_TOOLTIP_JOIN'];
+      }
+      throw Error('Unknown mode: ' + mode);
+    });
+  },
+  /**
+   * Modify this block to have the correct input and output types.
+   * @param {string} newMode Either 'SPLIT' or 'JOIN'.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateType_: function(newMode) {
+    var mode = this.getFieldValue('MODE');
+    if (mode != newMode) {
+      var inputConnection = this.getInput('INPUT').connection;
+      inputConnection.setShadowDom(null);
+      var inputBlock = inputConnection.targetBlock();
+      if (inputBlock) {
+        inputConnection.disconnect();
+        if (inputBlock.isShadow()) {
+          inputBlock.dispose();
+        } else {
+          this.bumpNeighbours();
+        }
+      }
+    }
+    if (newMode == 'SPLIT') {
+      this.outputConnection.setCheck('Array');
+      this.getInput('INPUT').setCheck('String');
+    } else {
+      this.outputConnection.setCheck('String');
+      this.getInput('INPUT').setCheck('Array');
+    }
+  },
+  /**
+   * Create XML to represent the input and output types.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    container.setAttribute('mode', this.getFieldValue('MODE'));
+    return container;
+  },
+  /**
+   * Parse XML to restore the input and output types.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    this.updateType_(xmlElement.getAttribute('mode'));
+  }
+};

blockly/blocks/logic.js

@@ -0,0 +1,635 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Logic blocks for Blockly.
+ *
+ * This file is scraped to extract a .json file of block definitions. The array
+ * passed to defineBlocksWithJsonArray(..) must be strict JSON: double quotes
+ * only, no outside references, no functions, no trailing commas, etc. The one
+ * exception is end-of-line comments, which the scraper will remove.
+ * @author q.neutron@gmail.com (Quynh Neutron)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.logic');  // Deprecated
+goog.provide('Blockly.Constants.Logic');
+
+goog.require('Blockly');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.FieldDropdown');
+goog.require('Blockly.FieldLabel');
+goog.require('Blockly.Mutator');
+
+
+/**
+ * Unused constant for the common HSV hue for all blocks in this category.
+ * @deprecated Use Blockly.Msg['LOGIC_HUE']. (2018 April 5)
+ */
+Blockly.Constants.Logic.HUE = 210;
+
+Blockly.defineBlocksWithJsonArray([  // BEGIN JSON EXTRACT
+  // Block for boolean data type: true and false.
+  {
+    "type": "logic_boolean",
+    "message0": "%1",
+    "args0": [
+      {
+        "type": "field_dropdown",
+        "name": "BOOL",
+        "options": [
+          ["%{BKY_LOGIC_BOOLEAN_TRUE}", "TRUE"],
+          ["%{BKY_LOGIC_BOOLEAN_FALSE}", "FALSE"]
+        ]
+      }
+    ],
+    "output": "Boolean",
+    "style": "logic_blocks",
+    "tooltip": "%{BKY_LOGIC_BOOLEAN_TOOLTIP}",
+    "helpUrl": "%{BKY_LOGIC_BOOLEAN_HELPURL}"
+  },
+  // Block for if/elseif/else condition.
+  {
+    "type": "controls_if",
+    "message0": "%{BKY_CONTROLS_IF_MSG_IF} %1",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "IF0",
+        "check": "Boolean"
+      }
+    ],
+    "message1": "%{BKY_CONTROLS_IF_MSG_THEN} %1",
+    "args1": [
+      {
+        "type": "input_statement",
+        "name": "DO0"
+      }
+    ],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "logic_blocks",
+    "helpUrl": "%{BKY_CONTROLS_IF_HELPURL}",
+    "mutator": "controls_if_mutator",
+    "extensions": ["controls_if_tooltip"]
+  },
+  // If/else block that does not use a mutator.
+  {
+    "type": "controls_ifelse",
+    "message0": "%{BKY_CONTROLS_IF_MSG_IF} %1",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "IF0",
+        "check": "Boolean"
+      }
+    ],
+    "message1": "%{BKY_CONTROLS_IF_MSG_THEN} %1",
+    "args1": [
+      {
+        "type": "input_statement",
+        "name": "DO0"
+      }
+    ],
+    "message2": "%{BKY_CONTROLS_IF_MSG_ELSE} %1",
+    "args2": [
+      {
+        "type": "input_statement",
+        "name": "ELSE"
+      }
+    ],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "logic_blocks",
+    "tooltip": "%{BKYCONTROLS_IF_TOOLTIP_2}",
+    "helpUrl": "%{BKY_CONTROLS_IF_HELPURL}",
+    "extensions": ["controls_if_tooltip"]
+  },
+  // Block for comparison operator.
+  {
+    "type": "logic_compare",
+    "message0": "%1 %2 %3",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "A"
+      },
+      {
+        "type": "field_dropdown",
+        "name": "OP",
+        "options": [
+          ["=", "EQ"],
+          ["\u2260", "NEQ"],
+          ["\u200F<", "LT"],
+          ["\u200F\u2264", "LTE"],
+          ["\u200F>", "GT"],
+          ["\u200F\u2265", "GTE"]
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "B"
+      }
+    ],
+    "inputsInline": true,
+    "output": "Boolean",
+    "style": "logic_blocks",
+    "helpUrl": "%{BKY_LOGIC_COMPARE_HELPURL}",
+    "extensions": ["logic_compare", "logic_op_tooltip"]
+  },
+  // Block for logical operations: 'and', 'or'.
+  {
+    "type": "logic_operation",
+    "message0": "%1 %2 %3",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "A",
+        "check": "Boolean"
+      },
+      {
+        "type": "field_dropdown",
+        "name": "OP",
+        "options": [
+          ["%{BKY_LOGIC_OPERATION_AND}", "AND"],
+          ["%{BKY_LOGIC_OPERATION_OR}", "OR"]
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "B",
+        "check": "Boolean"
+      }
+    ],
+    "inputsInline": true,
+    "output": "Boolean",
+    "style": "logic_blocks",
+    "helpUrl": "%{BKY_LOGIC_OPERATION_HELPURL}",
+    "extensions": ["logic_op_tooltip"]
+  },
+  // Block for negation.
+  {
+    "type": "logic_negate",
+    "message0": "%{BKY_LOGIC_NEGATE_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "BOOL",
+        "check": "Boolean"
+      }
+    ],
+    "output": "Boolean",
+    "style": "logic_blocks",
+    "tooltip": "%{BKY_LOGIC_NEGATE_TOOLTIP}",
+    "helpUrl": "%{BKY_LOGIC_NEGATE_HELPURL}"
+  },
+  // Block for null data type.
+  {
+    "type": "logic_null",
+    "message0": "%{BKY_LOGIC_NULL}",
+    "output": null,
+    "style": "logic_blocks",
+    "tooltip": "%{BKY_LOGIC_NULL_TOOLTIP}",
+    "helpUrl": "%{BKY_LOGIC_NULL_HELPURL}"
+  },
+  // Block for ternary operator.
+  {
+    "type": "logic_ternary",
+    "message0": "%{BKY_LOGIC_TERNARY_CONDITION} %1",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "IF",
+        "check": "Boolean"
+      }
+    ],
+    "message1": "%{BKY_LOGIC_TERNARY_IF_TRUE} %1",
+    "args1": [
+      {
+        "type": "input_value",
+        "name": "THEN"
+      }
+    ],
+    "message2": "%{BKY_LOGIC_TERNARY_IF_FALSE} %1",
+    "args2": [
+      {
+        "type": "input_value",
+        "name": "ELSE"
+      }
+    ],
+    "output": null,
+    "style": "logic_blocks",
+    "tooltip": "%{BKY_LOGIC_TERNARY_TOOLTIP}",
+    "helpUrl": "%{BKY_LOGIC_TERNARY_HELPURL}",
+    "extensions": ["logic_ternary"]
+  }
+]);  // END JSON EXTRACT (Do not delete this comment.)
+
+Blockly.defineBlocksWithJsonArray([ // Mutator blocks. Do not extract.
+  // Block representing the if statement in the controls_if mutator.
+  {
+    "type": "controls_if_if",
+    "message0": "%{BKY_CONTROLS_IF_IF_TITLE_IF}",
+    "nextStatement": null,
+    "enableContextMenu": false,
+    "style": "logic_blocks",
+    "tooltip": "%{BKY_CONTROLS_IF_IF_TOOLTIP}"
+  },
+  // Block representing the else-if statement in the controls_if mutator.
+  {
+    "type": "controls_if_elseif",
+    "message0": "%{BKY_CONTROLS_IF_ELSEIF_TITLE_ELSEIF}",
+    "previousStatement": null,
+    "nextStatement": null,
+    "enableContextMenu": false,
+    "style": "logic_blocks",
+    "tooltip": "%{BKY_CONTROLS_IF_ELSEIF_TOOLTIP}"
+  },
+  // Block representing the else statement in the controls_if mutator.
+  {
+    "type": "controls_if_else",
+    "message0": "%{BKY_CONTROLS_IF_ELSE_TITLE_ELSE}",
+    "previousStatement": null,
+    "enableContextMenu": false,
+    "style": "logic_blocks",
+    "tooltip": "%{BKY_CONTROLS_IF_ELSE_TOOLTIP}"
+  }
+]);
+
+/**
+ * Tooltip text, keyed by block OP value. Used by logic_compare and
+ * logic_operation blocks.
+ * @see {Blockly.Extensions#buildTooltipForDropdown}
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Logic.TOOLTIPS_BY_OP = {
+  // logic_compare
+  'EQ': '%{BKY_LOGIC_COMPARE_TOOLTIP_EQ}',
+  'NEQ': '%{BKY_LOGIC_COMPARE_TOOLTIP_NEQ}',
+  'LT': '%{BKY_LOGIC_COMPARE_TOOLTIP_LT}',
+  'LTE': '%{BKY_LOGIC_COMPARE_TOOLTIP_LTE}',
+  'GT': '%{BKY_LOGIC_COMPARE_TOOLTIP_GT}',
+  'GTE': '%{BKY_LOGIC_COMPARE_TOOLTIP_GTE}',
+
+  // logic_operation
+  'AND': '%{BKY_LOGIC_OPERATION_TOOLTIP_AND}',
+  'OR': '%{BKY_LOGIC_OPERATION_TOOLTIP_OR}'
+};
+
+Blockly.Extensions.register('logic_op_tooltip',
+    Blockly.Extensions.buildTooltipForDropdown(
+        'OP', Blockly.Constants.Logic.TOOLTIPS_BY_OP));
+
+/**
+ * Mutator methods added to controls_if blocks.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN = {
+  elseifCount_: 0,
+  elseCount_: 0,
+
+  /**
+   * Don't automatically add STATEMENT_PREFIX and STATEMENT_SUFFIX to generated
+   * code.  These will be handled manually in this block's generators.
+   */
+  suppressPrefixSuffix: true,
+
+  /**
+   * Create XML to represent the number of else-if and else inputs.
+   * @return {Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    if (!this.elseifCount_ && !this.elseCount_) {
+      return null;
+    }
+    var container = Blockly.utils.xml.createElement('mutation');
+    if (this.elseifCount_) {
+      container.setAttribute('elseif', this.elseifCount_);
+    }
+    if (this.elseCount_) {
+      container.setAttribute('else', 1);
+    }
+    return container;
+  },
+  /**
+   * Parse XML to restore the else-if and else inputs.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    this.elseifCount_ = parseInt(xmlElement.getAttribute('elseif'), 10) || 0;
+    this.elseCount_ = parseInt(xmlElement.getAttribute('else'), 10) || 0;
+    this.rebuildShape_();
+  },
+  /**
+   * Populate the mutator's dialog with this block's components.
+   * @param {!Blockly.Workspace} workspace Mutator's workspace.
+   * @return {!Blockly.Block} Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  decompose: function(workspace) {
+    var containerBlock = workspace.newBlock('controls_if_if');
+    containerBlock.initSvg();
+    var connection = containerBlock.nextConnection;
+    for (var i = 1; i <= this.elseifCount_; i++) {
+      var elseifBlock = workspace.newBlock('controls_if_elseif');
+      elseifBlock.initSvg();
+      connection.connect(elseifBlock.previousConnection);
+      connection = elseifBlock.nextConnection;
+    }
+    if (this.elseCount_) {
+      var elseBlock = workspace.newBlock('controls_if_else');
+      elseBlock.initSvg();
+      connection.connect(elseBlock.previousConnection);
+    }
+    return containerBlock;
+  },
+  /**
+   * Reconfigure this block based on the mutator dialog's components.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  compose: function(containerBlock) {
+    var clauseBlock = containerBlock.nextConnection.targetBlock();
+    // Count number of inputs.
+    this.elseifCount_ = 0;
+    this.elseCount_ = 0;
+    var valueConnections = [null];
+    var statementConnections = [null];
+    var elseStatementConnection = null;
+    while (clauseBlock && !clauseBlock.isInsertionMarker()) {
+      switch (clauseBlock.type) {
+        case 'controls_if_elseif':
+          this.elseifCount_++;
+          valueConnections.push(clauseBlock.valueConnection_);
+          statementConnections.push(clauseBlock.statementConnection_);
+          break;
+        case 'controls_if_else':
+          this.elseCount_++;
+          elseStatementConnection = clauseBlock.statementConnection_;
+          break;
+        default:
+          throw TypeError('Unknown block type: ' + clauseBlock.type);
+      }
+      clauseBlock = clauseBlock.nextConnection &&
+          clauseBlock.nextConnection.targetBlock();
+    }
+    this.updateShape_();
+    // Reconnect any child blocks.
+    this.reconnectChildBlocks_(valueConnections, statementConnections,
+        elseStatementConnection);
+  },
+  /**
+   * Store pointers to any connected child blocks.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  saveConnections: function(containerBlock) {
+    var clauseBlock = containerBlock.nextConnection.targetBlock();
+    var i = 1;
+    while (clauseBlock) {
+      switch (clauseBlock.type) {
+        case 'controls_if_elseif':
+          var inputIf = this.getInput('IF' + i);
+          var inputDo = this.getInput('DO' + i);
+          clauseBlock.valueConnection_ =
+              inputIf && inputIf.connection.targetConnection;
+          clauseBlock.statementConnection_ =
+              inputDo && inputDo.connection.targetConnection;
+          i++;
+          break;
+        case 'controls_if_else':
+          var inputDo = this.getInput('ELSE');
+          clauseBlock.statementConnection_ =
+              inputDo && inputDo.connection.targetConnection;
+          break;
+        default:
+          throw TypeError('Unknown block type: ' + clauseBlock.type);
+      }
+      clauseBlock = clauseBlock.nextConnection &&
+          clauseBlock.nextConnection.targetBlock();
+    }
+  },
+  /**
+   * Reconstructs the block with all child blocks attached.
+   * @this {Blockly.Block}
+   */
+  rebuildShape_: function() {
+    var valueConnections = [null];
+    var statementConnections = [null];
+    var elseStatementConnection = null;
+
+    if (this.getInput('ELSE')) {
+      elseStatementConnection = this.getInput('ELSE').connection.targetConnection;
+    }
+    var i = 1;
+    while (this.getInput('IF' + i)) {
+      var inputIf = this.getInput('IF' + i);
+      var inputDo = this.getInput('DO' + i);
+      valueConnections.push(inputIf.connection.targetConnection);
+      statementConnections.push(inputDo.connection.targetConnection);
+      i++;
+    }
+    this.updateShape_();
+    this.reconnectChildBlocks_(valueConnections, statementConnections,
+        elseStatementConnection);
+  },
+  /**
+   * Modify this block to have the correct number of inputs.
+   * @this {Blockly.Block}
+   * @private
+   */
+  updateShape_: function() {
+    // Delete everything.
+    if (this.getInput('ELSE')) {
+      this.removeInput('ELSE');
+    }
+    var i = 1;
+    while (this.getInput('IF' + i)) {
+      this.removeInput('IF' + i);
+      this.removeInput('DO' + i);
+      i++;
+    }
+    // Rebuild block.
+    for (i = 1; i <= this.elseifCount_; i++) {
+      this.appendValueInput('IF' + i)
+          .setCheck('Boolean')
+          .appendField(Blockly.Msg['CONTROLS_IF_MSG_ELSEIF']);
+      this.appendStatementInput('DO' + i)
+          .appendField(Blockly.Msg['CONTROLS_IF_MSG_THEN']);
+    }
+    if (this.elseCount_) {
+      this.appendStatementInput('ELSE')
+          .appendField(Blockly.Msg['CONTROLS_IF_MSG_ELSE']);
+    }
+  },
+  /**
+   * Reconnects child blocks.
+   * @param {!Array<?Blockly.RenderedConnection>} valueConnections List of
+   * value connections for 'if' input.
+   * @param {!Array<?Blockly.RenderedConnection>} statementConnections List of
+   * statement connections for 'do' input.
+   * @param {?Blockly.RenderedConnection} elseStatementConnection Statement
+   * connection for else input.
+   * @this {Blockly.Block}
+   */
+  reconnectChildBlocks_: function(valueConnections, statementConnections,
+      elseStatementConnection) {
+    for (var i = 1; i <= this.elseifCount_; i++) {
+      Blockly.Mutator.reconnect(valueConnections[i], this, 'IF' + i);
+      Blockly.Mutator.reconnect(statementConnections[i], this, 'DO' + i);
+    }
+    Blockly.Mutator.reconnect(elseStatementConnection, this, 'ELSE');
+  }
+};
+
+Blockly.Extensions.registerMutator('controls_if_mutator',
+    Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN, null,
+    ['controls_if_elseif', 'controls_if_else']);
+/**
+ * "controls_if" extension function. Adds mutator, shape updating methods, and
+ * dynamic tooltip to "controls_if" blocks.
+ * @this {Blockly.Block}
+ * @package
+ */
+Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION = function() {
+
+  this.setTooltip(function() {
+    if (!this.elseifCount_ && !this.elseCount_) {
+      return Blockly.Msg['CONTROLS_IF_TOOLTIP_1'];
+    } else if (!this.elseifCount_ && this.elseCount_) {
+      return Blockly.Msg['CONTROLS_IF_TOOLTIP_2'];
+    } else if (this.elseifCount_ && !this.elseCount_) {
+      return Blockly.Msg['CONTROLS_IF_TOOLTIP_3'];
+    } else if (this.elseifCount_ && this.elseCount_) {
+      return Blockly.Msg['CONTROLS_IF_TOOLTIP_4'];
+    }
+    return '';
+  }.bind(this));
+};
+
+Blockly.Extensions.register('controls_if_tooltip',
+    Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION);
+
+/**
+ * Adds dynamic type validation for the left and right sides of a logic_compare
+ * block.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN = {
+  /**
+   * Called whenever anything on the workspace changes.
+   * Prevent mismatched types from being compared.
+   * @param {!Blockly.Events.Abstract} e Change event.
+   * @this {Blockly.Block}
+   */
+  onchange: function(e) {
+    if (!this.prevBlocks_) {
+      this.prevBlocks_ = [null, null];
+    }
+
+    var blockA = this.getInputTargetBlock('A');
+    var blockB = this.getInputTargetBlock('B');
+    // Disconnect blocks that existed prior to this change if they don't match.
+    if (blockA && blockB &&
+      !this.workspace.connectionChecker.doTypeChecks(
+          blockA.outputConnection, blockB.outputConnection)) {
+      // Mismatch between two inputs.  Revert the block connections,
+      // bumping away the newly connected block(s).
+      Blockly.Events.setGroup(e.group);
+      var prevA = this.prevBlocks_[0];
+      if (prevA !== blockA) {
+        blockA.unplug();
+        if (prevA && !prevA.isDisposed() && !prevA.isShadow()) {
+          // The shadow block is automatically replaced during unplug().
+          this.getInput('A').connection.connect(prevA.outputConnection);
+        }
+      }
+      var prevB = this.prevBlocks_[1];
+      if (prevB !== blockB) {
+        blockB.unplug();
+        if (prevB && !prevB.isDisposed() && !prevB.isShadow()) {
+          // The shadow block is automatically replaced during unplug().
+          this.getInput('B').connection.connect(prevB.outputConnection);
+        }
+      }
+      this.bumpNeighbours();
+      Blockly.Events.setGroup(false);
+    }
+    this.prevBlocks_[0] = this.getInputTargetBlock('A');
+    this.prevBlocks_[1] = this.getInputTargetBlock('B');
+  }
+};
+
+/**
+ * "logic_compare" extension function. Adds type left and right side type
+ * checking to "logic_compare" blocks.
+ * @this {Blockly.Block}
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION = function() {
+  // Add onchange handler to ensure types are compatible.
+  this.mixin(Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN);
+};
+
+Blockly.Extensions.register('logic_compare',
+    Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION);
+
+/**
+ * Adds type coordination between inputs and output.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN = {
+  prevParentConnection_: null,
+
+  /**
+   * Called whenever anything on the workspace changes.
+   * Prevent mismatched types.
+   * @param {!Blockly.Events.Abstract} e Change event.
+   * @this {Blockly.Block}
+   */
+  onchange: function(e) {
+    var blockA = this.getInputTargetBlock('THEN');
+    var blockB = this.getInputTargetBlock('ELSE');
+    var parentConnection = this.outputConnection.targetConnection;
+    // Disconnect blocks that existed prior to this change if they don't match.
+    if ((blockA || blockB) && parentConnection) {
+      for (var i = 0; i < 2; i++) {
+        var block = (i == 1) ? blockA : blockB;
+        if (block &&
+            !block.workspace.connectionChecker.doTypeChecks(
+                block.outputConnection, parentConnection)) {
+          // Ensure that any disconnections are grouped with the causing event.
+          Blockly.Events.setGroup(e.group);
+          if (parentConnection === this.prevParentConnection_) {
+            this.unplug();
+            parentConnection.getSourceBlock().bumpNeighbours();
+          } else {
+            block.unplug();
+            block.bumpNeighbours();
+          }
+          Blockly.Events.setGroup(false);
+        }
+      }
+    }
+    this.prevParentConnection_ = parentConnection;
+  }
+};
+
+Blockly.Extensions.registerMixin('logic_ternary',
+    Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN);

blockly/blocks/loops.js

@@ -0,0 +1,356 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Loop blocks for Blockly.
+ *
+ * This file is scraped to extract a .json file of block definitions. The array
+ * passed to defineBlocksWithJsonArray(..) must be strict JSON: double quotes
+ * only, no outside references, no functions, no trailing commas, etc. The one
+ * exception is end-of-line comments, which the scraper will remove.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.loops');  // Deprecated
+goog.provide('Blockly.Constants.Loops');
+
+goog.require('Blockly');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.FieldDropdown');
+goog.require('Blockly.FieldLabel');
+goog.require('Blockly.FieldNumber');
+goog.require('Blockly.FieldVariable');
+goog.require('Blockly.Warning');
+
+
+/**
+ * Unused constant for the common HSV hue for all blocks in this category.
+ * @deprecated Use Blockly.Msg['LOOPS_HUE']. (2018 April 5)
+ */
+Blockly.Constants.Loops.HUE = 120;
+
+Blockly.defineBlocksWithJsonArray([  // BEGIN JSON EXTRACT
+  // Block for repeat n times (external number).
+  {
+    "type": "controls_repeat_ext",
+    "message0": "%{BKY_CONTROLS_REPEAT_TITLE}",
+    "args0": [{
+      "type": "input_value",
+      "name": "TIMES",
+      "check": "Number"
+    }],
+    "message1": "%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",
+    "args1": [{
+      "type": "input_statement",
+      "name": "DO"
+    }],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "loop_blocks",
+    "tooltip": "%{BKY_CONTROLS_REPEAT_TOOLTIP}",
+    "helpUrl": "%{BKY_CONTROLS_REPEAT_HELPURL}"
+  },
+  // Block for repeat n times (internal number).
+  // The 'controls_repeat_ext' block is preferred as it is more flexible.
+  {
+    "type": "controls_repeat",
+    "message0": "%{BKY_CONTROLS_REPEAT_TITLE}",
+    "args0": [{
+      "type": "field_number",
+      "name": "TIMES",
+      "value": 10,
+      "min": 0,
+      "precision": 1
+    }],
+    "message1": "%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",
+    "args1": [{
+      "type": "input_statement",
+      "name": "DO"
+    }],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "loop_blocks",
+    "tooltip": "%{BKY_CONTROLS_REPEAT_TOOLTIP}",
+    "helpUrl": "%{BKY_CONTROLS_REPEAT_HELPURL}"
+  },
+  // Block for 'do while/until' loop.
+  {
+    "type": "controls_whileUntil",
+    "message0": "%1 %2",
+    "args0": [
+      {
+        "type": "field_dropdown",
+        "name": "MODE",
+        "options": [
+          ["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_WHILE}", "WHILE"],
+          ["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_UNTIL}", "UNTIL"]
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "BOOL",
+        "check": "Boolean"
+      }
+    ],
+    "message1": "%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",
+    "args1": [{
+      "type": "input_statement",
+      "name": "DO"
+    }],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "loop_blocks",
+    "helpUrl": "%{BKY_CONTROLS_WHILEUNTIL_HELPURL}",
+    "extensions": ["controls_whileUntil_tooltip"]
+  },
+  // Block for 'for' loop.
+  {
+    "type": "controls_for",
+    "message0": "%{BKY_CONTROLS_FOR_TITLE}",
+    "args0": [
+      {
+        "type": "field_variable",
+        "name": "VAR",
+        "variable": null
+      },
+      {
+        "type": "input_value",
+        "name": "FROM",
+        "check": "Number",
+        "align": "RIGHT"
+      },
+      {
+        "type": "input_value",
+        "name": "TO",
+        "check": "Number",
+        "align": "RIGHT"
+      },
+      {
+        "type": "input_value",
+        "name": "BY",
+        "check": "Number",
+        "align": "RIGHT"
+      }
+    ],
+    "message1": "%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",
+    "args1": [{
+      "type": "input_statement",
+      "name": "DO"
+    }],
+    "inputsInline": true,
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "loop_blocks",
+    "helpUrl": "%{BKY_CONTROLS_FOR_HELPURL}",
+    "extensions": [
+      "contextMenu_newGetVariableBlock",
+      "controls_for_tooltip"
+    ]
+  },
+  // Block for 'for each' loop.
+  {
+    "type": "controls_forEach",
+    "message0": "%{BKY_CONTROLS_FOREACH_TITLE}",
+    "args0": [
+      {
+        "type": "field_variable",
+        "name": "VAR",
+        "variable": null
+      },
+      {
+        "type": "input_value",
+        "name": "LIST",
+        "check": "Array"
+      }
+    ],
+    "message1": "%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",
+    "args1": [{
+      "type": "input_statement",
+      "name": "DO"
+    }],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "loop_blocks",
+    "helpUrl": "%{BKY_CONTROLS_FOREACH_HELPURL}",
+    "extensions": [
+      "contextMenu_newGetVariableBlock",
+      "controls_forEach_tooltip"
+    ]
+  },
+  // Block for flow statements: continue, break.
+  {
+    "type": "controls_flow_statements",
+    "message0": "%1",
+    "args0": [{
+      "type": "field_dropdown",
+      "name": "FLOW",
+      "options": [
+        ["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK}", "BREAK"],
+        ["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE}", "CONTINUE"]
+      ]
+    }],
+    "previousStatement": null,
+    "style": "loop_blocks",
+    "helpUrl": "%{BKY_CONTROLS_FLOW_STATEMENTS_HELPURL}",
+    "extensions": [
+      "controls_flow_tooltip",
+      "controls_flow_in_loop_check"
+    ]
+  }
+]);  // END JSON EXTRACT (Do not delete this comment.)
+
+/**
+ * Tooltips for the 'controls_whileUntil' block, keyed by MODE value.
+ * @see {Blockly.Extensions#buildTooltipForDropdown}
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS = {
+  'WHILE': '%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_WHILE}',
+  'UNTIL': '%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL}'
+};
+
+Blockly.Extensions.register('controls_whileUntil_tooltip',
+    Blockly.Extensions.buildTooltipForDropdown(
+        'MODE', Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS));
+
+/**
+ * Tooltips for the 'controls_flow_statements' block, keyed by FLOW value.
+ * @see {Blockly.Extensions#buildTooltipForDropdown}
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS = {
+  'BREAK': '%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK}',
+  'CONTINUE': '%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE}'
+};
+
+Blockly.Extensions.register('controls_flow_tooltip',
+    Blockly.Extensions.buildTooltipForDropdown(
+        'FLOW', Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS));
+
+/**
+ * Mixin to add a context menu item to create a 'variables_get' block.
+ * Used by blocks 'controls_for' and 'controls_forEach'.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN = {
+  /**
+   * Add context menu option to create getter block for the loop's variable.
+   * (customContextMenu support limited to web BlockSvg.)
+   * @param {!Array} options List of menu options to add to.
+   * @this {Blockly.Block}
+   */
+  customContextMenu: function(options) {
+    if (this.isInFlyout) {
+      return;
+    }
+    var variable = this.getField('VAR').getVariable();
+    var varName = variable.name;
+    if (!this.isCollapsed() && varName != null) {
+      var option = {enabled: true};
+      option.text =
+          Blockly.Msg['VARIABLES_SET_CREATE_GET'].replace('%1', varName);
+      var xmlField = Blockly.Variables.generateVariableFieldDom(variable);
+      var xmlBlock = Blockly.utils.xml.createElement('block');
+      xmlBlock.setAttribute('type', 'variables_get');
+      xmlBlock.appendChild(xmlField);
+      option.callback = Blockly.ContextMenu.callbackFactory(this, xmlBlock);
+      options.push(option);
+    }
+  }
+};
+
+Blockly.Extensions.registerMixin('contextMenu_newGetVariableBlock',
+    Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN);
+
+Blockly.Extensions.register('controls_for_tooltip',
+    Blockly.Extensions.buildTooltipWithFieldText(
+        '%{BKY_CONTROLS_FOR_TOOLTIP}', 'VAR'));
+
+Blockly.Extensions.register('controls_forEach_tooltip',
+    Blockly.Extensions.buildTooltipWithFieldText(
+        '%{BKY_CONTROLS_FOREACH_TOOLTIP}', 'VAR'));
+
+/**
+ * This mixin adds a check to make sure the 'controls_flow_statements' block
+ * is contained in a loop. Otherwise a warning is added to the block.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN = {
+  /**
+   * List of block types that are loops and thus do not need warnings.
+   * To add a new loop type add this to your code:
+   * Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN.LOOP_TYPES.push('custom_loop');
+   */
+  LOOP_TYPES: [
+    'controls_repeat',
+    'controls_repeat_ext',
+    'controls_forEach',
+    'controls_for',
+    'controls_whileUntil'
+  ],
+
+  /**
+   * Don't automatically add STATEMENT_PREFIX and STATEMENT_SUFFIX to generated
+   * code.  These will be handled manually in this block's generators.
+   */
+  suppressPrefixSuffix: true,
+
+  /**
+   * Is the given block enclosed (at any level) by a loop?
+   * @param {!Blockly.Block} block Current block.
+   * @return {Blockly.Block} The nearest surrounding loop, or null if none.
+   */
+  getSurroundLoop: function(block) {
+    // Is the block nested in a loop?
+    do {
+      if (Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN.LOOP_TYPES
+          .indexOf(block.type) != -1) {
+        return block;
+      }
+      block = block.getSurroundParent();
+    } while (block);
+    return null;
+  },
+
+  /**
+   * Called whenever anything on the workspace changes.
+   * Add warning if this flow block is not nested inside a loop.
+   * @param {!Blockly.Events.Abstract} e Change event.
+   * @this {Blockly.Block}
+   */
+  onchange: function(e) {
+    // Don't change state if:
+    //   * It's at the start of a drag.
+    //   * It's not a move event.
+    if (!this.workspace.isDragging || this.workspace.isDragging() ||
+        e.type != Blockly.Events.BLOCK_MOVE) {
+      return;
+    }
+    var enabled = Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN
+        .getSurroundLoop(this);
+    this.setWarningText(enabled ? null :
+        Blockly.Msg['CONTROLS_FLOW_STATEMENTS_WARNING']);
+    if (!this.isInFlyout) {
+      var group = Blockly.Events.getGroup();
+      // Makes it so the move and the disable event get undone together.
+      Blockly.Events.setGroup(e.group);
+      this.setEnabled(enabled);
+      Blockly.Events.setGroup(group);
+    }
+  }
+};
+
+Blockly.Extensions.registerMixin('controls_flow_in_loop_check',
+    Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN);

blockly/blocks/math.js

@@ -0,0 +1,566 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Math blocks for Blockly.
+ *
+ * This file is scraped to extract a .json file of block definitions. The array
+ * passed to defineBlocksWithJsonArray(..) must be strict JSON: double quotes
+ * only, no outside references, no functions, no trailing commas, etc. The one
+ * exception is end-of-line comments, which the scraper will remove.
+ * @author q.neutron@gmail.com (Quynh Neutron)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.math');  // Deprecated
+goog.provide('Blockly.Constants.Math');
+
+goog.require('Blockly');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.FieldDropdown');
+goog.require('Blockly.FieldLabel');
+goog.require('Blockly.FieldNumber');
+goog.require('Blockly.FieldVariable');
+
+
+/**
+ * Unused constant for the common HSV hue for all blocks in this category.
+ * @deprecated Use Blockly.Msg['MATH_HUE']. (2018 April 5)
+ */
+Blockly.Constants.Math.HUE = 230;
+
+Blockly.defineBlocksWithJsonArray([  // BEGIN JSON EXTRACT
+  // Block for numeric value.
+  {
+    "type": "math_number",
+    "message0": "%1",
+    "args0": [{
+      "type": "field_number",
+      "name": "NUM",
+      "value": 0
+    }],
+    "output": "Number",
+    "helpUrl": "%{BKY_MATH_NUMBER_HELPURL}",
+    "style": "math_blocks",
+    "tooltip": "%{BKY_MATH_NUMBER_TOOLTIP}",
+    "extensions": ["parent_tooltip_when_inline"]
+  },
+
+  // Block for basic arithmetic operator.
+  {
+    "type": "math_arithmetic",
+    "message0": "%1 %2 %3",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "A",
+        "check": "Number"
+      },
+      {
+        "type": "field_dropdown",
+        "name": "OP",
+        "options": [
+          ["%{BKY_MATH_ADDITION_SYMBOL}", "ADD"],
+          ["%{BKY_MATH_SUBTRACTION_SYMBOL}", "MINUS"],
+          ["%{BKY_MATH_MULTIPLICATION_SYMBOL}", "MULTIPLY"],
+          ["%{BKY_MATH_DIVISION_SYMBOL}", "DIVIDE"],
+          ["%{BKY_MATH_POWER_SYMBOL}", "POWER"]
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "B",
+        "check": "Number"
+      }
+    ],
+    "inputsInline": true,
+    "output": "Number",
+    "style": "math_blocks",
+    "helpUrl": "%{BKY_MATH_ARITHMETIC_HELPURL}",
+    "extensions": ["math_op_tooltip"]
+  },
+
+  // Block for advanced math operators with single operand.
+  {
+    "type": "math_single",
+    "message0": "%1 %2",
+    "args0": [
+      {
+        "type": "field_dropdown",
+        "name": "OP",
+        "options": [
+          ["%{BKY_MATH_SINGLE_OP_ROOT}", 'ROOT'],
+          ["%{BKY_MATH_SINGLE_OP_ABSOLUTE}", 'ABS'],
+          ['-', 'NEG'],
+          ['ln', 'LN'],
+          ['log10', 'LOG10'],
+          ['e^', 'EXP'],
+          ['10^', 'POW10']
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "NUM",
+        "check": "Number"
+      }
+    ],
+    "output": "Number",
+    "style": "math_blocks",
+    "helpUrl": "%{BKY_MATH_SINGLE_HELPURL}",
+    "extensions": ["math_op_tooltip"]
+  },
+
+  // Block for trigonometry operators.
+  {
+    "type": "math_trig",
+    "message0": "%1 %2",
+    "args0": [
+      {
+        "type": "field_dropdown",
+        "name": "OP",
+        "options": [
+          ["%{BKY_MATH_TRIG_SIN}", "SIN"],
+          ["%{BKY_MATH_TRIG_COS}", "COS"],
+          ["%{BKY_MATH_TRIG_TAN}", "TAN"],
+          ["%{BKY_MATH_TRIG_ASIN}", "ASIN"],
+          ["%{BKY_MATH_TRIG_ACOS}", "ACOS"],
+          ["%{BKY_MATH_TRIG_ATAN}", "ATAN"]
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "NUM",
+        "check": "Number"
+      }
+    ],
+    "output": "Number",
+    "style": "math_blocks",
+    "helpUrl": "%{BKY_MATH_TRIG_HELPURL}",
+    "extensions": ["math_op_tooltip"]
+  },
+
+  // Block for constants: PI, E, the Golden Ratio, sqrt(2), 1/sqrt(2), INFINITY.
+  {
+    "type": "math_constant",
+    "message0": "%1",
+    "args0": [
+      {
+        "type": "field_dropdown",
+        "name": "CONSTANT",
+        "options": [
+          ["\u03c0", "PI"],
+          ["e", "E"],
+          ["\u03c6", "GOLDEN_RATIO"],
+          ["sqrt(2)", "SQRT2"],
+          ["sqrt(\u00bd)", "SQRT1_2"],
+          ["\u221e", "INFINITY"]
+        ]
+      }
+    ],
+    "output": "Number",
+    "style": "math_blocks",
+    "tooltip": "%{BKY_MATH_CONSTANT_TOOLTIP}",
+    "helpUrl": "%{BKY_MATH_CONSTANT_HELPURL}"
+  },
+
+  // Block for checking if a number is even, odd, prime, whole, positive,
+  // negative or if it is divisible by certain number.
+  {
+    "type": "math_number_property",
+    "message0": "%1 %2",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "NUMBER_TO_CHECK",
+        "check": "Number"
+      },
+      {
+        "type": "field_dropdown",
+        "name": "PROPERTY",
+        "options": [
+          ["%{BKY_MATH_IS_EVEN}", "EVEN"],
+          ["%{BKY_MATH_IS_ODD}", "ODD"],
+          ["%{BKY_MATH_IS_PRIME}", "PRIME"],
+          ["%{BKY_MATH_IS_WHOLE}", "WHOLE"],
+          ["%{BKY_MATH_IS_POSITIVE}", "POSITIVE"],
+          ["%{BKY_MATH_IS_NEGATIVE}", "NEGATIVE"],
+          ["%{BKY_MATH_IS_DIVISIBLE_BY}", "DIVISIBLE_BY"]
+        ]
+      }
+    ],
+    "inputsInline": true,
+    "output": "Boolean",
+    "style": "math_blocks",
+    "tooltip": "%{BKY_MATH_IS_TOOLTIP}",
+    "mutator": "math_is_divisibleby_mutator"
+  },
+
+  // Block for adding to a variable in place.
+  {
+    "type": "math_change",
+    "message0": "%{BKY_MATH_CHANGE_TITLE}",
+    "args0": [
+      {
+        "type": "field_variable",
+        "name": "VAR",
+        "variable": "%{BKY_MATH_CHANGE_TITLE_ITEM}"
+      },
+      {
+        "type": "input_value",
+        "name": "DELTA",
+        "check": "Number"
+      }
+    ],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "variable_blocks",
+    "helpUrl": "%{BKY_MATH_CHANGE_HELPURL}",
+    "extensions": ["math_change_tooltip"]
+  },
+
+  // Block for rounding functions.
+  {
+    "type": "math_round",
+    "message0": "%1 %2",
+    "args0": [
+      {
+        "type": "field_dropdown",
+        "name": "OP",
+        "options": [
+          ["%{BKY_MATH_ROUND_OPERATOR_ROUND}", "ROUND"],
+          ["%{BKY_MATH_ROUND_OPERATOR_ROUNDUP}", "ROUNDUP"],
+          ["%{BKY_MATH_ROUND_OPERATOR_ROUNDDOWN}", "ROUNDDOWN"]
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "NUM",
+        "check": "Number"
+      }
+    ],
+    "output": "Number",
+    "style": "math_blocks",
+    "helpUrl": "%{BKY_MATH_ROUND_HELPURL}",
+    "tooltip": "%{BKY_MATH_ROUND_TOOLTIP}"
+  },
+
+  // Block for evaluating a list of numbers to return sum, average, min, max,
+  // etc.  Some functions also work on text (min, max, mode, median).
+  {
+    "type": "math_on_list",
+    "message0": "%1 %2",
+    "args0": [
+      {
+        "type": "field_dropdown",
+        "name": "OP",
+        "options": [
+          ["%{BKY_MATH_ONLIST_OPERATOR_SUM}", "SUM"],
+          ["%{BKY_MATH_ONLIST_OPERATOR_MIN}", "MIN"],
+          ["%{BKY_MATH_ONLIST_OPERATOR_MAX}", "MAX"],
+          ["%{BKY_MATH_ONLIST_OPERATOR_AVERAGE}", "AVERAGE"],
+          ["%{BKY_MATH_ONLIST_OPERATOR_MEDIAN}", "MEDIAN"],
+          ["%{BKY_MATH_ONLIST_OPERATOR_MODE}", "MODE"],
+          ["%{BKY_MATH_ONLIST_OPERATOR_STD_DEV}", "STD_DEV"],
+          ["%{BKY_MATH_ONLIST_OPERATOR_RANDOM}", "RANDOM"]
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "LIST",
+        "check": "Array"
+      }
+    ],
+    "output": "Number",
+    "style": "math_blocks",
+    "helpUrl": "%{BKY_MATH_ONLIST_HELPURL}",
+    "mutator": "math_modes_of_list_mutator",
+    "extensions": ["math_op_tooltip"]
+  },
+
+  // Block for remainder of a division.
+  {
+    "type": "math_modulo",
+    "message0": "%{BKY_MATH_MODULO_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "DIVIDEND",
+        "check": "Number"
+      },
+      {
+        "type": "input_value",
+        "name": "DIVISOR",
+        "check": "Number"
+      }
+    ],
+    "inputsInline": true,
+    "output": "Number",
+    "style": "math_blocks",
+    "tooltip": "%{BKY_MATH_MODULO_TOOLTIP}",
+    "helpUrl": "%{BKY_MATH_MODULO_HELPURL}"
+  },
+
+  // Block for constraining a number between two limits.
+  {
+    "type": "math_constrain",
+    "message0": "%{BKY_MATH_CONSTRAIN_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "VALUE",
+        "check": "Number"
+      },
+      {
+        "type": "input_value",
+        "name": "LOW",
+        "check": "Number"
+      },
+      {
+        "type": "input_value",
+        "name": "HIGH",
+        "check": "Number"
+      }
+    ],
+    "inputsInline": true,
+    "output": "Number",
+    "style": "math_blocks",
+    "tooltip": "%{BKY_MATH_CONSTRAIN_TOOLTIP}",
+    "helpUrl": "%{BKY_MATH_CONSTRAIN_HELPURL}"
+  },
+
+  // Block for random integer between [X] and [Y].
+  {
+    "type": "math_random_int",
+    "message0": "%{BKY_MATH_RANDOM_INT_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "FROM",
+        "check": "Number"
+      },
+      {
+        "type": "input_value",
+        "name": "TO",
+        "check": "Number"
+      }
+    ],
+    "inputsInline": true,
+    "output": "Number",
+    "style": "math_blocks",
+    "tooltip": "%{BKY_MATH_RANDOM_INT_TOOLTIP}",
+    "helpUrl": "%{BKY_MATH_RANDOM_INT_HELPURL}"
+  },
+
+  // Block for random integer between [X] and [Y].
+  {
+    "type": "math_random_float",
+    "message0": "%{BKY_MATH_RANDOM_FLOAT_TITLE_RANDOM}",
+    "output": "Number",
+    "style": "math_blocks",
+    "tooltip": "%{BKY_MATH_RANDOM_FLOAT_TOOLTIP}",
+    "helpUrl": "%{BKY_MATH_RANDOM_FLOAT_HELPURL}"
+  },
+
+  // Block for calculating atan2 of [X] and [Y].
+  {
+    "type": "math_atan2",
+    "message0": "%{BKY_MATH_ATAN2_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "X",
+        "check": "Number"
+      },
+      {
+        "type": "input_value",
+        "name": "Y",
+        "check": "Number"
+      }
+    ],
+    "inputsInline": true,
+    "output": "Number",
+    "style": "math_blocks",
+    "tooltip": "%{BKY_MATH_ATAN2_TOOLTIP}",
+    "helpUrl": "%{BKY_MATH_ATAN2_HELPURL}"
+  }
+]);  // END JSON EXTRACT (Do not delete this comment.)
+
+/**
+ * Mapping of math block OP value to tooltip message for blocks
+ * math_arithmetic, math_simple, math_trig, and math_on_lists.
+ * @see {Blockly.Extensions#buildTooltipForDropdown}
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Math.TOOLTIPS_BY_OP = {
+  // math_arithmetic
+  'ADD': '%{BKY_MATH_ARITHMETIC_TOOLTIP_ADD}',
+  'MINUS': '%{BKY_MATH_ARITHMETIC_TOOLTIP_MINUS}',
+  'MULTIPLY': '%{BKY_MATH_ARITHMETIC_TOOLTIP_MULTIPLY}',
+  'DIVIDE': '%{BKY_MATH_ARITHMETIC_TOOLTIP_DIVIDE}',
+  'POWER': '%{BKY_MATH_ARITHMETIC_TOOLTIP_POWER}',
+
+  // math_simple
+  'ROOT': '%{BKY_MATH_SINGLE_TOOLTIP_ROOT}',
+  'ABS': '%{BKY_MATH_SINGLE_TOOLTIP_ABS}',
+  'NEG': '%{BKY_MATH_SINGLE_TOOLTIP_NEG}',
+  'LN': '%{BKY_MATH_SINGLE_TOOLTIP_LN}',
+  'LOG10': '%{BKY_MATH_SINGLE_TOOLTIP_LOG10}',
+  'EXP': '%{BKY_MATH_SINGLE_TOOLTIP_EXP}',
+  'POW10': '%{BKY_MATH_SINGLE_TOOLTIP_POW10}',
+
+  // math_trig
+  'SIN': '%{BKY_MATH_TRIG_TOOLTIP_SIN}',
+  'COS': '%{BKY_MATH_TRIG_TOOLTIP_COS}',
+  'TAN': '%{BKY_MATH_TRIG_TOOLTIP_TAN}',
+  'ASIN': '%{BKY_MATH_TRIG_TOOLTIP_ASIN}',
+  'ACOS': '%{BKY_MATH_TRIG_TOOLTIP_ACOS}',
+  'ATAN': '%{BKY_MATH_TRIG_TOOLTIP_ATAN}',
+
+  // math_on_lists
+  'SUM': '%{BKY_MATH_ONLIST_TOOLTIP_SUM}',
+  'MIN': '%{BKY_MATH_ONLIST_TOOLTIP_MIN}',
+  'MAX': '%{BKY_MATH_ONLIST_TOOLTIP_MAX}',
+  'AVERAGE': '%{BKY_MATH_ONLIST_TOOLTIP_AVERAGE}',
+  'MEDIAN': '%{BKY_MATH_ONLIST_TOOLTIP_MEDIAN}',
+  'MODE': '%{BKY_MATH_ONLIST_TOOLTIP_MODE}',
+  'STD_DEV': '%{BKY_MATH_ONLIST_TOOLTIP_STD_DEV}',
+  'RANDOM': '%{BKY_MATH_ONLIST_TOOLTIP_RANDOM}'
+};
+
+Blockly.Extensions.register('math_op_tooltip',
+    Blockly.Extensions.buildTooltipForDropdown(
+        'OP', Blockly.Constants.Math.TOOLTIPS_BY_OP));
+
+
+/**
+ * Mixin for mutator functions in the 'math_is_divisibleby_mutator'
+ * extension.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ */
+Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN = {
+  /**
+   * Create XML to represent whether the 'divisorInput' should be present.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    var divisorInput = (this.getFieldValue('PROPERTY') == 'DIVISIBLE_BY');
+    container.setAttribute('divisor_input', divisorInput);
+    return container;
+  },
+  /**
+   * Parse XML to restore the 'divisorInput'.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    var divisorInput = (xmlElement.getAttribute('divisor_input') == 'true');
+    this.updateShape_(divisorInput);
+  },
+  /**
+   * Modify this block to have (or not have) an input for 'is divisible by'.
+   * @param {boolean} divisorInput True if this block has a divisor input.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateShape_: function(divisorInput) {
+    // Add or remove a Value Input.
+    var inputExists = this.getInput('DIVISOR');
+    if (divisorInput) {
+      if (!inputExists) {
+        this.appendValueInput('DIVISOR')
+            .setCheck('Number');
+      }
+    } else if (inputExists) {
+      this.removeInput('DIVISOR');
+    }
+  }
+};
+
+/**
+ * 'math_is_divisibleby_mutator' extension to the 'math_property' block that
+ * can update the block shape (add/remove divisor input) based on whether
+ * property is "divisible by".
+ * @this {Blockly.Block}
+ * @package
+ */
+Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION = function() {
+  this.getField('PROPERTY').setValidator(function(option) {
+    var divisorInput = (option == 'DIVISIBLE_BY');
+    this.getSourceBlock().updateShape_(divisorInput);
+  });
+};
+
+Blockly.Extensions.registerMutator('math_is_divisibleby_mutator',
+    Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN,
+    Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION);
+
+// Update the tooltip of 'math_change' block to reference the variable.
+Blockly.Extensions.register('math_change_tooltip',
+    Blockly.Extensions.buildTooltipWithFieldText(
+        '%{BKY_MATH_CHANGE_TOOLTIP}', 'VAR'));
+
+/**
+ * Mixin with mutator methods to support alternate output based if the
+ * 'math_on_list' block uses the 'MODE' operation.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN = {
+  /**
+   * Modify this block to have the correct output type.
+   * @param {string} newOp Either 'MODE' or some op than returns a number.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateType_: function(newOp) {
+    if (newOp == 'MODE') {
+      this.outputConnection.setCheck('Array');
+    } else {
+      this.outputConnection.setCheck('Number');
+    }
+  },
+  /**
+   * Create XML to represent the output type.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    container.setAttribute('op', this.getFieldValue('OP'));
+    return container;
+  },
+  /**
+   * Parse XML to restore the output type.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    this.updateType_(xmlElement.getAttribute('op'));
+  }
+};
+
+/**
+ * Extension to 'math_on_list' blocks that allows support of
+ * modes operation (outputs a list of numbers).
+ * @this {Blockly.Block}
+ * @package
+ */
+Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION = function() {
+  this.getField('OP').setValidator(function(newOp) {
+    this.updateType_(newOp);
+  }.bind(this));
+};
+
+Blockly.Extensions.registerMutator('math_modes_of_list_mutator',
+    Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN,
+    Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION);

blockly/blocks/text.js

@@ -0,0 +1,923 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Text blocks for Blockly.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.texts');  // Deprecated
+goog.provide('Blockly.Constants.Text');
+
+goog.require('Blockly');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.FieldDropdown');
+goog.require('Blockly.FieldImage');
+goog.require('Blockly.FieldMultilineInput');
+goog.require('Blockly.FieldTextInput');
+goog.require('Blockly.FieldVariable');
+goog.require('Blockly.Mutator');
+
+
+/**
+ * Unused constant for the common HSV hue for all blocks in this category.
+ * @deprecated Use Blockly.Msg['TEXTS_HUE']. (2018 April 5)
+ */
+Blockly.Constants.Text.HUE = 160;
+
+Blockly.defineBlocksWithJsonArray([  // BEGIN JSON EXTRACT
+  // Block for text value
+  {
+    "type": "text",
+    "message0": "%1",
+    "args0": [{
+      "type": "field_input",
+      "name": "TEXT",
+      "text": ""
+    }],
+    "output": "String",
+    "style": "text_blocks",
+    "helpUrl": "%{BKY_TEXT_TEXT_HELPURL}",
+    "tooltip": "%{BKY_TEXT_TEXT_TOOLTIP}",
+    "extensions": [
+      "text_quotes",
+      "parent_tooltip_when_inline"
+    ]
+  },
+  {
+    "type": "text_multiline",
+    "message0": "%1 %2",
+    "args0": [{
+      "type": "field_image",
+      "src": 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAARCAYAAADpP' +
+             'U2iAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAdhgAAHYYBXaITgQAAABh0RVh0' +
+             'U29mdHdhcmUAcGFpbnQubmV0IDQuMS42/U4J6AAAAP1JREFUOE+Vks0KQUEYhjm' +
+             'RIja4ABtZ2dm5A3t3Ia6AUm7CylYuQRaUhZSlLZJiQbFAyRnPN33y01HOW08z88' +
+             '73zpwzM4F3GWOCruvGIE4/rLaV+Nq1hVGMBqzhqlxgCys4wJA65xnogMHsQ5luj' +
+             'nYHTejBBCK2mE4abjCgMGhNxHgDFWjDSG07kdfVa2pZMf4ZyMAdWmpZMfYOsLiD' +
+             'MYMjlMB+K613QISRhTnITnsYg5yUd0DETmEoMlkFOeIT/A58iyK5E18BuTBfgYX' +
+             'fwNJv4P9/oEBerLylOnRhygmGdPpTTBZAPkde61lbQe4moWUvYUZYLfUNftIY4z' +
+             'wA5X2Z9AYnQrEAAAAASUVORK5CYII=',
+      "width": 12,
+      "height": 17,
+      "alt": '\u00B6'
+    },{
+      "type": "field_multilinetext",
+      "name": "TEXT",
+      "text": ""
+    }],
+    "output": "String",
+    "style": "text_blocks",
+    "helpUrl": "%{BKY_TEXT_TEXT_HELPURL}",
+    "tooltip": "%{BKY_TEXT_TEXT_TOOLTIP}",
+    "extensions": [
+      "parent_tooltip_when_inline"
+    ]
+  },
+  {
+    "type": "text_join",
+    "message0": "",
+    "output": "String",
+    "style": "text_blocks",
+    "helpUrl": "%{BKY_TEXT_JOIN_HELPURL}",
+    "tooltip": "%{BKY_TEXT_JOIN_TOOLTIP}",
+    "mutator": "text_join_mutator"
+
+  },
+  {
+    "type": "text_create_join_container",
+    "message0": "%{BKY_TEXT_CREATE_JOIN_TITLE_JOIN} %1 %2",
+    "args0": [{
+      "type": "input_dummy"
+    },
+    {
+      "type": "input_statement",
+      "name": "STACK"
+    }],
+    "style": "text_blocks",
+    "tooltip": "%{BKY_TEXT_CREATE_JOIN_TOOLTIP}",
+    "enableContextMenu": false
+  },
+  {
+    "type": "text_create_join_item",
+    "message0": "%{BKY_TEXT_CREATE_JOIN_ITEM_TITLE_ITEM}",
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "text_blocks",
+    "tooltip": "%{BKY_TEXT_CREATE_JOIN_ITEM_TOOLTIP}",
+    "enableContextMenu": false
+  },
+  {
+    "type": "text_append",
+    "message0": "%{BKY_TEXT_APPEND_TITLE}",
+    "args0": [{
+      "type": "field_variable",
+      "name": "VAR",
+      "variable": "%{BKY_TEXT_APPEND_VARIABLE}"
+    },
+    {
+      "type": "input_value",
+      "name": "TEXT"
+    }],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "text_blocks",
+    "extensions": [
+      "text_append_tooltip"
+    ]
+  },
+  {
+    "type": "text_length",
+    "message0": "%{BKY_TEXT_LENGTH_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "VALUE",
+        "check": ['String', 'Array']
+      }
+    ],
+    "output": 'Number',
+    "style": "text_blocks",
+    "tooltip": "%{BKY_TEXT_LENGTH_TOOLTIP}",
+    "helpUrl": "%{BKY_TEXT_LENGTH_HELPURL}"
+  },
+  {
+    "type": "text_isEmpty",
+    "message0": "%{BKY_TEXT_ISEMPTY_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "VALUE",
+        "check": ['String', 'Array']
+      }
+    ],
+    "output": 'Boolean',
+    "style": "text_blocks",
+    "tooltip": "%{BKY_TEXT_ISEMPTY_TOOLTIP}",
+    "helpUrl": "%{BKY_TEXT_ISEMPTY_HELPURL}"
+  },
+  {
+    "type": "text_indexOf",
+    "message0": "%{BKY_TEXT_INDEXOF_TITLE}",
+    "args0": [
+      {
+        "type": "input_value",
+        "name": "VALUE",
+        "check": "String"
+      },
+      {
+        "type": "field_dropdown",
+        "name": "END",
+        "options": [
+          [
+            "%{BKY_TEXT_INDEXOF_OPERATOR_FIRST}",
+            "FIRST"
+          ],
+          [
+            "%{BKY_TEXT_INDEXOF_OPERATOR_LAST}",
+            "LAST"
+          ]
+        ]
+      },
+      {
+        "type": "input_value",
+        "name": "FIND",
+        "check": "String"
+      }
+    ],
+    "output": "Number",
+    "style": "text_blocks",
+    "helpUrl": "%{BKY_TEXT_INDEXOF_HELPURL}",
+    "inputsInline": true,
+    "extensions": [
+      "text_indexOf_tooltip"
+    ]
+  },
+  {
+    "type": "text_charAt",
+    "message0": "%{BKY_TEXT_CHARAT_TITLE}", // "in text %1 %2"
+    "args0": [
+      {
+        "type":"input_value",
+        "name": "VALUE",
+        "check": "String"
+      },
+      {
+        "type": "field_dropdown",
+        "name": "WHERE",
+        "options": [
+          ["%{BKY_TEXT_CHARAT_FROM_START}", "FROM_START"],
+          ["%{BKY_TEXT_CHARAT_FROM_END}", "FROM_END"],
+          ["%{BKY_TEXT_CHARAT_FIRST}", "FIRST"],
+          ["%{BKY_TEXT_CHARAT_LAST}", "LAST"],
+          ["%{BKY_TEXT_CHARAT_RANDOM}", "RANDOM"]
+        ]
+      }
+    ],
+    "output": "String",
+    "style": "text_blocks",
+    "helpUrl": "%{BKY_TEXT_CHARAT_HELPURL}",
+    "inputsInline": true,
+    "mutator": "text_charAt_mutator"
+  }
+]);  // END JSON EXTRACT (Do not delete this comment.)
+
+Blockly.Blocks['text_getSubstring'] = {
+  /**
+   * Block for getting substring.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this['WHERE_OPTIONS_1'] = [
+      [Blockly.Msg['TEXT_GET_SUBSTRING_START_FROM_START'], 'FROM_START'],
+      [Blockly.Msg['TEXT_GET_SUBSTRING_START_FROM_END'], 'FROM_END'],
+      [Blockly.Msg['TEXT_GET_SUBSTRING_START_FIRST'], 'FIRST']
+    ];
+    this['WHERE_OPTIONS_2'] = [
+      [Blockly.Msg['TEXT_GET_SUBSTRING_END_FROM_START'], 'FROM_START'],
+      [Blockly.Msg['TEXT_GET_SUBSTRING_END_FROM_END'], 'FROM_END'],
+      [Blockly.Msg['TEXT_GET_SUBSTRING_END_LAST'], 'LAST']
+    ];
+    this.setHelpUrl(Blockly.Msg['TEXT_GET_SUBSTRING_HELPURL']);
+    this.setStyle('text_blocks');
+    this.appendValueInput('STRING')
+        .setCheck('String')
+        .appendField(Blockly.Msg['TEXT_GET_SUBSTRING_INPUT_IN_TEXT']);
+    this.appendDummyInput('AT1');
+    this.appendDummyInput('AT2');
+    if (Blockly.Msg['TEXT_GET_SUBSTRING_TAIL']) {
+      this.appendDummyInput('TAIL')
+          .appendField(Blockly.Msg['TEXT_GET_SUBSTRING_TAIL']);
+    }
+    this.setInputsInline(true);
+    this.setOutput(true, 'String');
+    this.updateAt_(1, true);
+    this.updateAt_(2, true);
+    this.setTooltip(Blockly.Msg['TEXT_GET_SUBSTRING_TOOLTIP']);
+  },
+  /**
+   * Create XML to represent whether there are 'AT' inputs.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    var isAt1 = this.getInput('AT1').type == Blockly.INPUT_VALUE;
+    container.setAttribute('at1', isAt1);
+    var isAt2 = this.getInput('AT2').type == Blockly.INPUT_VALUE;
+    container.setAttribute('at2', isAt2);
+    return container;
+  },
+  /**
+   * Parse XML to restore the 'AT' inputs.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    var isAt1 = (xmlElement.getAttribute('at1') == 'true');
+    var isAt2 = (xmlElement.getAttribute('at2') == 'true');
+    this.updateAt_(1, isAt1);
+    this.updateAt_(2, isAt2);
+  },
+  /**
+   * Create or delete an input for a numeric index.
+   * This block has two such inputs, independent of each other.
+   * @param {number} n Specify first or second input (1 or 2).
+   * @param {boolean} isAt True if the input should exist.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateAt_: function(n, isAt) {
+    // Create or delete an input for the numeric index.
+    // Destroy old 'AT' and 'ORDINAL' inputs.
+    this.removeInput('AT' + n);
+    this.removeInput('ORDINAL' + n, true);
+    // Create either a value 'AT' input or a dummy input.
+    if (isAt) {
+      this.appendValueInput('AT' + n).setCheck('Number');
+      if (Blockly.Msg['ORDINAL_NUMBER_SUFFIX']) {
+        this.appendDummyInput('ORDINAL' + n)
+            .appendField(Blockly.Msg['ORDINAL_NUMBER_SUFFIX']);
+      }
+    } else {
+      this.appendDummyInput('AT' + n);
+    }
+    // Move tail, if present, to end of block.
+    if (n == 2 && Blockly.Msg['TEXT_GET_SUBSTRING_TAIL']) {
+      this.removeInput('TAIL', true);
+      this.appendDummyInput('TAIL')
+          .appendField(Blockly.Msg['TEXT_GET_SUBSTRING_TAIL']);
+    }
+    var menu = new Blockly.FieldDropdown(this['WHERE_OPTIONS_' + n],
+        function(value) {
+          var newAt = (value == 'FROM_START') || (value == 'FROM_END');
+          // The 'isAt' variable is available due to this function being a
+          // closure.
+          if (newAt != isAt) {
+            var block = this.getSourceBlock();
+            block.updateAt_(n, newAt);
+            // This menu has been destroyed and replaced.
+            // Update the replacement.
+            block.setFieldValue(value, 'WHERE' + n);
+            return null;
+          }
+          return undefined;
+        });
+
+    this.getInput('AT' + n)
+        .appendField(menu, 'WHERE' + n);
+    if (n == 1) {
+      this.moveInputBefore('AT1', 'AT2');
+      if (this.getInput('ORDINAL1')) {
+        this.moveInputBefore('ORDINAL1', 'AT2');
+      }
+    }
+  }
+};
+
+Blockly.Blocks['text_changeCase'] = {
+  /**
+   * Block for changing capitalization.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    var OPERATORS = [
+      [Blockly.Msg['TEXT_CHANGECASE_OPERATOR_UPPERCASE'], 'UPPERCASE'],
+      [Blockly.Msg['TEXT_CHANGECASE_OPERATOR_LOWERCASE'], 'LOWERCASE'],
+      [Blockly.Msg['TEXT_CHANGECASE_OPERATOR_TITLECASE'], 'TITLECASE']
+    ];
+    this.setHelpUrl(Blockly.Msg['TEXT_CHANGECASE_HELPURL']);
+    this.setStyle('text_blocks');
+    this.appendValueInput('TEXT')
+        .setCheck('String')
+        .appendField(new Blockly.FieldDropdown(OPERATORS), 'CASE');
+    this.setOutput(true, 'String');
+    this.setTooltip(Blockly.Msg['TEXT_CHANGECASE_TOOLTIP']);
+  }
+};
+
+Blockly.Blocks['text_trim'] = {
+  /**
+   * Block for trimming spaces.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    var OPERATORS = [
+      [Blockly.Msg['TEXT_TRIM_OPERATOR_BOTH'], 'BOTH'],
+      [Blockly.Msg['TEXT_TRIM_OPERATOR_LEFT'], 'LEFT'],
+      [Blockly.Msg['TEXT_TRIM_OPERATOR_RIGHT'], 'RIGHT']
+    ];
+    this.setHelpUrl(Blockly.Msg['TEXT_TRIM_HELPURL']);
+    this.setStyle('text_blocks');
+    this.appendValueInput('TEXT')
+        .setCheck('String')
+        .appendField(new Blockly.FieldDropdown(OPERATORS), 'MODE');
+    this.setOutput(true, 'String');
+    this.setTooltip(Blockly.Msg['TEXT_TRIM_TOOLTIP']);
+  }
+};
+
+Blockly.Blocks['text_print'] = {
+  /**
+   * Block for print statement.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg['TEXT_PRINT_TITLE'],
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT"
+        }
+      ],
+      "previousStatement": null,
+      "nextStatement": null,
+      "style": "text_blocks",
+      "tooltip": Blockly.Msg['TEXT_PRINT_TOOLTIP'],
+      "helpUrl": Blockly.Msg['TEXT_PRINT_HELPURL']
+    });
+  }
+};
+
+Blockly.Blocks['text_prompt_ext'] = {
+  /**
+   * Block for prompt function (external message).
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    var TYPES = [
+      [Blockly.Msg['TEXT_PROMPT_TYPE_TEXT'], 'TEXT'],
+      [Blockly.Msg['TEXT_PROMPT_TYPE_NUMBER'], 'NUMBER']
+    ];
+    this.setHelpUrl(Blockly.Msg['TEXT_PROMPT_HELPURL']);
+    this.setStyle('text_blocks');
+    // Assign 'this' to a variable for use in the closures below.
+    var thisBlock = this;
+    var dropdown = new Blockly.FieldDropdown(TYPES, function(newOp) {
+      thisBlock.updateType_(newOp);
+    });
+    this.appendValueInput('TEXT')
+        .appendField(dropdown, 'TYPE');
+    this.setOutput(true, 'String');
+    this.setTooltip(function() {
+      return (thisBlock.getFieldValue('TYPE') == 'TEXT') ?
+          Blockly.Msg['TEXT_PROMPT_TOOLTIP_TEXT'] :
+          Blockly.Msg['TEXT_PROMPT_TOOLTIP_NUMBER'];
+    });
+  },
+  /**
+   * Modify this block to have the correct output type.
+   * @param {string} newOp Either 'TEXT' or 'NUMBER'.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateType_: function(newOp) {
+    this.outputConnection.setCheck(newOp == 'NUMBER' ? 'Number' : 'String');
+  },
+  /**
+   * Create XML to represent the output type.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    container.setAttribute('type', this.getFieldValue('TYPE'));
+    return container;
+  },
+  /**
+   * Parse XML to restore the output type.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    this.updateType_(xmlElement.getAttribute('type'));
+  }
+};
+
+Blockly.Blocks['text_prompt'] = {
+  /**
+   * Block for prompt function (internal message).
+   * The 'text_prompt_ext' block is preferred as it is more flexible.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);
+    var TYPES = [
+      [Blockly.Msg['TEXT_PROMPT_TYPE_TEXT'], 'TEXT'],
+      [Blockly.Msg['TEXT_PROMPT_TYPE_NUMBER'], 'NUMBER']
+    ];
+
+    // Assign 'this' to a variable for use in the closures below.
+    var thisBlock = this;
+    this.setHelpUrl(Blockly.Msg['TEXT_PROMPT_HELPURL']);
+    this.setStyle('text_blocks');
+    var dropdown = new Blockly.FieldDropdown(TYPES, function(newOp) {
+      thisBlock.updateType_(newOp);
+    });
+    this.appendDummyInput()
+        .appendField(dropdown, 'TYPE')
+        .appendField(this.newQuote_(true))
+        .appendField(new Blockly.FieldTextInput(''), 'TEXT')
+        .appendField(this.newQuote_(false));
+    this.setOutput(true, 'String');
+    this.setTooltip(function() {
+      return (thisBlock.getFieldValue('TYPE') == 'TEXT') ?
+          Blockly.Msg['TEXT_PROMPT_TOOLTIP_TEXT'] :
+          Blockly.Msg['TEXT_PROMPT_TOOLTIP_NUMBER'];
+    });
+  },
+  updateType_: Blockly.Blocks['text_prompt_ext'].updateType_,
+  mutationToDom: Blockly.Blocks['text_prompt_ext'].mutationToDom,
+  domToMutation: Blockly.Blocks['text_prompt_ext'].domToMutation
+};
+
+Blockly.Blocks['text_count'] = {
+  /**
+   * Block for counting how many times one string appears within another string.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg['TEXT_COUNT_MESSAGE0'],
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SUB",
+          "check": "String"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT",
+          "check": "String"
+        }
+      ],
+      "output": "Number",
+      "inputsInline": true,
+      "style": "text_blocks",
+      "tooltip": Blockly.Msg['TEXT_COUNT_TOOLTIP'],
+      "helpUrl": Blockly.Msg['TEXT_COUNT_HELPURL']
+    });
+  }
+};
+
+Blockly.Blocks['text_replace'] = {
+  /**
+   * Block for replacing one string with another in the text.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg['TEXT_REPLACE_MESSAGE0'],
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "FROM",
+          "check": "String"
+        },
+        {
+          "type": "input_value",
+          "name": "TO",
+          "check": "String"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT",
+          "check": "String"
+        }
+      ],
+      "output": "String",
+      "inputsInline": true,
+      "style": "text_blocks",
+      "tooltip": Blockly.Msg['TEXT_REPLACE_TOOLTIP'],
+      "helpUrl": Blockly.Msg['TEXT_REPLACE_HELPURL']
+    });
+  }
+};
+
+Blockly.Blocks['text_reverse'] = {
+  /**
+   * Block for reversing a string.
+   * @this {Blockly.Block}
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg['TEXT_REVERSE_MESSAGE0'],
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT",
+          "check": "String"
+        }
+      ],
+      "output": "String",
+      "inputsInline": true,
+      "style": "text_blocks",
+      "tooltip": Blockly.Msg['TEXT_REVERSE_TOOLTIP'],
+      "helpUrl": Blockly.Msg['TEXT_REVERSE_HELPURL']
+    });
+  }
+};
+
+/**
+ *
+ * @mixin
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Text.QUOTE_IMAGE_MIXIN = {
+  /**
+   * Image data URI of an LTR opening double quote (same as RTL closing double quote).
+   * @readonly
+   */
+  QUOTE_IMAGE_LEFT_DATAURI:
+    'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAA' +
+    'n0lEQVQI1z3OMa5BURSF4f/cQhAKjUQhuQmFNwGJEUi0RKN5rU7FHKhpjEH3TEMtkdBSCY' +
+    '1EIv8r7nFX9e29V7EBAOvu7RPjwmWGH/VuF8CyN9/OAdvqIXYLvtRaNjx9mMTDyo+NjAN1' +
+    'HNcl9ZQ5oQMM3dgDUqDo1l8DzvwmtZN7mnD+PkmLa+4mhrxVA9fRowBWmVBhFy5gYEjKMf' +
+    'z9AylsaRRgGzvZAAAAAElFTkSuQmCC',
+  /**
+   * Image data URI of an LTR closing double quote (same as RTL opening double quote).
+   * @readonly
+   */
+  QUOTE_IMAGE_RIGHT_DATAURI:
+    'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAA' +
+    'qUlEQVQI1z3KvUpCcRiA8ef9E4JNHhI0aFEacm1o0BsI0Slx8wa8gLauoDnoBhq7DcfWhg' +
+    'gONDmJJgqCPA7neJ7p934EOOKOnM8Q7PDElo/4x4lFb2DmuUjcUzS3URnGib9qaPNbuXvB' +
+    'O3sGPHJDRG6fGVdMSeWDP2q99FQdFrz26Gu5Tq7dFMzUvbXy8KXeAj57cOklgA+u1B5Aos' +
+    'lLtGIHQMaCVnwDnADZIFIrXsoXrgAAAABJRU5ErkJggg==',
+  /**
+   * Pixel width of QUOTE_IMAGE_LEFT_DATAURI and QUOTE_IMAGE_RIGHT_DATAURI.
+   * @readonly
+   */
+  QUOTE_IMAGE_WIDTH: 12,
+  /**
+   * Pixel height of QUOTE_IMAGE_LEFT_DATAURI and QUOTE_IMAGE_RIGHT_DATAURI.
+   * @readonly
+   */
+  QUOTE_IMAGE_HEIGHT: 12,
+
+  /**
+   * Inserts appropriate quote images before and after the named field.
+   * @param {string} fieldName The name of the field to wrap with quotes.
+   * @this {Blockly.Block}
+   */
+  quoteField_: function(fieldName) {
+    for (var i = 0, input; (input = this.inputList[i]); i++) {
+      for (var j = 0, field; (field = input.fieldRow[j]); j++) {
+        if (fieldName == field.name) {
+          input.insertFieldAt(j, this.newQuote_(true));
+          input.insertFieldAt(j + 2, this.newQuote_(false));
+          return;
+        }
+      }
+    }
+    console.warn('field named "' + fieldName + '" not found in ' + this.toDevString());
+  },
+
+  /**
+   * A helper function that generates a FieldImage of an opening or
+   * closing double quote. The selected quote will be adapted for RTL blocks.
+   * @param {boolean} open If the image should be open quote (“ in LTR).
+   *                       Otherwise, a closing quote is used (” in LTR).
+   * @return {!Blockly.FieldImage} The new field.
+   * @this {Blockly.Block}
+   */
+  newQuote_: function(open) {
+    var isLeft = this.RTL ? !open : open;
+    var dataUri = isLeft ?
+      this.QUOTE_IMAGE_LEFT_DATAURI :
+      this.QUOTE_IMAGE_RIGHT_DATAURI;
+    return new Blockly.FieldImage(
+        dataUri,
+        this.QUOTE_IMAGE_WIDTH,
+        this.QUOTE_IMAGE_HEIGHT,
+        isLeft ? '\u201C' : '\u201D');
+  }
+};
+
+/**
+ * Wraps TEXT field with images of double quote characters.
+ * @this {Blockly.Block}
+ */
+Blockly.Constants.Text.TEXT_QUOTES_EXTENSION = function() {
+  this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);
+  this.quoteField_('TEXT');
+};
+
+/**
+ * Mixin for mutator functions in the 'text_join_mutator' extension.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ */
+Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN = {
+  /**
+   * Create XML to represent number of text inputs.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    container.setAttribute('items', this.itemCount_);
+    return container;
+  },
+  /**
+   * Parse XML to restore the text inputs.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    this.itemCount_ = parseInt(xmlElement.getAttribute('items'), 10);
+    this.updateShape_();
+  },
+  /**
+   * Populate the mutator's dialog with this block's components.
+   * @param {!Blockly.Workspace} workspace Mutator's workspace.
+   * @return {!Blockly.Block} Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  decompose: function(workspace) {
+    var containerBlock = workspace.newBlock('text_create_join_container');
+    containerBlock.initSvg();
+    var connection = containerBlock.getInput('STACK').connection;
+    for (var i = 0; i < this.itemCount_; i++) {
+      var itemBlock = workspace.newBlock('text_create_join_item');
+      itemBlock.initSvg();
+      connection.connect(itemBlock.previousConnection);
+      connection = itemBlock.nextConnection;
+    }
+    return containerBlock;
+  },
+  /**
+   * Reconfigure this block based on the mutator dialog's components.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  compose: function(containerBlock) {
+    var itemBlock = containerBlock.getInputTargetBlock('STACK');
+    // Count number of inputs.
+    var connections = [];
+    while (itemBlock && !itemBlock.isInsertionMarker()) {
+      connections.push(itemBlock.valueConnection_);
+      itemBlock = itemBlock.nextConnection &&
+          itemBlock.nextConnection.targetBlock();
+    }
+    // Disconnect any children that don't belong.
+    for (var i = 0; i < this.itemCount_; i++) {
+      var connection = this.getInput('ADD' + i).connection.targetConnection;
+      if (connection && connections.indexOf(connection) == -1) {
+        connection.disconnect();
+      }
+    }
+    this.itemCount_ = connections.length;
+    this.updateShape_();
+    // Reconnect any child blocks.
+    for (var i = 0; i < this.itemCount_; i++) {
+      Blockly.Mutator.reconnect(connections[i], this, 'ADD' + i);
+    }
+  },
+  /**
+   * Store pointers to any connected child blocks.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this {Blockly.Block}
+   */
+  saveConnections: function(containerBlock) {
+    var itemBlock = containerBlock.getInputTargetBlock('STACK');
+    var i = 0;
+    while (itemBlock) {
+      var input = this.getInput('ADD' + i);
+      itemBlock.valueConnection_ = input && input.connection.targetConnection;
+      i++;
+      itemBlock = itemBlock.nextConnection &&
+          itemBlock.nextConnection.targetBlock();
+    }
+  },
+  /**
+   * Modify this block to have the correct number of inputs.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateShape_: function() {
+    if (this.itemCount_ && this.getInput('EMPTY')) {
+      this.removeInput('EMPTY');
+    } else if (!this.itemCount_ && !this.getInput('EMPTY')) {
+      this.appendDummyInput('EMPTY')
+          .appendField(this.newQuote_(true))
+          .appendField(this.newQuote_(false));
+    }
+    // Add new inputs.
+    for (var i = 0; i < this.itemCount_; i++) {
+      if (!this.getInput('ADD' + i)) {
+        var input = this.appendValueInput('ADD' + i)
+            .setAlign(Blockly.ALIGN_RIGHT);
+        if (i == 0) {
+          input.appendField(Blockly.Msg['TEXT_JOIN_TITLE_CREATEWITH']);
+        }
+      }
+    }
+    // Remove deleted inputs.
+    while (this.getInput('ADD' + i)) {
+      this.removeInput('ADD' + i);
+      i++;
+    }
+  }
+};
+
+/**
+ * Performs final setup of a text_join block.
+ * @this {Blockly.Block}
+ */
+Blockly.Constants.Text.TEXT_JOIN_EXTENSION = function() {
+  // Add the quote mixin for the itemCount_ = 0 case.
+  this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);
+  // Initialize the mutator values.
+  this.itemCount_ = 2;
+  this.updateShape_();
+  // Configure the mutator UI.
+  this.setMutator(new Blockly.Mutator(['text_create_join_item']));
+};
+
+// Update the tooltip of 'text_append' block to reference the variable.
+Blockly.Extensions.register('text_append_tooltip',
+    Blockly.Extensions.buildTooltipWithFieldText(
+        '%{BKY_TEXT_APPEND_TOOLTIP}', 'VAR'));
+
+/**
+ * Update the tooltip of 'text_append' block to reference the variable.
+ * @this {Blockly.Block}
+ */
+Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION = function() {
+  // Assign 'this' to a variable for use in the tooltip closure below.
+  var thisBlock = this;
+  this.setTooltip(function() {
+    return Blockly.Msg['TEXT_INDEXOF_TOOLTIP'].replace('%1',
+        thisBlock.workspace.options.oneBasedIndex ? '0' : '-1');
+  });
+};
+
+/**
+ * Mixin for mutator functions in the 'text_charAt_mutator' extension.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ */
+Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN = {
+  /**
+   * Create XML to represent whether there is an 'AT' input.
+   * @return {!Element} XML storage element.
+   * @this {Blockly.Block}
+   */
+  mutationToDom: function() {
+    var container = Blockly.utils.xml.createElement('mutation');
+    container.setAttribute('at', !!this.isAt_);
+    return container;
+  },
+  /**
+   * Parse XML to restore the 'AT' input.
+   * @param {!Element} xmlElement XML storage element.
+   * @this {Blockly.Block}
+   */
+  domToMutation: function(xmlElement) {
+    // Note: Until January 2013 this block did not have mutations,
+    // so 'at' defaults to true.
+    var isAt = (xmlElement.getAttribute('at') != 'false');
+    this.updateAt_(isAt);
+  },
+  /**
+   * Create or delete an input for the numeric index.
+   * @param {boolean} isAt True if the input should exist.
+   * @private
+   * @this {Blockly.Block}
+   */
+  updateAt_: function(isAt) {
+    // Destroy old 'AT' and 'ORDINAL' inputs.
+    this.removeInput('AT', true);
+    this.removeInput('ORDINAL', true);
+    // Create either a value 'AT' input or a dummy input.
+    if (isAt) {
+      this.appendValueInput('AT').setCheck('Number');
+      if (Blockly.Msg['ORDINAL_NUMBER_SUFFIX']) {
+        this.appendDummyInput('ORDINAL')
+            .appendField(Blockly.Msg['ORDINAL_NUMBER_SUFFIX']);
+      }
+    }
+    if (Blockly.Msg['TEXT_CHARAT_TAIL']) {
+      this.removeInput('TAIL', true);
+      this.appendDummyInput('TAIL')
+          .appendField(Blockly.Msg['TEXT_CHARAT_TAIL']);
+    }
+
+    this.isAt_ = isAt;
+  }
+};
+
+/**
+ * Does the initial mutator update of text_charAt and adds the tooltip
+ * @this {Blockly.Block}
+ */
+Blockly.Constants.Text.TEXT_CHARAT_EXTENSION = function() {
+  var dropdown = this.getField('WHERE');
+  dropdown.setValidator(function(value) {
+    var newAt = (value == 'FROM_START') || (value == 'FROM_END');
+    if (newAt != this.isAt_) {
+      var block = this.getSourceBlock();
+      block.updateAt_(newAt);
+    }
+  });
+  this.updateAt_(true);
+  // Assign 'this' to a variable for use in the tooltip closure below.
+  var thisBlock = this;
+  this.setTooltip(function() {
+    var where = thisBlock.getFieldValue('WHERE');
+    var tooltip = Blockly.Msg['TEXT_CHARAT_TOOLTIP'];
+    if (where == 'FROM_START' || where == 'FROM_END') {
+      var msg = (where == 'FROM_START') ?
+          Blockly.Msg['LISTS_INDEX_FROM_START_TOOLTIP'] :
+          Blockly.Msg['LISTS_INDEX_FROM_END_TOOLTIP'];
+      if (msg) {
+        tooltip += '  ' + msg.replace('%1',
+            thisBlock.workspace.options.oneBasedIndex ? '#1' : '#0');
+      }
+    }
+    return tooltip;
+  });
+};
+
+Blockly.Extensions.register('text_indexOf_tooltip',
+    Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION);
+
+Blockly.Extensions.register('text_quotes',
+    Blockly.Constants.Text.TEXT_QUOTES_EXTENSION);
+
+Blockly.Extensions.registerMutator('text_join_mutator',
+    Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN,
+    Blockly.Constants.Text.TEXT_JOIN_EXTENSION);
+
+Blockly.Extensions.registerMutator('text_charAt_mutator',
+    Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN,
+    Blockly.Constants.Text.TEXT_CHARAT_EXTENSION);

blockly/blocks/variables.js

@@ -0,0 +1,163 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Variable blocks for Blockly.
+
+ * This file is scraped to extract a .json file of block definitions. The array
+ * passed to defineBlocksWithJsonArray(..) must be strict JSON: double quotes
+ * only, no outside references, no functions, no trailing commas, etc. The one
+ * exception is end-of-line comments, which the scraper will remove.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.variables');  // Deprecated.
+goog.provide('Blockly.Constants.Variables');
+
+goog.require('Blockly');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.FieldLabel');
+goog.require('Blockly.FieldVariable');
+
+
+/**
+ * Unused constant for the common HSV hue for all blocks in this category.
+ * @deprecated Use Blockly.Msg['VARIABLES_HUE']. (2018 April 5)
+ */
+Blockly.Constants.Variables.HUE = 330;
+
+Blockly.defineBlocksWithJsonArray([  // BEGIN JSON EXTRACT
+  // Block for variable getter.
+  {
+    "type": "variables_get",
+    "message0": "%1",
+    "args0": [
+      {
+        "type": "field_variable",
+        "name": "VAR",
+        "variable": "%{BKY_VARIABLES_DEFAULT_NAME}"
+      }
+    ],
+    "output": null,
+    "style": "variable_blocks",
+    "helpUrl": "%{BKY_VARIABLES_GET_HELPURL}",
+    "tooltip": "%{BKY_VARIABLES_GET_TOOLTIP}",
+    "extensions": ["contextMenu_variableSetterGetter"]
+  },
+  // Block for variable setter.
+  {
+    "type": "variables_set",
+    "message0": "%{BKY_VARIABLES_SET}",
+    "args0": [
+      {
+        "type": "field_variable",
+        "name": "VAR",
+        "variable": "%{BKY_VARIABLES_DEFAULT_NAME}"
+      },
+      {
+        "type": "input_value",
+        "name": "VALUE"
+      }
+    ],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "variable_blocks",
+    "tooltip": "%{BKY_VARIABLES_SET_TOOLTIP}",
+    "helpUrl": "%{BKY_VARIABLES_SET_HELPURL}",
+    "extensions": ["contextMenu_variableSetterGetter"]
+  }
+]);  // END JSON EXTRACT (Do not delete this comment.)
+
+/**
+ * Mixin to add context menu items to create getter/setter blocks for this
+ * setter/getter.
+ * Used by blocks 'variables_set' and 'variables_get'.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN = {
+  /**
+   * Add menu option to create getter/setter block for this setter/getter.
+   * @param {!Array} options List of menu options to add to.
+   * @this {Blockly.Block}
+   */
+  customContextMenu: function(options) {
+    if (!this.isInFlyout) {
+      // Getter blocks have the option to create a setter block, and vice versa.
+      if (this.type == 'variables_get') {
+        var opposite_type = 'variables_set';
+        var contextMenuMsg = Blockly.Msg['VARIABLES_GET_CREATE_SET'];
+      } else {
+        var opposite_type = 'variables_get';
+        var contextMenuMsg = Blockly.Msg['VARIABLES_SET_CREATE_GET'];
+      }
+
+      var option = {enabled: this.workspace.remainingCapacity() > 0};
+      var name = this.getField('VAR').getText();
+      option.text = contextMenuMsg.replace('%1', name);
+      var xmlField = Blockly.utils.xml.createElement('field');
+      xmlField.setAttribute('name', 'VAR');
+      xmlField.appendChild(Blockly.utils.xml.createTextNode(name));
+      var xmlBlock = Blockly.utils.xml.createElement('block');
+      xmlBlock.setAttribute('type', opposite_type);
+      xmlBlock.appendChild(xmlField);
+      option.callback = Blockly.ContextMenu.callbackFactory(this, xmlBlock);
+      options.push(option);
+      // Getter blocks have the option to rename or delete that variable.
+    } else {
+      if (this.type == 'variables_get' || this.type == 'variables_get_reporter') {
+        var renameOption = {
+          text: Blockly.Msg.RENAME_VARIABLE,
+          enabled: true,
+          callback: Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY(this)
+        };
+        var name = this.getField('VAR').getText();
+        var deleteOption = {
+          text: Blockly.Msg.DELETE_VARIABLE.replace('%1', name),
+          enabled: true,
+          callback: Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY(this)
+        };
+        options.unshift(renameOption);
+        options.unshift(deleteOption);
+      }
+    }
+  }
+};
+
+/**
+  * Callback for rename variable dropdown menu option associated with a
+  * variable getter block.
+  * @param {!Blockly.Block} block The block with the variable to rename.
+  * @return {!function()} A function that renames the variable.
+  */
+Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY = function(block) {
+  return function() {
+    var workspace = block.workspace;
+    var variable = block.getField('VAR').getVariable();
+    Blockly.Variables.renameVariable(workspace, variable);
+  };
+};
+
+/**
+ * Callback for delete variable dropdown menu option associated with a
+ * variable getter block.
+ * @param {!Blockly.Block} block The block with the variable to delete.
+ * @return {!function()} A function that deletes the variable.
+ */
+Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY = function(block) {
+  return function() {
+    var workspace = block.workspace;
+    var variable = block.getField('VAR').getVariable();
+    workspace.deleteVariableById(variable.getId());
+    workspace.refreshToolboxSelection();
+  };
+};
+
+Blockly.Extensions.registerMixin('contextMenu_variableSetterGetter',
+    Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);

blockly/blocks/variables_dynamic.js

@@ -0,0 +1,180 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Variable blocks for Blockly.
+
+ * This file is scraped to extract a .json file of block definitions. The array
+ * passed to defineBlocksWithJsonArray(..) must be strict JSON: double quotes
+ * only, no outside references, no functions, no trailing commas, etc. The one
+ * exception is end-of-line comments, which the scraper will remove.
+ * @author duzc2dtw@gmail.com (Du Tian Wei)
+ */
+'use strict';
+
+goog.provide('Blockly.Constants.VariablesDynamic');
+
+goog.require('Blockly');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.FieldLabel');
+goog.require('Blockly.FieldVariable');
+
+
+/**
+ * Unused constant for the common HSV hue for all blocks in this category.
+ * @deprecated Use Blockly.Msg['VARIABLES_DYNAMIC_HUE']. (2018 April 5)
+ */
+Blockly.Constants.VariablesDynamic.HUE = 310;
+
+Blockly.defineBlocksWithJsonArray([ // BEGIN JSON EXTRACT
+  // Block for variable getter.
+  {
+    "type": "variables_get_dynamic",
+    "message0": "%1",
+    "args0": [{
+      "type": "field_variable",
+      "name": "VAR",
+      "variable": "%{BKY_VARIABLES_DEFAULT_NAME}"
+    }],
+    "output": null,
+    "style": "variable_dynamic_blocks",
+    "helpUrl": "%{BKY_VARIABLES_GET_HELPURL}",
+    "tooltip": "%{BKY_VARIABLES_GET_TOOLTIP}",
+    "extensions": ["contextMenu_variableDynamicSetterGetter"]
+  },
+  // Block for variable setter.
+  {
+    "type": "variables_set_dynamic",
+    "message0": "%{BKY_VARIABLES_SET}",
+    "args0": [{
+      "type": "field_variable",
+      "name": "VAR",
+      "variable": "%{BKY_VARIABLES_DEFAULT_NAME}"
+    },
+    {
+      "type": "input_value",
+      "name": "VALUE"
+    }
+    ],
+    "previousStatement": null,
+    "nextStatement": null,
+    "style": "variable_dynamic_blocks",
+    "tooltip": "%{BKY_VARIABLES_SET_TOOLTIP}",
+    "helpUrl": "%{BKY_VARIABLES_SET_HELPURL}",
+    "extensions": ["contextMenu_variableDynamicSetterGetter"]
+  }
+]); // END JSON EXTRACT (Do not delete this comment.)
+
+/**
+ * Mixin to add context menu items to create getter/setter blocks for this
+ * setter/getter.
+ * Used by blocks 'variables_set_dynamic' and 'variables_get_dynamic'.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.VariablesDynamic.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN = {
+  /**
+   * Add menu option to create getter/setter block for this setter/getter.
+   * @param {!Array} options List of menu options to add to.
+   * @this {Blockly.Block}
+   */
+  customContextMenu: function(options) {
+    // Getter blocks have the option to create a setter block, and vice versa.
+    if (!this.isInFlyout) {
+      var opposite_type;
+      var contextMenuMsg;
+      var id = this.getFieldValue('VAR');
+      var variableModel = this.workspace.getVariableById(id);
+      var varType = variableModel.type;
+      if (this.type == 'variables_get_dynamic') {
+        opposite_type = 'variables_set_dynamic';
+        contextMenuMsg = Blockly.Msg['VARIABLES_GET_CREATE_SET'];
+      } else {
+        opposite_type = 'variables_get_dynamic';
+        contextMenuMsg = Blockly.Msg['VARIABLES_SET_CREATE_GET'];
+      }
+
+      var option = {enabled: this.workspace.remainingCapacity() > 0};
+      var name = this.getField('VAR').getText();
+      option.text = contextMenuMsg.replace('%1', name);
+      var xmlField = Blockly.utils.xml.createElement('field');
+      xmlField.setAttribute('name', 'VAR');
+      xmlField.setAttribute('variabletype', varType);
+      xmlField.appendChild(Blockly.utils.xml.createTextNode(name));
+      var xmlBlock = Blockly.utils.xml.createElement('block');
+      xmlBlock.setAttribute('type', opposite_type);
+      xmlBlock.appendChild(xmlField);
+      option.callback = Blockly.ContextMenu.callbackFactory(this, xmlBlock);
+      options.push(option);
+    } else {
+      if (this.type == 'variables_get_dynamic' ||
+       this.type == 'variables_get_reporter_dynamic') {
+        var renameOption = {
+          text: Blockly.Msg.RENAME_VARIABLE,
+          enabled: true,
+          callback: Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY(this)
+        };
+        var name = this.getField('VAR').getText();
+        var deleteOption = {
+          text: Blockly.Msg.DELETE_VARIABLE.replace('%1', name),
+          enabled: true,
+          callback: Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY(this)
+        };
+        options.unshift(renameOption);
+        options.unshift(deleteOption);
+      }
+    }
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * Set the connection type for this block.
+   * @param {!Blockly.Events.Abstract} _e Change event.
+   * @this {Blockly.Block}
+   */
+  onchange: function(_e) {
+    var id = this.getFieldValue('VAR');
+    var variableModel = Blockly.Variables.getVariable(this.workspace, id);
+    if (this.type == 'variables_get_dynamic') {
+      this.outputConnection.setCheck(variableModel.type);
+    } else {
+      this.getInput('VALUE').connection.setCheck(variableModel.type);
+    }
+  }
+};
+
+/**
+  * Callback for rename variable dropdown menu option associated with a
+  * variable getter block.
+  * @param {!Blockly.Block} block The block with the variable to rename.
+  * @return {!function()} A function that renames the variable.
+  */
+Blockly.Constants.VariablesDynamic.RENAME_OPTION_CALLBACK_FACTORY = function(block) {
+  return function() {
+    var workspace = block.workspace;
+    var variable = block.getField('VAR').getVariable();
+    Blockly.Variables.renameVariable(workspace, variable);
+  };
+};
+
+/**
+ * Callback for delete variable dropdown menu option associated with a
+ * variable getter block.
+ * @param {!Blockly.Block} block The block with the variable to delete.
+ * @return {!function()} A function that deletes the variable.
+ */
+Blockly.Constants.VariablesDynamic.DELETE_OPTION_CALLBACK_FACTORY = function(block) {
+  return function() {
+    var workspace = block.workspace;
+    var variable = block.getField('VAR').getVariable();
+    workspace.deleteVariableById(variable.getId());
+    workspace.refreshToolboxSelection();
+  };
+};
+
+Blockly.Extensions.registerMixin('contextMenu_variableDynamicSetterGetter',
+    Blockly.Constants.VariablesDynamic.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);

blockly/blocks_compressed.js

@@ -0,0 +1,182 @@
+// Do not edit this file; automatically generated by gulp.
+
+/* eslint-disable */
+;(function(root, factory) {
+  if (typeof define === 'function' && define.amd) { // AMD
+    define(['./blockly_compressed.js'], factory);
+  } else if (typeof exports === 'object') { // Node.js
+    module.exports = factory(require('./blockly_compressed.js'));
+  } else { // Browser
+    root.Blockly.Blocks = factory(root.Blockly);
+  }
+}(this, function(Blockly) {
+  'use strict';Blockly.Blocks.colour={};Blockly.Constants={};Blockly.Constants.Colour={};Blockly.Constants.Colour.HUE=20;
+Blockly.defineBlocksWithJsonArray([{type:"colour_picker",message0:"%1",args0:[{type:"field_colour",name:"COLOUR",colour:"#ff0000"}],output:"Colour",helpUrl:"%{BKY_COLOUR_PICKER_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_PICKER_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"colour_random",message0:"%{BKY_COLOUR_RANDOM_TITLE}",output:"Colour",helpUrl:"%{BKY_COLOUR_RANDOM_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_RANDOM_TOOLTIP}"},{type:"colour_rgb",message0:"%{BKY_COLOUR_RGB_TITLE} %{BKY_COLOUR_RGB_RED} %1 %{BKY_COLOUR_RGB_GREEN} %2 %{BKY_COLOUR_RGB_BLUE} %3",
+args0:[{type:"input_value",name:"RED",check:"Number",align:"RIGHT"},{type:"input_value",name:"GREEN",check:"Number",align:"RIGHT"},{type:"input_value",name:"BLUE",check:"Number",align:"RIGHT"}],output:"Colour",helpUrl:"%{BKY_COLOUR_RGB_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_RGB_TOOLTIP}"},{type:"colour_blend",message0:"%{BKY_COLOUR_BLEND_TITLE} %{BKY_COLOUR_BLEND_COLOUR1} %1 %{BKY_COLOUR_BLEND_COLOUR2} %2 %{BKY_COLOUR_BLEND_RATIO} %3",args0:[{type:"input_value",name:"COLOUR1",check:"Colour",
+align:"RIGHT"},{type:"input_value",name:"COLOUR2",check:"Colour",align:"RIGHT"},{type:"input_value",name:"RATIO",check:"Number",align:"RIGHT"}],output:"Colour",helpUrl:"%{BKY_COLOUR_BLEND_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_BLEND_TOOLTIP}"}]);Blockly.Constants.Lists={};Blockly.Constants.Lists.HUE=260;
+Blockly.defineBlocksWithJsonArray([{type:"lists_create_empty",message0:"%{BKY_LISTS_CREATE_EMPTY_TITLE}",output:"Array",style:"list_blocks",tooltip:"%{BKY_LISTS_CREATE_EMPTY_TOOLTIP}",helpUrl:"%{BKY_LISTS_CREATE_EMPTY_HELPURL}"},{type:"lists_repeat",message0:"%{BKY_LISTS_REPEAT_TITLE}",args0:[{type:"input_value",name:"ITEM"},{type:"input_value",name:"NUM",check:"Number"}],output:"Array",style:"list_blocks",tooltip:"%{BKY_LISTS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_LISTS_REPEAT_HELPURL}"},{type:"lists_reverse",
+message0:"%{BKY_LISTS_REVERSE_MESSAGE0}",args0:[{type:"input_value",name:"LIST",check:"Array"}],output:"Array",inputsInline:!0,style:"list_blocks",tooltip:"%{BKY_LISTS_REVERSE_TOOLTIP}",helpUrl:"%{BKY_LISTS_REVERSE_HELPURL}"},{type:"lists_isEmpty",message0:"%{BKY_LISTS_ISEMPTY_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Boolean",style:"list_blocks",tooltip:"%{BKY_LISTS_ISEMPTY_TOOLTIP}",helpUrl:"%{BKY_LISTS_ISEMPTY_HELPURL}"},{type:"lists_length",message0:"%{BKY_LISTS_LENGTH_TITLE}",
+args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Number",style:"list_blocks",tooltip:"%{BKY_LISTS_LENGTH_TOOLTIP}",helpUrl:"%{BKY_LISTS_LENGTH_HELPURL}"}]);
+Blockly.Blocks.lists_create_with={init:function(){this.setHelpUrl(Blockly.Msg.LISTS_CREATE_WITH_HELPURL);this.setStyle("list_blocks");this.itemCount_=3;this.updateShape_();this.setOutput(!0,"Array");this.setMutator(new Blockly.Mutator(["lists_create_with_item"]));this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_TOOLTIP)},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation");a.setAttribute("items",this.itemCount_);return a},domToMutation:function(a){this.itemCount_=parseInt(a.getAttribute("items"),
+10);this.updateShape_()},decompose:function(a){var b=a.newBlock("lists_create_with_container");b.initSvg();for(var c=b.getInput("STACK").connection,d=0;d<this.itemCount_;d++){var e=a.newBlock("lists_create_with_item");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}return b},compose:function(a){var b=a.getInputTargetBlock("STACK");for(a=[];b&&!b.isInsertionMarker();)a.push(b.valueConnection_),b=b.nextConnection&&b.nextConnection.targetBlock();for(b=0;b<this.itemCount_;b++){var c=this.getInput("ADD"+
+b).connection.targetConnection;c&&-1==a.indexOf(c)&&c.disconnect()}this.itemCount_=a.length;this.updateShape_();for(b=0;b<this.itemCount_;b++)Blockly.Mutator.reconnect(a[b],this,"ADD"+b)},saveConnections:function(a){a=a.getInputTargetBlock("STACK");for(var b=0;a;){var c=this.getInput("ADD"+b);a.valueConnection_=c&&c.connection.targetConnection;b++;a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.itemCount_&&this.getInput("EMPTY")?this.removeInput("EMPTY"):this.itemCount_||
+this.getInput("EMPTY")||this.appendDummyInput("EMPTY").appendField(Blockly.Msg.LISTS_CREATE_EMPTY_TITLE);for(var a=0;a<this.itemCount_;a++)if(!this.getInput("ADD"+a)){var b=this.appendValueInput("ADD"+a).setAlign(Blockly.ALIGN_RIGHT);0==a&&b.appendField(Blockly.Msg.LISTS_CREATE_WITH_INPUT_WITH)}for(;this.getInput("ADD"+a);)this.removeInput("ADD"+a),a++}};
+Blockly.Blocks.lists_create_with_container={init:function(){this.setStyle("list_blocks");this.appendDummyInput().appendField(Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TITLE_ADD);this.appendStatementInput("STACK");this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TOOLTIP);this.contextMenu=!1}};
+Blockly.Blocks.lists_create_with_item={init:function(){this.setStyle("list_blocks");this.appendDummyInput().appendField(Blockly.Msg.LISTS_CREATE_WITH_ITEM_TITLE);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_ITEM_TOOLTIP);this.contextMenu=!1}};
+Blockly.Blocks.lists_indexOf={init:function(){var a=[[Blockly.Msg.LISTS_INDEX_OF_FIRST,"FIRST"],[Blockly.Msg.LISTS_INDEX_OF_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.LISTS_INDEX_OF_HELPURL);this.setStyle("list_blocks");this.setOutput(!0,"Number");this.appendValueInput("VALUE").setCheck("Array").appendField(Blockly.Msg.LISTS_INDEX_OF_INPUT_IN_LIST);this.appendValueInput("FIND").appendField(new Blockly.FieldDropdown(a),"END");this.setInputsInline(!0);var b=this;this.setTooltip(function(){return Blockly.Msg.LISTS_INDEX_OF_TOOLTIP.replace("%1",
+b.workspace.options.oneBasedIndex?"0":"-1")})}};
+Blockly.Blocks.lists_getIndex={init:function(){var a=[[Blockly.Msg.LISTS_GET_INDEX_GET,"GET"],[Blockly.Msg.LISTS_GET_INDEX_GET_REMOVE,"GET_REMOVE"],[Blockly.Msg.LISTS_GET_INDEX_REMOVE,"REMOVE"]];this.WHERE_OPTIONS=[[Blockly.Msg.LISTS_GET_INDEX_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_INDEX_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_INDEX_FIRST,"FIRST"],[Blockly.Msg.LISTS_GET_INDEX_LAST,"LAST"],[Blockly.Msg.LISTS_GET_INDEX_RANDOM,"RANDOM"]];this.setHelpUrl(Blockly.Msg.LISTS_GET_INDEX_HELPURL);this.setStyle("list_blocks");
+a=new Blockly.FieldDropdown(a,function(c){c="REMOVE"==c;this.getSourceBlock().updateStatement_(c)});this.appendValueInput("VALUE").setCheck("Array").appendField(Blockly.Msg.LISTS_GET_INDEX_INPUT_IN_LIST);this.appendDummyInput().appendField(a,"MODE").appendField("","SPACE");this.appendDummyInput("AT");Blockly.Msg.LISTS_GET_INDEX_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.LISTS_GET_INDEX_TAIL);this.setInputsInline(!0);this.setOutput(!0);this.updateAt_(!0);var b=this;this.setTooltip(function(){var c=
+b.getFieldValue("MODE"),d=b.getFieldValue("WHERE"),e="";switch(c+" "+d){case "GET FROM_START":case "GET FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FROM;break;case "GET FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FIRST;break;case "GET LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_LAST;break;case "GET RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_RANDOM;break;case "GET_REMOVE FROM_START":case "GET_REMOVE FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM;break;case "GET_REMOVE FIRST":e=
+Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST;break;case "GET_REMOVE LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST;break;case "GET_REMOVE RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM;break;case "REMOVE FROM_START":case "REMOVE FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM;break;case "REMOVE FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST;break;case "REMOVE LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST;break;case "REMOVE RANDOM":e=
+Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM}if("FROM_START"==d||"FROM_END"==d)e+="  "+("FROM_START"==d?Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP:Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP).replace("%1",b.workspace.options.oneBasedIndex?"#1":"#0");return e})},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation");a.setAttribute("statement",!this.outputConnection);var b=this.getInput("AT").type==Blockly.INPUT_VALUE;a.setAttribute("at",b);return a},domToMutation:function(a){var b=
+"true"==a.getAttribute("statement");this.updateStatement_(b);a="false"!=a.getAttribute("at");this.updateAt_(a)},updateStatement_:function(a){a!=!this.outputConnection&&(this.unplug(!0,!0),a?(this.setOutput(!1),this.setPreviousStatement(!0),this.setNextStatement(!0)):(this.setPreviousStatement(!1),this.setNextStatement(!1),this.setOutput(!0)))},updateAt_:function(a){this.removeInput("AT");this.removeInput("ORDINAL",!0);a?(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&
+this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):this.appendDummyInput("AT");var b=new Blockly.FieldDropdown(this.WHERE_OPTIONS,function(c){var d="FROM_START"==c||"FROM_END"==c;if(d!=a){var e=this.getSourceBlock();e.updateAt_(d);e.setFieldValue(c,"WHERE");return null}});this.getInput("AT").appendField(b,"WHERE");Blockly.Msg.LISTS_GET_INDEX_TAIL&&this.moveInputBefore("TAIL",null)}};
+Blockly.Blocks.lists_setIndex={init:function(){var a=[[Blockly.Msg.LISTS_SET_INDEX_SET,"SET"],[Blockly.Msg.LISTS_SET_INDEX_INSERT,"INSERT"]];this.WHERE_OPTIONS=[[Blockly.Msg.LISTS_GET_INDEX_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_INDEX_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_INDEX_FIRST,"FIRST"],[Blockly.Msg.LISTS_GET_INDEX_LAST,"LAST"],[Blockly.Msg.LISTS_GET_INDEX_RANDOM,"RANDOM"]];this.setHelpUrl(Blockly.Msg.LISTS_SET_INDEX_HELPURL);this.setStyle("list_blocks");this.appendValueInput("LIST").setCheck("Array").appendField(Blockly.Msg.LISTS_SET_INDEX_INPUT_IN_LIST);
+this.appendDummyInput().appendField(new Blockly.FieldDropdown(a),"MODE").appendField("","SPACE");this.appendDummyInput("AT");this.appendValueInput("TO").appendField(Blockly.Msg.LISTS_SET_INDEX_INPUT_TO);this.setInputsInline(!0);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setTooltip(Blockly.Msg.LISTS_SET_INDEX_TOOLTIP);this.updateAt_(!0);var b=this;this.setTooltip(function(){var c=b.getFieldValue("MODE"),d=b.getFieldValue("WHERE"),e="";switch(c+" "+d){case "SET FROM_START":case "SET FROM_END":e=
+Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FROM;break;case "SET FIRST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FIRST;break;case "SET LAST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_LAST;break;case "SET RANDOM":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_RANDOM;break;case "INSERT FROM_START":case "INSERT FROM_END":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM;break;case "INSERT FIRST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST;break;case "INSERT LAST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_LAST;
+break;case "INSERT RANDOM":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM}if("FROM_START"==d||"FROM_END"==d)e+="  "+Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP.replace("%1",b.workspace.options.oneBasedIndex?"#1":"#0");return e})},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation"),b=this.getInput("AT").type==Blockly.INPUT_VALUE;a.setAttribute("at",b);return a},domToMutation:function(a){a="false"!=a.getAttribute("at");this.updateAt_(a)},updateAt_:function(a){this.removeInput("AT");
+this.removeInput("ORDINAL",!0);a?(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):this.appendDummyInput("AT");var b=new Blockly.FieldDropdown(this.WHERE_OPTIONS,function(c){var d="FROM_START"==c||"FROM_END"==c;if(d!=a){var e=this.getSourceBlock();e.updateAt_(d);e.setFieldValue(c,"WHERE");return null}});this.moveInputBefore("AT","TO");this.getInput("ORDINAL")&&this.moveInputBefore("ORDINAL",
+"TO");this.getInput("AT").appendField(b,"WHERE")}};
+Blockly.Blocks.lists_getSublist={init:function(){this.WHERE_OPTIONS_1=[[Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_SUBLIST_START_FIRST,"FIRST"]];this.WHERE_OPTIONS_2=[[Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_SUBLIST_END_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.LISTS_GET_SUBLIST_HELPURL);this.setStyle("list_blocks");
+this.appendValueInput("LIST").setCheck("Array").appendField(Blockly.Msg.LISTS_GET_SUBLIST_INPUT_IN_LIST);this.appendDummyInput("AT1");this.appendDummyInput("AT2");Blockly.Msg.LISTS_GET_SUBLIST_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.LISTS_GET_SUBLIST_TAIL);this.setInputsInline(!0);this.setOutput(!0,"Array");this.updateAt_(1,!0);this.updateAt_(2,!0);this.setTooltip(Blockly.Msg.LISTS_GET_SUBLIST_TOOLTIP)},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation"),
+b=this.getInput("AT1").type==Blockly.INPUT_VALUE;a.setAttribute("at1",b);b=this.getInput("AT2").type==Blockly.INPUT_VALUE;a.setAttribute("at2",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("at1");a="true"==a.getAttribute("at2");this.updateAt_(1,b);this.updateAt_(2,a)},updateAt_:function(a,b){this.removeInput("AT"+a);this.removeInput("ORDINAL"+a,!0);b?(this.appendValueInput("AT"+a).setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL"+a).appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):
+this.appendDummyInput("AT"+a);var c=new Blockly.FieldDropdown(this["WHERE_OPTIONS_"+a],function(d){var e="FROM_START"==d||"FROM_END"==d;if(e!=b){var f=this.getSourceBlock();f.updateAt_(a,e);f.setFieldValue(d,"WHERE"+a);return null}});this.getInput("AT"+a).appendField(c,"WHERE"+a);1==a&&(this.moveInputBefore("AT1","AT2"),this.getInput("ORDINAL1")&&this.moveInputBefore("ORDINAL1","AT2"));Blockly.Msg.LISTS_GET_SUBLIST_TAIL&&this.moveInputBefore("TAIL",null)}};
+Blockly.Blocks.lists_sort={init:function(){this.jsonInit({message0:Blockly.Msg.LISTS_SORT_TITLE,args0:[{type:"field_dropdown",name:"TYPE",options:[[Blockly.Msg.LISTS_SORT_TYPE_NUMERIC,"NUMERIC"],[Blockly.Msg.LISTS_SORT_TYPE_TEXT,"TEXT"],[Blockly.Msg.LISTS_SORT_TYPE_IGNORECASE,"IGNORE_CASE"]]},{type:"field_dropdown",name:"DIRECTION",options:[[Blockly.Msg.LISTS_SORT_ORDER_ASCENDING,"1"],[Blockly.Msg.LISTS_SORT_ORDER_DESCENDING,"-1"]]},{type:"input_value",name:"LIST",check:"Array"}],output:"Array",style:"list_blocks",
+tooltip:Blockly.Msg.LISTS_SORT_TOOLTIP,helpUrl:Blockly.Msg.LISTS_SORT_HELPURL})}};
+Blockly.Blocks.lists_split={init:function(){var a=this,b=new Blockly.FieldDropdown([[Blockly.Msg.LISTS_SPLIT_LIST_FROM_TEXT,"SPLIT"],[Blockly.Msg.LISTS_SPLIT_TEXT_FROM_LIST,"JOIN"]],function(c){a.updateType_(c)});this.setHelpUrl(Blockly.Msg.LISTS_SPLIT_HELPURL);this.setStyle("list_blocks");this.appendValueInput("INPUT").setCheck("String").appendField(b,"MODE");this.appendValueInput("DELIM").setCheck("String").appendField(Blockly.Msg.LISTS_SPLIT_WITH_DELIMITER);this.setInputsInline(!0);this.setOutput(!0,
+"Array");this.setTooltip(function(){var c=a.getFieldValue("MODE");if("SPLIT"==c)return Blockly.Msg.LISTS_SPLIT_TOOLTIP_SPLIT;if("JOIN"==c)return Blockly.Msg.LISTS_SPLIT_TOOLTIP_JOIN;throw Error("Unknown mode: "+c);})},updateType_:function(a){if(this.getFieldValue("MODE")!=a){var b=this.getInput("INPUT").connection;b.setShadowDom(null);var c=b.targetBlock();c&&(b.disconnect(),c.isShadow()?c.dispose():this.bumpNeighbours())}"SPLIT"==a?(this.outputConnection.setCheck("Array"),this.getInput("INPUT").setCheck("String")):
+(this.outputConnection.setCheck("String"),this.getInput("INPUT").setCheck("Array"))},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation");a.setAttribute("mode",this.getFieldValue("MODE"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("mode"))}};Blockly.Blocks.logic={};Blockly.Constants.Logic={};Blockly.Constants.Logic.HUE=210;
+Blockly.defineBlocksWithJsonArray([{type:"logic_boolean",message0:"%1",args0:[{type:"field_dropdown",name:"BOOL",options:[["%{BKY_LOGIC_BOOLEAN_TRUE}","TRUE"],["%{BKY_LOGIC_BOOLEAN_FALSE}","FALSE"]]}],output:"Boolean",style:"logic_blocks",tooltip:"%{BKY_LOGIC_BOOLEAN_TOOLTIP}",helpUrl:"%{BKY_LOGIC_BOOLEAN_HELPURL}"},{type:"controls_if",message0:"%{BKY_CONTROLS_IF_MSG_IF} %1",args0:[{type:"input_value",name:"IF0",check:"Boolean"}],message1:"%{BKY_CONTROLS_IF_MSG_THEN} %1",args1:[{type:"input_statement",
+name:"DO0"}],previousStatement:null,nextStatement:null,style:"logic_blocks",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",mutator:"controls_if_mutator",extensions:["controls_if_tooltip"]},{type:"controls_ifelse",message0:"%{BKY_CONTROLS_IF_MSG_IF} %1",args0:[{type:"input_value",name:"IF0",check:"Boolean"}],message1:"%{BKY_CONTROLS_IF_MSG_THEN} %1",args1:[{type:"input_statement",name:"DO0"}],message2:"%{BKY_CONTROLS_IF_MSG_ELSE} %1",args2:[{type:"input_statement",name:"ELSE"}],previousStatement:null,nextStatement:null,
+style:"logic_blocks",tooltip:"%{BKYCONTROLS_IF_TOOLTIP_2}",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",extensions:["controls_if_tooltip"]},{type:"logic_compare",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A"},{type:"field_dropdown",name:"OP",options:[["=","EQ"],["\u2260","NEQ"],["\u200f<","LT"],["\u200f\u2264","LTE"],["\u200f>","GT"],["\u200f\u2265","GTE"]]},{type:"input_value",name:"B"}],inputsInline:!0,output:"Boolean",style:"logic_blocks",helpUrl:"%{BKY_LOGIC_COMPARE_HELPURL}",extensions:["logic_compare",
+"logic_op_tooltip"]},{type:"logic_operation",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:"Boolean"},{type:"field_dropdown",name:"OP",options:[["%{BKY_LOGIC_OPERATION_AND}","AND"],["%{BKY_LOGIC_OPERATION_OR}","OR"]]},{type:"input_value",name:"B",check:"Boolean"}],inputsInline:!0,output:"Boolean",style:"logic_blocks",helpUrl:"%{BKY_LOGIC_OPERATION_HELPURL}",extensions:["logic_op_tooltip"]},{type:"logic_negate",message0:"%{BKY_LOGIC_NEGATE_TITLE}",args0:[{type:"input_value",name:"BOOL",
+check:"Boolean"}],output:"Boolean",style:"logic_blocks",tooltip:"%{BKY_LOGIC_NEGATE_TOOLTIP}",helpUrl:"%{BKY_LOGIC_NEGATE_HELPURL}"},{type:"logic_null",message0:"%{BKY_LOGIC_NULL}",output:null,style:"logic_blocks",tooltip:"%{BKY_LOGIC_NULL_TOOLTIP}",helpUrl:"%{BKY_LOGIC_NULL_HELPURL}"},{type:"logic_ternary",message0:"%{BKY_LOGIC_TERNARY_CONDITION} %1",args0:[{type:"input_value",name:"IF",check:"Boolean"}],message1:"%{BKY_LOGIC_TERNARY_IF_TRUE} %1",args1:[{type:"input_value",name:"THEN"}],message2:"%{BKY_LOGIC_TERNARY_IF_FALSE} %1",
+args2:[{type:"input_value",name:"ELSE"}],output:null,style:"logic_blocks",tooltip:"%{BKY_LOGIC_TERNARY_TOOLTIP}",helpUrl:"%{BKY_LOGIC_TERNARY_HELPURL}",extensions:["logic_ternary"]}]);
+Blockly.defineBlocksWithJsonArray([{type:"controls_if_if",message0:"%{BKY_CONTROLS_IF_IF_TITLE_IF}",nextStatement:null,enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_IF_TOOLTIP}"},{type:"controls_if_elseif",message0:"%{BKY_CONTROLS_IF_ELSEIF_TITLE_ELSEIF}",previousStatement:null,nextStatement:null,enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_ELSEIF_TOOLTIP}"},{type:"controls_if_else",message0:"%{BKY_CONTROLS_IF_ELSE_TITLE_ELSE}",previousStatement:null,
+enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_ELSE_TOOLTIP}"}]);Blockly.Constants.Logic.TOOLTIPS_BY_OP={EQ:"%{BKY_LOGIC_COMPARE_TOOLTIP_EQ}",NEQ:"%{BKY_LOGIC_COMPARE_TOOLTIP_NEQ}",LT:"%{BKY_LOGIC_COMPARE_TOOLTIP_LT}",LTE:"%{BKY_LOGIC_COMPARE_TOOLTIP_LTE}",GT:"%{BKY_LOGIC_COMPARE_TOOLTIP_GT}",GTE:"%{BKY_LOGIC_COMPARE_TOOLTIP_GTE}",AND:"%{BKY_LOGIC_OPERATION_TOOLTIP_AND}",OR:"%{BKY_LOGIC_OPERATION_TOOLTIP_OR}"};
+Blockly.Extensions.register("logic_op_tooltip",Blockly.Extensions.buildTooltipForDropdown("OP",Blockly.Constants.Logic.TOOLTIPS_BY_OP));
+Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN={elseifCount_:0,elseCount_:0,suppressPrefixSuffix:!0,mutationToDom:function(){if(!this.elseifCount_&&!this.elseCount_)return null;var a=Blockly.utils.xml.createElement("mutation");this.elseifCount_&&a.setAttribute("elseif",this.elseifCount_);this.elseCount_&&a.setAttribute("else",1);return a},domToMutation:function(a){this.elseifCount_=parseInt(a.getAttribute("elseif"),10)||0;this.elseCount_=parseInt(a.getAttribute("else"),10)||0;this.rebuildShape_()},
+decompose:function(a){var b=a.newBlock("controls_if_if");b.initSvg();for(var c=b.nextConnection,d=1;d<=this.elseifCount_;d++){var e=a.newBlock("controls_if_elseif");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}this.elseCount_&&(a=a.newBlock("controls_if_else"),a.initSvg(),c.connect(a.previousConnection));return b},compose:function(a){a=a.nextConnection.targetBlock();this.elseCount_=this.elseifCount_=0;for(var b=[null],c=[null],d=null;a&&!a.isInsertionMarker();){switch(a.type){case "controls_if_elseif":this.elseifCount_++;
+b.push(a.valueConnection_);c.push(a.statementConnection_);break;case "controls_if_else":this.elseCount_++;d=a.statementConnection_;break;default:throw TypeError("Unknown block type: "+a.type);}a=a.nextConnection&&a.nextConnection.targetBlock()}this.updateShape_();this.reconnectChildBlocks_(b,c,d)},saveConnections:function(a){a=a.nextConnection.targetBlock();for(var b=1;a;){switch(a.type){case "controls_if_elseif":var c=this.getInput("IF"+b),d=this.getInput("DO"+b);a.valueConnection_=c&&c.connection.targetConnection;
+a.statementConnection_=d&&d.connection.targetConnection;b++;break;case "controls_if_else":d=this.getInput("ELSE");a.statementConnection_=d&&d.connection.targetConnection;break;default:throw TypeError("Unknown block type: "+a.type);}a=a.nextConnection&&a.nextConnection.targetBlock()}},rebuildShape_:function(){var a=[null],b=[null],c=null;this.getInput("ELSE")&&(c=this.getInput("ELSE").connection.targetConnection);for(var d=1;this.getInput("IF"+d);){var e=this.getInput("IF"+d),f=this.getInput("DO"+
+d);a.push(e.connection.targetConnection);b.push(f.connection.targetConnection);d++}this.updateShape_();this.reconnectChildBlocks_(a,b,c)},updateShape_:function(){this.getInput("ELSE")&&this.removeInput("ELSE");for(var a=1;this.getInput("IF"+a);)this.removeInput("IF"+a),this.removeInput("DO"+a),a++;for(a=1;a<=this.elseifCount_;a++)this.appendValueInput("IF"+a).setCheck("Boolean").appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSEIF),this.appendStatementInput("DO"+a).appendField(Blockly.Msg.CONTROLS_IF_MSG_THEN);
+this.elseCount_&&this.appendStatementInput("ELSE").appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSE)},reconnectChildBlocks_:function(a,b,c){for(var d=1;d<=this.elseifCount_;d++)Blockly.Mutator.reconnect(a[d],this,"IF"+d),Blockly.Mutator.reconnect(b[d],this,"DO"+d);Blockly.Mutator.reconnect(c,this,"ELSE")}};Blockly.Extensions.registerMutator("controls_if_mutator",Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN,null,["controls_if_elseif","controls_if_else"]);
+Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION=function(){this.setTooltip(function(){if(this.elseifCount_||this.elseCount_){if(!this.elseifCount_&&this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_2;if(this.elseifCount_&&!this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_3;if(this.elseifCount_&&this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_4}else return Blockly.Msg.CONTROLS_IF_TOOLTIP_1;return""}.bind(this))};Blockly.Extensions.register("controls_if_tooltip",Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION);
+Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN={onchange:function(a){this.prevBlocks_||(this.prevBlocks_=[null,null]);var b=this.getInputTargetBlock("A"),c=this.getInputTargetBlock("B");b&&c&&!this.workspace.connectionChecker.doTypeChecks(b.outputConnection,c.outputConnection)&&(Blockly.Events.setGroup(a.group),a=this.prevBlocks_[0],a!==b&&(b.unplug(),!a||a.isDisposed()||a.isShadow()||this.getInput("A").connection.connect(a.outputConnection)),b=this.prevBlocks_[1],b!==c&&(c.unplug(),!b||b.isDisposed()||
+b.isShadow()||this.getInput("B").connection.connect(b.outputConnection)),this.bumpNeighbours(),Blockly.Events.setGroup(!1));this.prevBlocks_[0]=this.getInputTargetBlock("A");this.prevBlocks_[1]=this.getInputTargetBlock("B")}};Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION=function(){this.mixin(Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN)};Blockly.Extensions.register("logic_compare",Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION);
+Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN={prevParentConnection_:null,onchange:function(a){var b=this.getInputTargetBlock("THEN"),c=this.getInputTargetBlock("ELSE"),d=this.outputConnection.targetConnection;if((b||c)&&d)for(var e=0;2>e;e++){var f=1==e?b:c;f&&!f.workspace.connectionChecker.doTypeChecks(f.outputConnection,d)&&(Blockly.Events.setGroup(a.group),d===this.prevParentConnection_?(this.unplug(),d.getSourceBlock().bumpNeighbours()):(f.unplug(),f.bumpNeighbours()),Blockly.Events.setGroup(!1))}this.prevParentConnection_=
+d}};Blockly.Extensions.registerMixin("logic_ternary",Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN);Blockly.Blocks.loops={};Blockly.Constants.Loops={};Blockly.Constants.Loops.HUE=120;
+Blockly.defineBlocksWithJsonArray([{type:"controls_repeat_ext",message0:"%{BKY_CONTROLS_REPEAT_TITLE}",args0:[{type:"input_value",name:"TIMES",check:"Number"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",tooltip:"%{BKY_CONTROLS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_CONTROLS_REPEAT_HELPURL}"},{type:"controls_repeat",message0:"%{BKY_CONTROLS_REPEAT_TITLE}",args0:[{type:"field_number",name:"TIMES",value:10,
+min:0,precision:1}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",tooltip:"%{BKY_CONTROLS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_CONTROLS_REPEAT_HELPURL}"},{type:"controls_whileUntil",message0:"%1 %2",args0:[{type:"field_dropdown",name:"MODE",options:[["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_WHILE}","WHILE"],["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_UNTIL}","UNTIL"]]},{type:"input_value",name:"BOOL",check:"Boolean"}],
+message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_WHILEUNTIL_HELPURL}",extensions:["controls_whileUntil_tooltip"]},{type:"controls_for",message0:"%{BKY_CONTROLS_FOR_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:null},{type:"input_value",name:"FROM",check:"Number",align:"RIGHT"},{type:"input_value",name:"TO",check:"Number",align:"RIGHT"},{type:"input_value",name:"BY",
+check:"Number",align:"RIGHT"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],inputsInline:!0,previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FOR_HELPURL}",extensions:["contextMenu_newGetVariableBlock","controls_for_tooltip"]},{type:"controls_forEach",message0:"%{BKY_CONTROLS_FOREACH_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:null},{type:"input_value",name:"LIST",check:"Array"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",
+args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FOREACH_HELPURL}",extensions:["contextMenu_newGetVariableBlock","controls_forEach_tooltip"]},{type:"controls_flow_statements",message0:"%1",args0:[{type:"field_dropdown",name:"FLOW",options:[["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK}","BREAK"],["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE}","CONTINUE"]]}],previousStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FLOW_STATEMENTS_HELPURL}",
+extensions:["controls_flow_tooltip","controls_flow_in_loop_check"]}]);Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS={WHILE:"%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_WHILE}",UNTIL:"%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL}"};Blockly.Extensions.register("controls_whileUntil_tooltip",Blockly.Extensions.buildTooltipForDropdown("MODE",Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS));Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS={BREAK:"%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK}",CONTINUE:"%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE}"};
+Blockly.Extensions.register("controls_flow_tooltip",Blockly.Extensions.buildTooltipForDropdown("FLOW",Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS));
+Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){var b=this.getField("VAR").getVariable(),c=b.name;if(!this.isCollapsed()&&null!=c){var d={enabled:!0};d.text=Blockly.Msg.VARIABLES_SET_CREATE_GET.replace("%1",c);b=Blockly.Variables.generateVariableFieldDom(b);c=Blockly.utils.xml.createElement("block");c.setAttribute("type","variables_get");c.appendChild(b);d.callback=Blockly.ContextMenu.callbackFactory(this,c);a.push(d)}}}};
+Blockly.Extensions.registerMixin("contextMenu_newGetVariableBlock",Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN);Blockly.Extensions.register("controls_for_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_CONTROLS_FOR_TOOLTIP}","VAR"));Blockly.Extensions.register("controls_forEach_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_CONTROLS_FOREACH_TOOLTIP}","VAR"));
+Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN={LOOP_TYPES:["controls_repeat","controls_repeat_ext","controls_forEach","controls_for","controls_whileUntil"],suppressPrefixSuffix:!0,getSurroundLoop:function(a){do{if(-1!=Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN.LOOP_TYPES.indexOf(a.type))return a;a=a.getSurroundParent()}while(a);return null},onchange:function(a){if(this.workspace.isDragging&&!this.workspace.isDragging()&&a.type==Blockly.Events.BLOCK_MOVE){var b=Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN.getSurroundLoop(this);
+this.setWarningText(b?null:Blockly.Msg.CONTROLS_FLOW_STATEMENTS_WARNING);if(!this.isInFlyout){var c=Blockly.Events.getGroup();Blockly.Events.setGroup(a.group);this.setEnabled(b);Blockly.Events.setGroup(c)}}}};Blockly.Extensions.registerMixin("controls_flow_in_loop_check",Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN);Blockly.Blocks.math={};Blockly.Constants.Math={};Blockly.Constants.Math.HUE=230;
+Blockly.defineBlocksWithJsonArray([{type:"math_number",message0:"%1",args0:[{type:"field_number",name:"NUM",value:0}],output:"Number",helpUrl:"%{BKY_MATH_NUMBER_HELPURL}",style:"math_blocks",tooltip:"%{BKY_MATH_NUMBER_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"math_arithmetic",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:"Number"},{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ADDITION_SYMBOL}","ADD"],["%{BKY_MATH_SUBTRACTION_SYMBOL}","MINUS"],["%{BKY_MATH_MULTIPLICATION_SYMBOL}",
+"MULTIPLY"],["%{BKY_MATH_DIVISION_SYMBOL}","DIVIDE"],["%{BKY_MATH_POWER_SYMBOL}","POWER"]]},{type:"input_value",name:"B",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ARITHMETIC_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_single",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_SINGLE_OP_ROOT}","ROOT"],["%{BKY_MATH_SINGLE_OP_ABSOLUTE}","ABS"],["-","NEG"],["ln","LN"],["log10","LOG10"],["e^","EXP"],["10^","POW10"]]},
+{type:"input_value",name:"NUM",check:"Number"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_SINGLE_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_trig",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_TRIG_SIN}","SIN"],["%{BKY_MATH_TRIG_COS}","COS"],["%{BKY_MATH_TRIG_TAN}","TAN"],["%{BKY_MATH_TRIG_ASIN}","ASIN"],["%{BKY_MATH_TRIG_ACOS}","ACOS"],["%{BKY_MATH_TRIG_ATAN}","ATAN"]]},{type:"input_value",name:"NUM",check:"Number"}],output:"Number",style:"math_blocks",
+helpUrl:"%{BKY_MATH_TRIG_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_constant",message0:"%1",args0:[{type:"field_dropdown",name:"CONSTANT",options:[["\u03c0","PI"],["e","E"],["\u03c6","GOLDEN_RATIO"],["sqrt(2)","SQRT2"],["sqrt(\u00bd)","SQRT1_2"],["\u221e","INFINITY"]]}],output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_CONSTANT_TOOLTIP}",helpUrl:"%{BKY_MATH_CONSTANT_HELPURL}"},{type:"math_number_property",message0:"%1 %2",args0:[{type:"input_value",name:"NUMBER_TO_CHECK",check:"Number"},
+{type:"field_dropdown",name:"PROPERTY",options:[["%{BKY_MATH_IS_EVEN}","EVEN"],["%{BKY_MATH_IS_ODD}","ODD"],["%{BKY_MATH_IS_PRIME}","PRIME"],["%{BKY_MATH_IS_WHOLE}","WHOLE"],["%{BKY_MATH_IS_POSITIVE}","POSITIVE"],["%{BKY_MATH_IS_NEGATIVE}","NEGATIVE"],["%{BKY_MATH_IS_DIVISIBLE_BY}","DIVISIBLE_BY"]]}],inputsInline:!0,output:"Boolean",style:"math_blocks",tooltip:"%{BKY_MATH_IS_TOOLTIP}",mutator:"math_is_divisibleby_mutator"},{type:"math_change",message0:"%{BKY_MATH_CHANGE_TITLE}",args0:[{type:"field_variable",
+name:"VAR",variable:"%{BKY_MATH_CHANGE_TITLE_ITEM}"},{type:"input_value",name:"DELTA",check:"Number"}],previousStatement:null,nextStatement:null,style:"variable_blocks",helpUrl:"%{BKY_MATH_CHANGE_HELPURL}",extensions:["math_change_tooltip"]},{type:"math_round",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ROUND_OPERATOR_ROUND}","ROUND"],["%{BKY_MATH_ROUND_OPERATOR_ROUNDUP}","ROUNDUP"],["%{BKY_MATH_ROUND_OPERATOR_ROUNDDOWN}","ROUNDDOWN"]]},{type:"input_value",name:"NUM",
+check:"Number"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ROUND_HELPURL}",tooltip:"%{BKY_MATH_ROUND_TOOLTIP}"},{type:"math_on_list",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ONLIST_OPERATOR_SUM}","SUM"],["%{BKY_MATH_ONLIST_OPERATOR_MIN}","MIN"],["%{BKY_MATH_ONLIST_OPERATOR_MAX}","MAX"],["%{BKY_MATH_ONLIST_OPERATOR_AVERAGE}","AVERAGE"],["%{BKY_MATH_ONLIST_OPERATOR_MEDIAN}","MEDIAN"],["%{BKY_MATH_ONLIST_OPERATOR_MODE}","MODE"],["%{BKY_MATH_ONLIST_OPERATOR_STD_DEV}",
+"STD_DEV"],["%{BKY_MATH_ONLIST_OPERATOR_RANDOM}","RANDOM"]]},{type:"input_value",name:"LIST",check:"Array"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ONLIST_HELPURL}",mutator:"math_modes_of_list_mutator",extensions:["math_op_tooltip"]},{type:"math_modulo",message0:"%{BKY_MATH_MODULO_TITLE}",args0:[{type:"input_value",name:"DIVIDEND",check:"Number"},{type:"input_value",name:"DIVISOR",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_MODULO_TOOLTIP}",
+helpUrl:"%{BKY_MATH_MODULO_HELPURL}"},{type:"math_constrain",message0:"%{BKY_MATH_CONSTRAIN_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"Number"},{type:"input_value",name:"LOW",check:"Number"},{type:"input_value",name:"HIGH",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_CONSTRAIN_TOOLTIP}",helpUrl:"%{BKY_MATH_CONSTRAIN_HELPURL}"},{type:"math_random_int",message0:"%{BKY_MATH_RANDOM_INT_TITLE}",args0:[{type:"input_value",name:"FROM",check:"Number"},
+{type:"input_value",name:"TO",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_RANDOM_INT_TOOLTIP}",helpUrl:"%{BKY_MATH_RANDOM_INT_HELPURL}"},{type:"math_random_float",message0:"%{BKY_MATH_RANDOM_FLOAT_TITLE_RANDOM}",output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_RANDOM_FLOAT_TOOLTIP}",helpUrl:"%{BKY_MATH_RANDOM_FLOAT_HELPURL}"},{type:"math_atan2",message0:"%{BKY_MATH_ATAN2_TITLE}",args0:[{type:"input_value",name:"X",check:"Number"},{type:"input_value",
+name:"Y",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_ATAN2_TOOLTIP}",helpUrl:"%{BKY_MATH_ATAN2_HELPURL}"}]);
+Blockly.Constants.Math.TOOLTIPS_BY_OP={ADD:"%{BKY_MATH_ARITHMETIC_TOOLTIP_ADD}",MINUS:"%{BKY_MATH_ARITHMETIC_TOOLTIP_MINUS}",MULTIPLY:"%{BKY_MATH_ARITHMETIC_TOOLTIP_MULTIPLY}",DIVIDE:"%{BKY_MATH_ARITHMETIC_TOOLTIP_DIVIDE}",POWER:"%{BKY_MATH_ARITHMETIC_TOOLTIP_POWER}",ROOT:"%{BKY_MATH_SINGLE_TOOLTIP_ROOT}",ABS:"%{BKY_MATH_SINGLE_TOOLTIP_ABS}",NEG:"%{BKY_MATH_SINGLE_TOOLTIP_NEG}",LN:"%{BKY_MATH_SINGLE_TOOLTIP_LN}",LOG10:"%{BKY_MATH_SINGLE_TOOLTIP_LOG10}",EXP:"%{BKY_MATH_SINGLE_TOOLTIP_EXP}",POW10:"%{BKY_MATH_SINGLE_TOOLTIP_POW10}",
+SIN:"%{BKY_MATH_TRIG_TOOLTIP_SIN}",COS:"%{BKY_MATH_TRIG_TOOLTIP_COS}",TAN:"%{BKY_MATH_TRIG_TOOLTIP_TAN}",ASIN:"%{BKY_MATH_TRIG_TOOLTIP_ASIN}",ACOS:"%{BKY_MATH_TRIG_TOOLTIP_ACOS}",ATAN:"%{BKY_MATH_TRIG_TOOLTIP_ATAN}",SUM:"%{BKY_MATH_ONLIST_TOOLTIP_SUM}",MIN:"%{BKY_MATH_ONLIST_TOOLTIP_MIN}",MAX:"%{BKY_MATH_ONLIST_TOOLTIP_MAX}",AVERAGE:"%{BKY_MATH_ONLIST_TOOLTIP_AVERAGE}",MEDIAN:"%{BKY_MATH_ONLIST_TOOLTIP_MEDIAN}",MODE:"%{BKY_MATH_ONLIST_TOOLTIP_MODE}",STD_DEV:"%{BKY_MATH_ONLIST_TOOLTIP_STD_DEV}",RANDOM:"%{BKY_MATH_ONLIST_TOOLTIP_RANDOM}"};
+Blockly.Extensions.register("math_op_tooltip",Blockly.Extensions.buildTooltipForDropdown("OP",Blockly.Constants.Math.TOOLTIPS_BY_OP));
+Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN={mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation"),b="DIVISIBLE_BY"==this.getFieldValue("PROPERTY");a.setAttribute("divisor_input",b);return a},domToMutation:function(a){a="true"==a.getAttribute("divisor_input");this.updateShape_(a)},updateShape_:function(a){var b=this.getInput("DIVISOR");a?b||this.appendValueInput("DIVISOR").setCheck("Number"):b&&this.removeInput("DIVISOR")}};
+Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION=function(){this.getField("PROPERTY").setValidator(function(a){a="DIVISIBLE_BY"==a;this.getSourceBlock().updateShape_(a)})};Blockly.Extensions.registerMutator("math_is_divisibleby_mutator",Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN,Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION);Blockly.Extensions.register("math_change_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_MATH_CHANGE_TOOLTIP}","VAR"));
+Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN={updateType_:function(a){"MODE"==a?this.outputConnection.setCheck("Array"):this.outputConnection.setCheck("Number")},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation");a.setAttribute("op",this.getFieldValue("OP"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("op"))}};Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION=function(){this.getField("OP").setValidator(function(a){this.updateType_(a)}.bind(this))};
+Blockly.Extensions.registerMutator("math_modes_of_list_mutator",Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN,Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION);Blockly.Blocks.procedures={};
+Blockly.Blocks.procedures_defnoreturn={init:function(){var a=Blockly.Procedures.findLegalName("",this);a=new Blockly.FieldTextInput(a,Blockly.Procedures.rename);a.setSpellcheck(!1);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_DEFNORETURN_TITLE).appendField(a,"NAME").appendField("","PARAMS");this.setMutator(new Blockly.Mutator(["procedures_mutatorarg"]));(this.workspace.options.comments||this.workspace.options.parentWorkspace&&this.workspace.options.parentWorkspace.options.comments)&&Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT&&
+this.setCommentText(Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_DEFNORETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_DEFNORETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.setStatements_(!0);this.statementConnection_=null},setStatements_:function(a){this.hasStatements_!==a&&(a?(this.appendStatementInput("STACK").appendField(Blockly.Msg.PROCEDURES_DEFNORETURN_DO),this.getInput("RETURN")&&this.moveInputBefore("STACK",
+"RETURN")):this.removeInput("STACK",!0),this.hasStatements_=a)},updateParams_:function(){var a="";this.arguments_.length&&(a=Blockly.Msg.PROCEDURES_BEFORE_PARAMS+" "+this.arguments_.join(", "));Blockly.Events.disable();try{this.setFieldValue(a,"PARAMS")}finally{Blockly.Events.enable()}},mutationToDom:function(a){var b=Blockly.utils.xml.createElement("mutation");a&&b.setAttribute("name",this.getFieldValue("NAME"));for(var c=0;c<this.argumentVarModels_.length;c++){var d=Blockly.utils.xml.createElement("arg"),
+e=this.argumentVarModels_[c];d.setAttribute("name",e.name);d.setAttribute("varid",e.getId());a&&this.paramIds_&&d.setAttribute("paramId",this.paramIds_[c]);b.appendChild(d)}this.hasStatements_||b.setAttribute("statements","false");return b},domToMutation:function(a){this.arguments_=[];this.argumentVarModels_=[];for(var b=0,c;c=a.childNodes[b];b++)if("arg"==c.nodeName.toLowerCase()){var d=c.getAttribute("name");c=c.getAttribute("varid")||c.getAttribute("varId");this.arguments_.push(d);c=Blockly.Variables.getOrCreateVariablePackage(this.workspace,
+c,d,"");null!=c?this.argumentVarModels_.push(c):console.log("Failed to create a variable with name "+d+", ignoring.")}this.updateParams_();Blockly.Procedures.mutateCallers(this);this.setStatements_("false"!==a.getAttribute("statements"))},decompose:function(a){var b=Blockly.utils.xml.createElement("block");b.setAttribute("type","procedures_mutatorcontainer");var c=Blockly.utils.xml.createElement("statement");c.setAttribute("name","STACK");b.appendChild(c);for(var d=0;d<this.arguments_.length;d++){var e=
+Blockly.utils.xml.createElement("block");e.setAttribute("type","procedures_mutatorarg");var f=Blockly.utils.xml.createElement("field");f.setAttribute("name","NAME");var g=Blockly.utils.xml.createTextNode(this.arguments_[d]);f.appendChild(g);e.appendChild(f);f=Blockly.utils.xml.createElement("next");e.appendChild(f);c.appendChild(e);c=f}a=Blockly.Xml.domToBlock(b,a);"procedures_defreturn"==this.type?a.setFieldValue(this.hasStatements_,"STATEMENTS"):a.removeInput("STATEMENT_INPUT");Blockly.Procedures.mutateCallers(this);
+return a},compose:function(a){this.arguments_=[];this.paramIds_=[];this.argumentVarModels_=[];for(var b=a.getInputTargetBlock("STACK");b&&!b.isInsertionMarker();){var c=b.getFieldValue("NAME");this.arguments_.push(c);c=this.workspace.getVariable(c,"");this.argumentVarModels_.push(c);this.paramIds_.push(b.id);b=b.nextConnection&&b.nextConnection.targetBlock()}this.updateParams_();Blockly.Procedures.mutateCallers(this);a=a.getFieldValue("STATEMENTS");if(null!==a&&(a="TRUE"==a,this.hasStatements_!=a))if(a)this.setStatements_(!0),
+Blockly.Mutator.reconnect(this.statementConnection_,this,"STACK"),this.statementConnection_=null;else{a=this.getInput("STACK").connection;if(this.statementConnection_=a.targetConnection)a=a.targetBlock(),a.unplug(),a.bumpNeighbours();this.setStatements_(!1)}},getProcedureDef:function(){return[this.getFieldValue("NAME"),this.arguments_,!1]},getVars:function(){return this.arguments_},getVarModels:function(){return this.argumentVarModels_},renameVarById:function(a,b){var c=this.workspace.getVariableById(a);
+if(""==c.type){c=c.name;b=this.workspace.getVariableById(b);for(var d=!1,e=0;e<this.argumentVarModels_.length;e++)this.argumentVarModels_[e].getId()==a&&(this.arguments_[e]=b.name,this.argumentVarModels_[e]=b,d=!0);d&&(this.displayRenamedVar_(c,b.name),Blockly.Procedures.mutateCallers(this))}},updateVarName:function(a){for(var b=a.name,c=!1,d=0;d<this.argumentVarModels_.length;d++)if(this.argumentVarModels_[d].getId()==a.getId()){var e=this.arguments_[d];this.arguments_[d]=b;c=!0}c&&(this.displayRenamedVar_(e,
+b),Blockly.Procedures.mutateCallers(this))},displayRenamedVar_:function(a,b){this.updateParams_();if(this.mutator&&this.mutator.isVisible())for(var c=this.mutator.workspace_.getAllBlocks(!1),d=0,e;e=c[d];d++)"procedures_mutatorarg"==e.type&&Blockly.Names.equals(a,e.getFieldValue("NAME"))&&e.setFieldValue(b,"NAME")},customContextMenu:function(a){if(!this.isInFlyout){var b={enabled:!0},c=this.getFieldValue("NAME");b.text=Blockly.Msg.PROCEDURES_CREATE_DO.replace("%1",c);var d=Blockly.utils.xml.createElement("mutation");
+d.setAttribute("name",c);for(c=0;c<this.arguments_.length;c++){var e=Blockly.utils.xml.createElement("arg");e.setAttribute("name",this.arguments_[c]);d.appendChild(e)}c=Blockly.utils.xml.createElement("block");c.setAttribute("type",this.callType_);c.appendChild(d);b.callback=Blockly.ContextMenu.callbackFactory(this,c);a.push(b);if(!this.isCollapsed())for(c=0;c<this.argumentVarModels_.length;c++)b={enabled:!0},d=this.argumentVarModels_[c],b.text=Blockly.Msg.VARIABLES_SET_CREATE_GET.replace("%1",d.name),
+d=Blockly.Variables.generateVariableFieldDom(d),e=Blockly.utils.xml.createElement("block"),e.setAttribute("type","variables_get"),e.appendChild(d),b.callback=Blockly.ContextMenu.callbackFactory(this,e),a.push(b)}},callType_:"procedures_callnoreturn"};
+Blockly.Blocks.procedures_defreturn={init:function(){var a=Blockly.Procedures.findLegalName("",this);a=new Blockly.FieldTextInput(a,Blockly.Procedures.rename);a.setSpellcheck(!1);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_DEFRETURN_TITLE).appendField(a,"NAME").appendField("","PARAMS");this.appendValueInput("RETURN").setAlign(Blockly.ALIGN_RIGHT).appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN);this.setMutator(new Blockly.Mutator(["procedures_mutatorarg"]));(this.workspace.options.comments||
+this.workspace.options.parentWorkspace&&this.workspace.options.parentWorkspace.options.comments)&&Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT&&this.setCommentText(Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_DEFRETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_DEFRETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.setStatements_(!0);this.statementConnection_=null},setStatements_:Blockly.Blocks.procedures_defnoreturn.setStatements_,
+updateParams_:Blockly.Blocks.procedures_defnoreturn.updateParams_,mutationToDom:Blockly.Blocks.procedures_defnoreturn.mutationToDom,domToMutation:Blockly.Blocks.procedures_defnoreturn.domToMutation,decompose:Blockly.Blocks.procedures_defnoreturn.decompose,compose:Blockly.Blocks.procedures_defnoreturn.compose,getProcedureDef:function(){return[this.getFieldValue("NAME"),this.arguments_,!0]},getVars:Blockly.Blocks.procedures_defnoreturn.getVars,getVarModels:Blockly.Blocks.procedures_defnoreturn.getVarModels,
+renameVarById:Blockly.Blocks.procedures_defnoreturn.renameVarById,updateVarName:Blockly.Blocks.procedures_defnoreturn.updateVarName,displayRenamedVar_:Blockly.Blocks.procedures_defnoreturn.displayRenamedVar_,customContextMenu:Blockly.Blocks.procedures_defnoreturn.customContextMenu,callType_:"procedures_callreturn"};
+Blockly.Blocks.procedures_mutatorcontainer={init:function(){this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TITLE);this.appendStatementInput("STACK");this.appendDummyInput("STATEMENT_INPUT").appendField(Blockly.Msg.PROCEDURES_ALLOW_STATEMENTS).appendField(new Blockly.FieldCheckbox("TRUE"),"STATEMENTS");this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TOOLTIP);this.contextMenu=!1}};
+Blockly.Blocks.procedures_mutatorarg={init:function(){var a=new Blockly.FieldTextInput(Blockly.Procedures.DEFAULT_ARG,this.validator_);a.oldShowEditorFn_=a.showEditor_;a.showEditor_=function(){this.createdVariables_=[];this.oldShowEditorFn_()};this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_MUTATORARG_TITLE).appendField(a,"NAME");this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_MUTATORARG_TOOLTIP);this.contextMenu=
+!1;a.onFinishEditing_=this.deleteIntermediateVars_;a.createdVariables_=[];a.onFinishEditing_("x")},validator_:function(a){var b=this.getSourceBlock(),c=Blockly.Mutator.findParentWs(b.workspace);a=a.replace(/[\s\xa0]+/g," ").replace(/^ | $/g,"");if(!a)return null;for(var d=(b.workspace.targetWorkspace||b.workspace).getAllBlocks(!1),e=a.toLowerCase(),f=0;f<d.length;f++)if(d[f].id!=this.getSourceBlock().id){var g=d[f].getFieldValue("NAME");if(g&&g.toLowerCase()==e)return null}if(b.isInFlyout)return a;
+(b=c.getVariable(a,""))&&b.name!=a&&c.renameVariableById(b.getId(),a);b||(b=c.createVariable(a,""))&&this.createdVariables_&&this.createdVariables_.push(b);return a},deleteIntermediateVars_:function(a){var b=Blockly.Mutator.findParentWs(this.getSourceBlock().workspace);if(b)for(var c=0;c<this.createdVariables_.length;c++){var d=this.createdVariables_[c];d.name!=a&&b.deleteVariableById(d.getId())}}};
+Blockly.Blocks.procedures_callnoreturn={init:function(){this.appendDummyInput("TOPROW").appendField("","NAME");this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setHelpUrl(Blockly.Msg.PROCEDURES_CALLNORETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.quarkConnections_={};this.quarkIds_=null;this.previousEnabledState_=!0},getProcedureCall:function(){return this.getFieldValue("NAME")},renameProcedure:function(a,b){Blockly.Names.equals(a,
+this.getProcedureCall())&&(this.setFieldValue(b,"NAME"),this.setTooltip((this.outputConnection?Blockly.Msg.PROCEDURES_CALLRETURN_TOOLTIP:Blockly.Msg.PROCEDURES_CALLNORETURN_TOOLTIP).replace("%1",b)))},setProcedureParameters_:function(a,b){var c=Blockly.Procedures.getDefinition(this.getProcedureCall(),this.workspace),d=c&&c.mutator&&c.mutator.isVisible();d||(this.quarkConnections_={},this.quarkIds_=null);if(b)if(a.join("\n")==this.arguments_.join("\n"))this.quarkIds_=b;else{if(b.length!=a.length)throw RangeError("paramNames and paramIds must be the same length.");
+this.setCollapsed(!1);this.quarkIds_||(this.quarkConnections_={},this.quarkIds_=[]);c=this.rendered;this.rendered=!1;for(var e=0;e<this.arguments_.length;e++){var f=this.getInput("ARG"+e);f&&(f=f.connection.targetConnection,this.quarkConnections_[this.quarkIds_[e]]=f,d&&f&&-1==b.indexOf(this.quarkIds_[e])&&(f.disconnect(),f.getSourceBlock().bumpNeighbours()))}this.arguments_=[].concat(a);this.argumentVarModels_=[];for(e=0;e<this.arguments_.length;e++)a=Blockly.Variables.getOrCreateVariablePackage(this.workspace,
+null,this.arguments_[e],""),this.argumentVarModels_.push(a);this.updateShape_();if(this.quarkIds_=b)for(e=0;e<this.arguments_.length;e++)b=this.quarkIds_[e],b in this.quarkConnections_&&(f=this.quarkConnections_[b],Blockly.Mutator.reconnect(f,this,"ARG"+e)||delete this.quarkConnections_[b]);(this.rendered=c)&&this.render()}},updateShape_:function(){for(var a=0;a<this.arguments_.length;a++){var b=this.getField("ARGNAME"+a);if(b){Blockly.Events.disable();try{b.setValue(this.arguments_[a])}finally{Blockly.Events.enable()}}else b=
+new Blockly.FieldLabel(this.arguments_[a]),this.appendValueInput("ARG"+a).setAlign(Blockly.ALIGN_RIGHT).appendField(b,"ARGNAME"+a).init()}for(;this.getInput("ARG"+a);)this.removeInput("ARG"+a),a++;if(a=this.getInput("TOPROW"))this.arguments_.length?this.getField("WITH")||(a.appendField(Blockly.Msg.PROCEDURES_CALL_BEFORE_PARAMS,"WITH"),a.init()):this.getField("WITH")&&a.removeField("WITH")},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation");a.setAttribute("name",this.getProcedureCall());
+for(var b=0;b<this.arguments_.length;b++){var c=Blockly.utils.xml.createElement("arg");c.setAttribute("name",this.arguments_[b]);a.appendChild(c)}return a},domToMutation:function(a){var b=a.getAttribute("name");this.renameProcedure(this.getProcedureCall(),b);b=[];for(var c=[],d=0,e;e=a.childNodes[d];d++)"arg"==e.nodeName.toLowerCase()&&(b.push(e.getAttribute("name")),c.push(e.getAttribute("paramId")));this.setProcedureParameters_(b,c)},getVars:function(){return this.arguments_},getVarModels:function(){return this.argumentVarModels_},
+onchange:function(a){if(this.workspace&&!this.workspace.isFlyout&&a.recordUndo)if(a.type==Blockly.Events.BLOCK_CREATE&&-1!=a.ids.indexOf(this.id)){var b=this.getProcedureCall();b=Blockly.Procedures.getDefinition(b,this.workspace);!b||b.type==this.defType_&&JSON.stringify(b.getVars())==JSON.stringify(this.arguments_)||(b=null);if(!b){Blockly.Events.setGroup(a.group);a=Blockly.utils.xml.createElement("xml");b=Blockly.utils.xml.createElement("block");b.setAttribute("type",this.defType_);var c=this.getRelativeToSurfaceXY(),
+d=c.y+2*Blockly.SNAP_RADIUS;b.setAttribute("x",c.x+Blockly.SNAP_RADIUS*(this.RTL?-1:1));b.setAttribute("y",d);c=this.mutationToDom();b.appendChild(c);c=Blockly.utils.xml.createElement("field");c.setAttribute("name","NAME");d=this.getProcedureCall();d||(d=Blockly.Procedures.findLegalName("",this),this.renameProcedure("",d));c.appendChild(Blockly.utils.xml.createTextNode(d));b.appendChild(c);a.appendChild(b);Blockly.Xml.domToWorkspace(a,this.workspace);Blockly.Events.setGroup(!1)}}else a.type==Blockly.Events.BLOCK_DELETE?
+(b=this.getProcedureCall(),b=Blockly.Procedures.getDefinition(b,this.workspace),b||(Blockly.Events.setGroup(a.group),this.dispose(!0),Blockly.Events.setGroup(!1))):a.type==Blockly.Events.CHANGE&&"disabled"==a.element&&(b=this.getProcedureCall(),(b=Blockly.Procedures.getDefinition(b,this.workspace))&&b.id==a.blockId&&((b=Blockly.Events.getGroup())&&console.log("Saw an existing group while responding to a definition change"),Blockly.Events.setGroup(a.group),a.newValue?(this.previousEnabledState_=this.isEnabled(),
+this.setEnabled(!1)):this.setEnabled(this.previousEnabledState_),Blockly.Events.setGroup(b)))},customContextMenu:function(a){if(this.workspace.isMovable()){var b={enabled:!0};b.text=Blockly.Msg.PROCEDURES_HIGHLIGHT_DEF;var c=this.getProcedureCall(),d=this.workspace;b.callback=function(){var e=Blockly.Procedures.getDefinition(c,d);e&&(d.centerOnBlock(e.id),e.select())};a.push(b)}},defType_:"procedures_defnoreturn"};
+Blockly.Blocks.procedures_callreturn={init:function(){this.appendDummyInput("TOPROW").appendField("","NAME");this.setOutput(!0);this.setStyle("procedure_blocks");this.setHelpUrl(Blockly.Msg.PROCEDURES_CALLRETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.quarkConnections_={};this.quarkIds_=null;this.previousEnabledState_=!0},getProcedureCall:Blockly.Blocks.procedures_callnoreturn.getProcedureCall,renameProcedure:Blockly.Blocks.procedures_callnoreturn.renameProcedure,setProcedureParameters_:Blockly.Blocks.procedures_callnoreturn.setProcedureParameters_,
+updateShape_:Blockly.Blocks.procedures_callnoreturn.updateShape_,mutationToDom:Blockly.Blocks.procedures_callnoreturn.mutationToDom,domToMutation:Blockly.Blocks.procedures_callnoreturn.domToMutation,getVars:Blockly.Blocks.procedures_callnoreturn.getVars,getVarModels:Blockly.Blocks.procedures_callnoreturn.getVarModels,onchange:Blockly.Blocks.procedures_callnoreturn.onchange,customContextMenu:Blockly.Blocks.procedures_callnoreturn.customContextMenu,defType_:"procedures_defreturn"};
+Blockly.Blocks.procedures_ifreturn={init:function(){this.appendValueInput("CONDITION").setCheck("Boolean").appendField(Blockly.Msg.CONTROLS_IF_MSG_IF);this.appendValueInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN);this.setInputsInline(!0);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_IFRETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_IFRETURN_HELPURL);this.hasReturnValue_=!0},mutationToDom:function(){var a=
+Blockly.utils.xml.createElement("mutation");a.setAttribute("value",Number(this.hasReturnValue_));return a},domToMutation:function(a){this.hasReturnValue_=1==a.getAttribute("value");this.hasReturnValue_||(this.removeInput("VALUE"),this.appendDummyInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN))},onchange:function(a){if(this.workspace.isDragging&&!this.workspace.isDragging()){a=!1;var b=this;do{if(-1!=this.FUNCTION_TYPES.indexOf(b.type)){a=!0;break}b=b.getSurroundParent()}while(b);
+a?("procedures_defnoreturn"==b.type&&this.hasReturnValue_?(this.removeInput("VALUE"),this.appendDummyInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN),this.hasReturnValue_=!1):"procedures_defreturn"!=b.type||this.hasReturnValue_||(this.removeInput("VALUE"),this.appendValueInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN),this.hasReturnValue_=!0),this.setWarningText(null),this.isInFlyout||this.setEnabled(!0)):(this.setWarningText(Blockly.Msg.PROCEDURES_IFRETURN_WARNING),
+this.isInFlyout||this.getInheritedDisabled()||this.setEnabled(!1))}},FUNCTION_TYPES:["procedures_defnoreturn","procedures_defreturn"]};Blockly.Blocks.texts={};Blockly.Constants.Text={};Blockly.Constants.Text.HUE=160;
+Blockly.defineBlocksWithJsonArray([{type:"text",message0:"%1",args0:[{type:"field_input",name:"TEXT",text:""}],output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_TEXT_HELPURL}",tooltip:"%{BKY_TEXT_TEXT_TOOLTIP}",extensions:["text_quotes","parent_tooltip_when_inline"]},{type:"text_multiline",message0:"%1 %2",args0:[{type:"field_image",src:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAARCAYAAADpPU2iAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAdhgAAHYYBXaITgQAAABh0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMS42/U4J6AAAAP1JREFUOE+Vks0KQUEYhjmRIja4ABtZ2dm5A3t3Ia6AUm7CylYuQRaUhZSlLZJiQbFAyRnPN33y01HOW08z8873zpwzM4F3GWOCruvGIE4/rLaV+Nq1hVGMBqzhqlxgCys4wJA65xnogMHsQ5lujnYHTejBBCK2mE4abjCgMGhNxHgDFWjDSG07kdfVa2pZMf4ZyMAdWmpZMfYOsLiDMYMjlMB+K613QISRhTnITnsYg5yUd0DETmEoMlkFOeIT/A58iyK5E18BuTBfgYXfwNJv4P9/oEBerLylOnRhygmGdPpTTBZAPkde61lbQe4moWUvYUZYLfUNftIY4zwA5X2Z9AYnQrEAAAAASUVORK5CYII=",width:12,
+height:17,alt:"\u00b6"},{type:"field_multilinetext",name:"TEXT",text:""}],output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_TEXT_HELPURL}",tooltip:"%{BKY_TEXT_TEXT_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"text_join",message0:"",output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_JOIN_HELPURL}",tooltip:"%{BKY_TEXT_JOIN_TOOLTIP}",mutator:"text_join_mutator"},{type:"text_create_join_container",message0:"%{BKY_TEXT_CREATE_JOIN_TITLE_JOIN} %1 %2",args0:[{type:"input_dummy"},
+{type:"input_statement",name:"STACK"}],style:"text_blocks",tooltip:"%{BKY_TEXT_CREATE_JOIN_TOOLTIP}",enableContextMenu:!1},{type:"text_create_join_item",message0:"%{BKY_TEXT_CREATE_JOIN_ITEM_TITLE_ITEM}",previousStatement:null,nextStatement:null,style:"text_blocks",tooltip:"%{BKY_TEXT_CREATE_JOIN_ITEM_TOOLTIP}",enableContextMenu:!1},{type:"text_append",message0:"%{BKY_TEXT_APPEND_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_TEXT_APPEND_VARIABLE}"},{type:"input_value",name:"TEXT"}],
+previousStatement:null,nextStatement:null,style:"text_blocks",extensions:["text_append_tooltip"]},{type:"text_length",message0:"%{BKY_TEXT_LENGTH_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Number",style:"text_blocks",tooltip:"%{BKY_TEXT_LENGTH_TOOLTIP}",helpUrl:"%{BKY_TEXT_LENGTH_HELPURL}"},{type:"text_isEmpty",message0:"%{BKY_TEXT_ISEMPTY_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Boolean",style:"text_blocks",tooltip:"%{BKY_TEXT_ISEMPTY_TOOLTIP}",
+helpUrl:"%{BKY_TEXT_ISEMPTY_HELPURL}"},{type:"text_indexOf",message0:"%{BKY_TEXT_INDEXOF_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"String"},{type:"field_dropdown",name:"END",options:[["%{BKY_TEXT_INDEXOF_OPERATOR_FIRST}","FIRST"],["%{BKY_TEXT_INDEXOF_OPERATOR_LAST}","LAST"]]},{type:"input_value",name:"FIND",check:"String"}],output:"Number",style:"text_blocks",helpUrl:"%{BKY_TEXT_INDEXOF_HELPURL}",inputsInline:!0,extensions:["text_indexOf_tooltip"]},{type:"text_charAt",message0:"%{BKY_TEXT_CHARAT_TITLE}",
+args0:[{type:"input_value",name:"VALUE",check:"String"},{type:"field_dropdown",name:"WHERE",options:[["%{BKY_TEXT_CHARAT_FROM_START}","FROM_START"],["%{BKY_TEXT_CHARAT_FROM_END}","FROM_END"],["%{BKY_TEXT_CHARAT_FIRST}","FIRST"],["%{BKY_TEXT_CHARAT_LAST}","LAST"],["%{BKY_TEXT_CHARAT_RANDOM}","RANDOM"]]}],output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_CHARAT_HELPURL}",inputsInline:!0,mutator:"text_charAt_mutator"}]);
+Blockly.Blocks.text_getSubstring={init:function(){this.WHERE_OPTIONS_1=[[Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_START,"FROM_START"],[Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_END,"FROM_END"],[Blockly.Msg.TEXT_GET_SUBSTRING_START_FIRST,"FIRST"]];this.WHERE_OPTIONS_2=[[Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_START,"FROM_START"],[Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_END,"FROM_END"],[Blockly.Msg.TEXT_GET_SUBSTRING_END_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.TEXT_GET_SUBSTRING_HELPURL);this.setStyle("text_blocks");
+this.appendValueInput("STRING").setCheck("String").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_INPUT_IN_TEXT);this.appendDummyInput("AT1");this.appendDummyInput("AT2");Blockly.Msg.TEXT_GET_SUBSTRING_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_TAIL);this.setInputsInline(!0);this.setOutput(!0,"String");this.updateAt_(1,!0);this.updateAt_(2,!0);this.setTooltip(Blockly.Msg.TEXT_GET_SUBSTRING_TOOLTIP)},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation"),
+b=this.getInput("AT1").type==Blockly.INPUT_VALUE;a.setAttribute("at1",b);b=this.getInput("AT2").type==Blockly.INPUT_VALUE;a.setAttribute("at2",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("at1");a="true"==a.getAttribute("at2");this.updateAt_(1,b);this.updateAt_(2,a)},updateAt_:function(a,b){this.removeInput("AT"+a);this.removeInput("ORDINAL"+a,!0);b?(this.appendValueInput("AT"+a).setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL"+a).appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):
+this.appendDummyInput("AT"+a);2==a&&Blockly.Msg.TEXT_GET_SUBSTRING_TAIL&&(this.removeInput("TAIL",!0),this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_TAIL));var c=new Blockly.FieldDropdown(this["WHERE_OPTIONS_"+a],function(d){var e="FROM_START"==d||"FROM_END"==d;if(e!=b){var f=this.getSourceBlock();f.updateAt_(a,e);f.setFieldValue(d,"WHERE"+a);return null}});this.getInput("AT"+a).appendField(c,"WHERE"+a);1==a&&(this.moveInputBefore("AT1","AT2"),this.getInput("ORDINAL1")&&
+this.moveInputBefore("ORDINAL1","AT2"))}};Blockly.Blocks.text_changeCase={init:function(){var a=[[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_UPPERCASE,"UPPERCASE"],[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_LOWERCASE,"LOWERCASE"],[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_TITLECASE,"TITLECASE"]];this.setHelpUrl(Blockly.Msg.TEXT_CHANGECASE_HELPURL);this.setStyle("text_blocks");this.appendValueInput("TEXT").setCheck("String").appendField(new Blockly.FieldDropdown(a),"CASE");this.setOutput(!0,"String");this.setTooltip(Blockly.Msg.TEXT_CHANGECASE_TOOLTIP)}};
+Blockly.Blocks.text_trim={init:function(){var a=[[Blockly.Msg.TEXT_TRIM_OPERATOR_BOTH,"BOTH"],[Blockly.Msg.TEXT_TRIM_OPERATOR_LEFT,"LEFT"],[Blockly.Msg.TEXT_TRIM_OPERATOR_RIGHT,"RIGHT"]];this.setHelpUrl(Blockly.Msg.TEXT_TRIM_HELPURL);this.setStyle("text_blocks");this.appendValueInput("TEXT").setCheck("String").appendField(new Blockly.FieldDropdown(a),"MODE");this.setOutput(!0,"String");this.setTooltip(Blockly.Msg.TEXT_TRIM_TOOLTIP)}};
+Blockly.Blocks.text_print={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_PRINT_TITLE,args0:[{type:"input_value",name:"TEXT"}],previousStatement:null,nextStatement:null,style:"text_blocks",tooltip:Blockly.Msg.TEXT_PRINT_TOOLTIP,helpUrl:Blockly.Msg.TEXT_PRINT_HELPURL})}};
+Blockly.Blocks.text_prompt_ext={init:function(){var a=[[Blockly.Msg.TEXT_PROMPT_TYPE_TEXT,"TEXT"],[Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER,"NUMBER"]];this.setHelpUrl(Blockly.Msg.TEXT_PROMPT_HELPURL);this.setStyle("text_blocks");var b=this;a=new Blockly.FieldDropdown(a,function(c){b.updateType_(c)});this.appendValueInput("TEXT").appendField(a,"TYPE");this.setOutput(!0,"String");this.setTooltip(function(){return"TEXT"==b.getFieldValue("TYPE")?Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT:Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER})},
+updateType_:function(a){this.outputConnection.setCheck("NUMBER"==a?"Number":"String")},mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation");a.setAttribute("type",this.getFieldValue("TYPE"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("type"))}};
+Blockly.Blocks.text_prompt={init:function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);var a=[[Blockly.Msg.TEXT_PROMPT_TYPE_TEXT,"TEXT"],[Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER,"NUMBER"]],b=this;this.setHelpUrl(Blockly.Msg.TEXT_PROMPT_HELPURL);this.setStyle("text_blocks");a=new Blockly.FieldDropdown(a,function(c){b.updateType_(c)});this.appendDummyInput().appendField(a,"TYPE").appendField(this.newQuote_(!0)).appendField(new Blockly.FieldTextInput(""),"TEXT").appendField(this.newQuote_(!1));
+this.setOutput(!0,"String");this.setTooltip(function(){return"TEXT"==b.getFieldValue("TYPE")?Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT:Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER})},updateType_:Blockly.Blocks.text_prompt_ext.updateType_,mutationToDom:Blockly.Blocks.text_prompt_ext.mutationToDom,domToMutation:Blockly.Blocks.text_prompt_ext.domToMutation};
+Blockly.Blocks.text_count={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_COUNT_MESSAGE0,args0:[{type:"input_value",name:"SUB",check:"String"},{type:"input_value",name:"TEXT",check:"String"}],output:"Number",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_COUNT_TOOLTIP,helpUrl:Blockly.Msg.TEXT_COUNT_HELPURL})}};
+Blockly.Blocks.text_replace={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_REPLACE_MESSAGE0,args0:[{type:"input_value",name:"FROM",check:"String"},{type:"input_value",name:"TO",check:"String"},{type:"input_value",name:"TEXT",check:"String"}],output:"String",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_REPLACE_TOOLTIP,helpUrl:Blockly.Msg.TEXT_REPLACE_HELPURL})}};
+Blockly.Blocks.text_reverse={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_REVERSE_MESSAGE0,args0:[{type:"input_value",name:"TEXT",check:"String"}],output:"String",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_REVERSE_TOOLTIP,helpUrl:Blockly.Msg.TEXT_REVERSE_HELPURL})}};
+Blockly.Constants.Text.QUOTE_IMAGE_MIXIN={QUOTE_IMAGE_LEFT_DATAURI:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAAn0lEQVQI1z3OMa5BURSF4f/cQhAKjUQhuQmFNwGJEUi0RKN5rU7FHKhpjEH3TEMtkdBSCY1EIv8r7nFX9e29V7EBAOvu7RPjwmWGH/VuF8CyN9/OAdvqIXYLvtRaNjx9mMTDyo+NjAN1HNcl9ZQ5oQMM3dgDUqDo1l8DzvwmtZN7mnD+PkmLa+4mhrxVA9fRowBWmVBhFy5gYEjKMfz9AylsaRRgGzvZAAAAAElFTkSuQmCC",QUOTE_IMAGE_RIGHT_DATAURI:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAAqUlEQVQI1z3KvUpCcRiA8ef9E4JNHhI0aFEacm1o0BsI0Slx8wa8gLauoDnoBhq7DcfWhggONDmJJgqCPA7neJ7p934EOOKOnM8Q7PDElo/4x4lFb2DmuUjcUzS3URnGib9qaPNbuXvBO3sGPHJDRG6fGVdMSeWDP2q99FQdFrz26Gu5Tq7dFMzUvbXy8KXeAj57cOklgA+u1B5AoslLtGIHQMaCVnwDnADZIFIrXsoXrgAAAABJRU5ErkJggg==",
+QUOTE_IMAGE_WIDTH:12,QUOTE_IMAGE_HEIGHT:12,quoteField_:function(a){for(var b=0,c;c=this.inputList[b];b++)for(var d=0,e;e=c.fieldRow[d];d++)if(a==e.name){c.insertFieldAt(d,this.newQuote_(!0));c.insertFieldAt(d+2,this.newQuote_(!1));return}console.warn('field named "'+a+'" not found in '+this.toDevString())},newQuote_:function(a){a=this.RTL?!a:a;return new Blockly.FieldImage(a?this.QUOTE_IMAGE_LEFT_DATAURI:this.QUOTE_IMAGE_RIGHT_DATAURI,this.QUOTE_IMAGE_WIDTH,this.QUOTE_IMAGE_HEIGHT,a?"\u201c":"\u201d")}};
+Blockly.Constants.Text.TEXT_QUOTES_EXTENSION=function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);this.quoteField_("TEXT")};
+Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN={mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation");a.setAttribute("items",this.itemCount_);return a},domToMutation:function(a){this.itemCount_=parseInt(a.getAttribute("items"),10);this.updateShape_()},decompose:function(a){var b=a.newBlock("text_create_join_container");b.initSvg();for(var c=b.getInput("STACK").connection,d=0;d<this.itemCount_;d++){var e=a.newBlock("text_create_join_item");e.initSvg();c.connect(e.previousConnection);
+c=e.nextConnection}return b},compose:function(a){var b=a.getInputTargetBlock("STACK");for(a=[];b&&!b.isInsertionMarker();)a.push(b.valueConnection_),b=b.nextConnection&&b.nextConnection.targetBlock();for(b=0;b<this.itemCount_;b++){var c=this.getInput("ADD"+b).connection.targetConnection;c&&-1==a.indexOf(c)&&c.disconnect()}this.itemCount_=a.length;this.updateShape_();for(b=0;b<this.itemCount_;b++)Blockly.Mutator.reconnect(a[b],this,"ADD"+b)},saveConnections:function(a){a=a.getInputTargetBlock("STACK");
+for(var b=0;a;){var c=this.getInput("ADD"+b);a.valueConnection_=c&&c.connection.targetConnection;b++;a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.itemCount_&&this.getInput("EMPTY")?this.removeInput("EMPTY"):this.itemCount_||this.getInput("EMPTY")||this.appendDummyInput("EMPTY").appendField(this.newQuote_(!0)).appendField(this.newQuote_(!1));for(var a=0;a<this.itemCount_;a++)if(!this.getInput("ADD"+a)){var b=this.appendValueInput("ADD"+a).setAlign(Blockly.ALIGN_RIGHT);
+0==a&&b.appendField(Blockly.Msg.TEXT_JOIN_TITLE_CREATEWITH)}for(;this.getInput("ADD"+a);)this.removeInput("ADD"+a),a++}};Blockly.Constants.Text.TEXT_JOIN_EXTENSION=function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);this.itemCount_=2;this.updateShape_();this.setMutator(new Blockly.Mutator(["text_create_join_item"]))};Blockly.Extensions.register("text_append_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_TEXT_APPEND_TOOLTIP}","VAR"));
+Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION=function(){var a=this;this.setTooltip(function(){return Blockly.Msg.TEXT_INDEXOF_TOOLTIP.replace("%1",a.workspace.options.oneBasedIndex?"0":"-1")})};
+Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN={mutationToDom:function(){var a=Blockly.utils.xml.createElement("mutation");a.setAttribute("at",!!this.isAt_);return a},domToMutation:function(a){a="false"!=a.getAttribute("at");this.updateAt_(a)},updateAt_:function(a){this.removeInput("AT",!0);this.removeInput("ORDINAL",!0);a&&(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX));Blockly.Msg.TEXT_CHARAT_TAIL&&
+(this.removeInput("TAIL",!0),this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_CHARAT_TAIL));this.isAt_=a}};
+Blockly.Constants.Text.TEXT_CHARAT_EXTENSION=function(){this.getField("WHERE").setValidator(function(b){b="FROM_START"==b||"FROM_END"==b;b!=this.isAt_&&this.getSourceBlock().updateAt_(b)});this.updateAt_(!0);var a=this;this.setTooltip(function(){var b=a.getFieldValue("WHERE"),c=Blockly.Msg.TEXT_CHARAT_TOOLTIP;("FROM_START"==b||"FROM_END"==b)&&(b="FROM_START"==b?Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP:Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP)&&(c+="  "+b.replace("%1",a.workspace.options.oneBasedIndex?
+"#1":"#0"));return c})};Blockly.Extensions.register("text_indexOf_tooltip",Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION);Blockly.Extensions.register("text_quotes",Blockly.Constants.Text.TEXT_QUOTES_EXTENSION);Blockly.Extensions.registerMutator("text_join_mutator",Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN,Blockly.Constants.Text.TEXT_JOIN_EXTENSION);Blockly.Extensions.registerMutator("text_charAt_mutator",Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN,Blockly.Constants.Text.TEXT_CHARAT_EXTENSION);Blockly.Blocks.variables={};Blockly.Constants.Variables={};Blockly.Constants.Variables.HUE=330;
+Blockly.defineBlocksWithJsonArray([{type:"variables_get",message0:"%1",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"}],output:null,style:"variable_blocks",helpUrl:"%{BKY_VARIABLES_GET_HELPURL}",tooltip:"%{BKY_VARIABLES_GET_TOOLTIP}",extensions:["contextMenu_variableSetterGetter"]},{type:"variables_set",message0:"%{BKY_VARIABLES_SET}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"},{type:"input_value",name:"VALUE"}],previousStatement:null,
+nextStatement:null,style:"variable_blocks",tooltip:"%{BKY_VARIABLES_SET_TOOLTIP}",helpUrl:"%{BKY_VARIABLES_SET_HELPURL}",extensions:["contextMenu_variableSetterGetter"]}]);
+Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){if("variables_get"==this.type)var b="variables_set",c=Blockly.Msg.VARIABLES_GET_CREATE_SET;else b="variables_get",c=Blockly.Msg.VARIABLES_SET_CREATE_GET;var d={enabled:0<this.workspace.remainingCapacity()},e=this.getField("VAR").getText();d.text=c.replace("%1",e);c=Blockly.utils.xml.createElement("field");c.setAttribute("name","VAR");c.appendChild(Blockly.utils.xml.createTextNode(e));
+e=Blockly.utils.xml.createElement("block");e.setAttribute("type",b);e.appendChild(c);d.callback=Blockly.ContextMenu.callbackFactory(this,e);a.push(d)}else if("variables_get"==this.type||"variables_get_reporter"==this.type)b={text:Blockly.Msg.RENAME_VARIABLE,enabled:!0,callback:Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY(this)},e=this.getField("VAR").getText(),d={text:Blockly.Msg.DELETE_VARIABLE.replace("%1",e),enabled:!0,callback:Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY(this)},
+a.unshift(b),a.unshift(d)}};Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();Blockly.Variables.renameVariable(b,c)}};Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();b.deleteVariableById(c.getId());b.refreshToolboxSelection()}};Blockly.Extensions.registerMixin("contextMenu_variableSetterGetter",Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);Blockly.Constants.VariablesDynamic={};Blockly.Constants.VariablesDynamic.HUE=310;
+Blockly.defineBlocksWithJsonArray([{type:"variables_get_dynamic",message0:"%1",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"}],output:null,style:"variable_dynamic_blocks",helpUrl:"%{BKY_VARIABLES_GET_HELPURL}",tooltip:"%{BKY_VARIABLES_GET_TOOLTIP}",extensions:["contextMenu_variableDynamicSetterGetter"]},{type:"variables_set_dynamic",message0:"%{BKY_VARIABLES_SET}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"},{type:"input_value",
+name:"VALUE"}],previousStatement:null,nextStatement:null,style:"variable_dynamic_blocks",tooltip:"%{BKY_VARIABLES_SET_TOOLTIP}",helpUrl:"%{BKY_VARIABLES_SET_HELPURL}",extensions:["contextMenu_variableDynamicSetterGetter"]}]);
+Blockly.Constants.VariablesDynamic.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){var b=this.getFieldValue("VAR");var c=this.workspace.getVariableById(b).type;if("variables_get_dynamic"==this.type){b="variables_set_dynamic";var d=Blockly.Msg.VARIABLES_GET_CREATE_SET}else b="variables_get_dynamic",d=Blockly.Msg.VARIABLES_SET_CREATE_GET;var e={enabled:0<this.workspace.remainingCapacity()},f=this.getField("VAR").getText();e.text=d.replace("%1",f);
+d=Blockly.utils.xml.createElement("field");d.setAttribute("name","VAR");d.setAttribute("variabletype",c);d.appendChild(Blockly.utils.xml.createTextNode(f));f=Blockly.utils.xml.createElement("block");f.setAttribute("type",b);f.appendChild(d);e.callback=Blockly.ContextMenu.callbackFactory(this,f);a.push(e)}else if("variables_get_dynamic"==this.type||"variables_get_reporter_dynamic"==this.type)b={text:Blockly.Msg.RENAME_VARIABLE,enabled:!0,callback:Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY(this)},
+f=this.getField("VAR").getText(),e={text:Blockly.Msg.DELETE_VARIABLE.replace("%1",f),enabled:!0,callback:Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY(this)},a.unshift(b),a.unshift(e)},onchange:function(a){a=this.getFieldValue("VAR");a=Blockly.Variables.getVariable(this.workspace,a);"variables_get_dynamic"==this.type?this.outputConnection.setCheck(a.type):this.getInput("VALUE").connection.setCheck(a.type)}};
+Blockly.Constants.VariablesDynamic.RENAME_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();Blockly.Variables.renameVariable(b,c)}};Blockly.Constants.VariablesDynamic.DELETE_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();b.deleteVariableById(c.getId());b.refreshToolboxSelection()}};Blockly.Extensions.registerMixin("contextMenu_variableDynamicSetterGetter",Blockly.Constants.VariablesDynamic.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);
+return Blockly.Blocks;
+}));
+
+
+//# sourceMappingURL=blocks_compressed.js.map

blockly/closure/bin/calcdeps.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python
+#
+# Copyright 2006 The Closure Library Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""Calculates JavaScript dependencies without requiring Google's build system.
+
+It iterates over a number of search paths and builds a dependency tree.  With
+the inputs provided, it walks the dependency tree and outputs all the files
+required for compilation.
+"""
+
+
+import logging
+import os
+import re
+import sys
+
+
+_BASE_REGEX_STRING = '^\s*goog\.%s\(\s*[\'"](.+)[\'"]\s*\)'
+req_regex = re.compile(_BASE_REGEX_STRING % 'require')
+prov_regex = re.compile(_BASE_REGEX_STRING % 'provide')
+ns_regex = re.compile('^ns:((\w+\.)*(\w+))$')
+
+
+def IsValidFile(ref):
+  """Returns true if the provided reference is a file and exists."""
+  return os.path.isfile(ref)
+
+
+def IsJsFile(ref):
+  """Returns true if the provided reference is a JavaScript file."""
+  return ref.endswith('.js')
+
+
+def IsNamespace(ref):
+  """Returns true if the provided reference is a namespace."""
+  return re.match(ns_regex, ref) is not None
+
+
+def IsDirectory(ref):
+  """Returns true if the provided reference is a directory."""
+  return os.path.isdir(ref)
+
+
+def ExpandDirectories(refs):
+  """Expands any directory references into inputs.
+
+  Description:
+    Looks for any directories in the provided references.  Found directories
+    are recursively searched for .js files, which are then added to the result
+    list.
+
+  Args:
+    refs: a list of references such as files, directories, and namespaces
+
+  Returns:
+    A list of references with directories removed and replaced by any
+    .js files that are found in them. Also, the paths will be normalized.
+  """
+  result = []
+  for ref in refs:
+    if IsDirectory(ref):
+      # Disable 'Unused variable' for subdirs
+      # pylint: disable=unused-variable
+      for (directory, subdirs, filenames) in os.walk(ref):
+        for filename in filenames:
+          if IsJsFile(filename):
+            result.append(os.path.join(directory, filename))
+    else:
+      result.append(ref)
+  return map(os.path.normpath, result)
+
+
+class DependencyInfo(object):
+  """Represents a dependency that is used to build and walk a tree."""
+
+  def __init__(self, filename):
+    self.filename = filename
+    self.provides = []
+    self.requires = []
+
+  def __str__(self):
+    return '%s Provides: %s Requires: %s' % (self.filename,
+                                             repr(self.provides),
+                                             repr(self.requires))
+
+
+def BuildDependenciesFromFiles(files):
+  """Build a list of dependencies from a list of files.
+
+  Description:
+    Takes a list of files, extracts their provides and requires, and builds
+    out a list of dependency objects.
+
+  Args:
+    files: a list of files to be parsed for goog.provides and goog.requires.
+
+  Returns:
+    A list of dependency objects, one for each file in the files argument.
+  """
+  result = []
+  filenames = set()
+  for filename in files:
+    if filename in filenames:
+      continue
+
+    # Python 3 requires the file encoding to be specified
+    if (sys.version_info[0] < 3):
+      file_handle = open(filename, 'r')
+    else:
+      file_handle = open(filename, 'r', encoding='utf8')
+
+    try:
+      dep = CreateDependencyInfo(filename, file_handle)
+      result.append(dep)
+    finally:
+      file_handle.close()
+
+    filenames.add(filename)
+
+  return result
+
+
+def CreateDependencyInfo(filename, source):
+  """Create dependency info.
+
+  Args:
+    filename: Filename for source.
+    source: File-like object containing source.
+
+  Returns:
+    A DependencyInfo object with provides and requires filled.
+  """
+  dep = DependencyInfo(filename)
+  for line in source:
+    if re.match(req_regex, line):
+      dep.requires.append(re.search(req_regex, line).group(1))
+    if re.match(prov_regex, line):
+      dep.provides.append(re.search(prov_regex, line).group(1))
+  return dep
+
+
+def BuildDependencyHashFromDependencies(deps):
+  """Builds a hash for searching dependencies by the namespaces they provide.
+
+  Description:
+    Dependency objects can provide multiple namespaces.  This method enumerates
+    the provides of each dependency and adds them to a hash that can be used
+    to easily resolve a given dependency by a namespace it provides.
+
+  Args:
+    deps: a list of dependency objects used to build the hash.
+
+  Raises:
+    Exception: If a multiple files try to provide the same namepace.
+
+  Returns:
+    A hash table { namespace: dependency } that can be used to resolve a
+    dependency by a namespace it provides.
+  """
+  dep_hash = {}
+  for dep in deps:
+    for provide in dep.provides:
+      if provide in dep_hash:
+        raise Exception('Duplicate provide (%s) in (%s, %s)' % (
+            provide,
+            dep_hash[provide].filename,
+            dep.filename))
+      dep_hash[provide] = dep
+  return dep_hash
+
+
+def CalculateDependencies(paths, inputs):
+  """Calculates the dependencies for given inputs.
+
+  Description:
+    This method takes a list of paths (files, directories) and builds a
+    searchable data structure based on the namespaces that each .js file
+    provides.  It then parses through each input, resolving dependencies
+    against this data structure.  The final output is a list of files,
+    including the inputs, that represent all of the code that is needed to
+    compile the given inputs.
+
+  Args:
+    paths: the references (files, directories) that are used to build the
+      dependency hash.
+    inputs: the inputs (files, directories, namespaces) that have dependencies
+      that need to be calculated.
+
+  Raises:
+    Exception: if a provided input is invalid.
+
+  Returns:
+    A list of all files, including inputs, that are needed to compile the given
+    inputs.
+  """
+  deps = BuildDependenciesFromFiles(paths + inputs)
+  search_hash = BuildDependencyHashFromDependencies(deps)
+  result_list = []
+  seen_list = []
+  for input_file in inputs:
+    if IsNamespace(input_file):
+      namespace = re.search(ns_regex, input_file).group(1)
+      if namespace not in search_hash:
+        raise Exception('Invalid namespace (%s)' % namespace)
+      input_file = search_hash[namespace].filename
+    if not IsValidFile(input_file) or not IsJsFile(input_file):
+      raise Exception('Invalid file (%s)' % input_file)
+    seen_list.append(input_file)
+    file_handle = open(input_file, 'r')
+    try:
+      for line in file_handle:
+        if re.match(req_regex, line):
+          require = re.search(req_regex, line).group(1)
+          ResolveDependencies(require, search_hash, result_list, seen_list)
+    finally:
+      file_handle.close()
+    result_list.append(input_file)
+
+  return result_list
+
+
+def FindClosureBasePath(paths):
+  """Given a list of file paths, return Closure base.js path, if any.
+
+  Args:
+    paths: A list of paths.
+
+  Returns:
+    The path to Closure's base.js file including filename, if found.
+  """
+
+  for path in paths:
+    pathname, filename = os.path.split(path)
+
+    if filename == 'base.js':
+      f = open(path)
+
+      is_base = False
+
+      # Sanity check that this is the Closure base file.  Check that this
+      # is where goog is defined.  This is determined by the @provideGoog
+      # flag.
+      for line in f:
+        if '@provideGoog' in line:
+          is_base = True
+          break
+
+      f.close()
+
+      if is_base:
+        return path
+
+def ResolveDependencies(require, search_hash, result_list, seen_list):
+  """Takes a given requirement and resolves all of the dependencies for it.
+
+  Description:
+    A given requirement may require other dependencies.  This method
+    recursively resolves all dependencies for the given requirement.
+
+  Raises:
+    Exception: when require does not exist in the search_hash.
+
+  Args:
+    require: the namespace to resolve dependencies for.
+    search_hash: the data structure used for resolving dependencies.
+    result_list: a list of filenames that have been calculated as dependencies.
+      This variable is the output for this function.
+    seen_list: a list of filenames that have been 'seen'.  This is required
+      for the dependency->dependent ordering.
+  """
+  if require not in search_hash:
+    raise Exception('Missing provider for (%s)' % require)
+
+  dep = search_hash[require]
+  if not dep.filename in seen_list:
+    seen_list.append(dep.filename)
+    for sub_require in dep.requires:
+      ResolveDependencies(sub_require, search_hash, result_list, seen_list)
+    result_list.append(dep.filename)
+
+
+def GetDepsLine(dep, base_path):
+  """Returns a JS string for a dependency statement in the deps.js file.
+
+  Args:
+    dep: The dependency that we're printing.
+    base_path: The path to Closure's base.js including filename.
+  """
+  return 'goog.addDependency("%s", %s, %s);' % (
+      GetRelpath(dep.filename, base_path), dep.provides, dep.requires)
+
+
+def GetRelpath(path, start):
+  """Return a relative path to |path| from |start|."""
+  # NOTE: Python 2.6 provides os.path.relpath, which has almost the same
+  # functionality as this function. Since we want to support 2.4, we have
+  # to implement it manually. :(
+  path_list = os.path.abspath(os.path.normpath(path)).split(os.sep)
+  start_list = os.path.abspath(
+      os.path.normpath(os.path.dirname(start))).split(os.sep)
+
+  common_prefix_count = 0
+  for i in range(0, min(len(path_list), len(start_list))):
+    if path_list[i] != start_list[i]:
+      break
+    common_prefix_count += 1
+
+  # Always use forward slashes, because this will get expanded to a url,
+  # not a file path.
+  return '/'.join(['..'] * (len(start_list) - common_prefix_count) +
+                  path_list[common_prefix_count:])

blockly/closure/goog/base.js

@@ -0,0 +1,531 @@
+// Copyright 2006 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Bootstrap for the Google JS Library (Closure).
+ *
+ * In uncompiled mode base.js will attempt to load Closure's deps file, unless
+ * the global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects
+ * to include their own deps file(s) from different locations.
+ *
+ * Avoid including base.js more than once. This is strictly discouraged and not
+ * supported. goog.require(...) won't work properly in that case.
+ *
+ * @provideGoog
+ */
+
+
+/**
+ * Base namespace for the Closure library.  Checks to see goog is already
+ * defined in the current scope before assigning to prevent clobbering if
+ * base.js is loaded more than once.
+ *
+ * @const
+ */
+var goog = goog || {};
+
+/**
+ * Reference to the global object.
+ * https://www.ecma-international.org/ecma-262/9.0/index.html#sec-global-object
+ *
+ * More info on this implementation here:
+ * https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit
+ *
+ * @const
+ * @suppress {undefinedVars} self won't be referenced unless `this` is falsy.
+ * @type {!Global}
+ */
+goog.global =
+    // Check `this` first for backwards compatibility.
+    // Valid unless running as an ES module or in a function wrapper called
+    //   without setting `this` properly.
+    // Note that base.js can't usefully be imported as an ES module, but it may
+    // be compiled into bundles that are loadable as ES modules.
+    this ||
+    // https://developer.mozilla.org/en-US/docs/Web/API/Window/self
+    // For in-page browser environments and workers.
+    self;
+
+/**
+ * Builds an object structure for the provided namespace path, ensuring that
+ * names that already exist are not overwritten. For example:
+ * "a.b.c" -> a = {};a.b={};a.b.c={};
+ * Used by goog.provide and goog.exportSymbol.
+ * @param {string} name name of the object that this file defines.
+ * @private
+ */
+goog.exportPath_ = function(name) {
+  var parts = name.split('.');
+  var cur = goog.global;
+
+  // Internet Explorer exhibits strange behavior when throwing errors from
+  // methods externed in this manner.  See the testExportSymbolExceptions in
+  // base_test.html for an example.
+  if (!(parts[0] in cur) && typeof cur.execScript != 'undefined') {
+    cur.execScript('var ' + parts[0]);
+  }
+
+  for (var part; parts.length && (part = parts.shift());) {
+    if (cur[part] && cur[part] !== Object.prototype[part]) {
+      cur = cur[part];
+    } else {
+      cur = cur[part] = {};
+    }
+  }
+};
+
+/**
+ * Defines a namespace in Closure.
+ *
+ * A namespace may only be defined once in a codebase. It may be defined using
+ * goog.provide() or goog.module().
+ *
+ * The presence of one or more goog.provide() calls in a file indicates
+ * that the file defines the given objects/namespaces.
+ * Provided symbols must not be null or undefined.
+ *
+ * In addition, goog.provide() creates the object stubs for a namespace
+ * (for example, goog.provide("goog.foo.bar") will create the object
+ * goog.foo.bar if it does not already exist).
+ *
+ * Build tools also scan for provide/require/module statements
+ * to discern dependencies, build dependency files (see deps.js), etc.
+ *
+ * @see goog.require
+ * @see goog.module
+ * @param {string} name Namespace provided by this file in the form
+ *     "goog.package.part".
+ */
+goog.provide = function(name) {
+  // Ensure that the same namespace isn't provided twice.
+  // A goog.module/goog.provide maps a goog.require to a specific file
+  if (goog.isProvided_(name)) {
+    throw Error('Namespace "' + name + '" already declared.');
+  }
+
+  delete goog.implicitNamespaces_[name];
+
+  var namespace = name;
+  while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
+    if (goog.getObjectByName(namespace)) {
+      break;
+    }
+    goog.implicitNamespaces_[namespace] = true;
+  }
+
+  goog.exportPath_(name);
+};
+
+/**
+ * @private {?{
+ *   moduleName: (string|undefined),
+ *   declareLegacyNamespace:boolean,
+ *   type: ?goog.ModuleType
+ * }}
+ */
+goog.moduleLoaderState_ = null;
+
+/**
+ * Check if the given name has been goog.provided. This will return false for
+ * names that are available only as implicit namespaces.
+ * @param {string} name name of the object to look for.
+ * @return {boolean} Whether the name has been provided.
+ * @private
+ */
+goog.isProvided_ = function(name) {
+  return (!goog.implicitNamespaces_[name] &&
+       goog.isDefAndNotNull(goog.getObjectByName(name)));
+};
+
+/**
+ * Namespaces implicitly defined by goog.provide. For example,
+ * goog.provide('goog.events.Event') implicitly declares that 'goog' and
+ * 'goog.events' must be namespaces.
+ *
+ * @type {!Object<string, (boolean|undefined)>}
+ * @private
+ */
+goog.implicitNamespaces_ = {};
+
+// NOTE: We add goog.module as an implicit namespace as goog.module is defined
+// here and because the existing module package has not been moved yet out of
+// the goog.module namespace. This satisfies both the debug loader and
+// ahead-of-time dependency management.
+
+
+/**
+ * Returns an object based on its fully qualified external name.  The object
+ * is not found if null or undefined.  If you are using a compilation pass that
+ * renames property names beware that using this function will not find renamed
+ * properties.
+ *
+ * @param {string} name The fully qualified name.
+ * @param {Object=} opt_obj The object within which to look; default is
+ *     |goog.global|.
+ * @return {?} The value (object or primitive) or, if not found, null.
+ */
+goog.getObjectByName = function(name, opt_obj) {
+  var parts = name.split('.');
+  var cur = opt_obj || goog.global;
+  for (var i = 0; i < parts.length; i++) {
+    cur = cur[parts[i]];
+    if (!goog.isDefAndNotNull(cur)) {
+      return null;
+    }
+  }
+  return cur;
+};
+
+
+/**
+ * Adds a dependency from a file to the files it requires.
+ * @param {string} relPath The path to the js file.
+ * @param {!Array<string>} provides An array of strings with
+ *     the names of the objects this file provides.
+ * @param {!Array<string>} requires An array of strings with
+ *     the names of the objects this file requires.
+ */
+goog.addDependency = function(relPath, provides, requires) {
+  goog.debugLoader_.addDependency(relPath, provides, requires);
+};
+
+
+
+
+// NOTE(nnaze): The debug DOM loader was included in base.js as an original way
+// to do "debug-mode" development.  The dependency system can sometimes be
+// confusing, as can the debug DOM loader's asynchronous nature.
+//
+// With the DOM loader, a call to goog.require() is not blocking -- the script
+// will not load until some point after the current script.  If a namespace is
+// needed at runtime, it needs to be defined in a previous script, or loaded via
+// require() with its registered dependencies.
+//
+// User-defined namespaces may need their own deps file. For a reference on
+// creating a deps file, see:
+// Externally: https://developers.google.com/closure/library/docs/depswriter
+//
+// Because of legacy clients, the DOM loader can't be easily removed from
+// base.js.  Work was done to make it disableable or replaceable for
+// different environments (DOM-less JavaScript interpreters like Rhino or V8,
+// for example). See bootstrap/ for more information.
+
+
+/**
+ * Implements a system for the dynamic resolution of dependencies that works in
+ * parallel with the BUILD system.
+ *
+ * Note that all calls to goog.require will be stripped by the compiler.
+ *
+ * @see goog.provide
+ * @param {string} namespace Namespace (as was given in goog.provide,
+ *     goog.module, or goog.declareModuleId) in the form
+ *     "goog.package.part".
+ * @return {?} If called within a goog.module or ES6 module file, the associated
+ *     namespace or module otherwise null.
+ */
+goog.require = function(namespace) {
+  // If the object already exists we do not need to do anything.
+  if (!goog.isProvided_(namespace)) {
+    var moduleLoaderState = goog.moduleLoaderState_;
+    goog.moduleLoaderState_ = null;
+    try {
+      goog.debugLoader_.load_(namespace);
+    } finally {
+      goog.moduleLoaderState_ = moduleLoaderState;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Requires a symbol for its type information. This is an indication to the
+ * compiler that the symbol may appear in type annotations, yet it is not
+ * referenced at runtime.
+ *
+ * When called within a goog.module or ES6 module file, the return value may be
+ * assigned to or destructured into a variable, but it may not be otherwise used
+ * in code outside of a type annotation.
+ *
+ * Note that all calls to goog.requireType will be stripped by the compiler.
+ *
+ * @param {string} namespace Namespace (as was given in goog.provide,
+ *     goog.module, or goog.declareModuleId) in the form
+ *     "goog.package.part".
+ * @return {?}
+ */
+goog.requireType = function(namespace) {
+  // Return an empty object so that single-level destructuring of the return
+  // value doesn't crash at runtime when using the debug loader. Multi-level
+  // destructuring isn't supported.
+  return {};
+};
+
+/**
+ * Path for included scripts.
+ * @type {string}
+ */
+goog.basePath = '';
+
+/**
+ * Normalize a file path by removing redundant ".." and extraneous "." file
+ * path components.
+ * @param {string} path
+ * @return {string}
+ * @private
+ */
+goog.normalizePath_ = function(path) {
+  var components = path.split('/');
+  var i = 0;
+  while (i < components.length) {
+    if (components[i] == '.') {
+      components.splice(i, 1);
+    } else if (
+        i && components[i] == '..' && components[i - 1] &&
+        components[i - 1] != '..') {
+      components.splice(--i, 2);
+    } else {
+      i++;
+    }
+  }
+  return components.join('/');
+};
+
+
+//==============================================================================
+// Language Enhancements
+//==============================================================================
+
+
+/**
+ * Returns true if the specified value is defined and not null.
+ * @param {?} val Variable to test.
+ * @return {boolean} Whether variable is defined and not null.
+ */
+goog.isDefAndNotNull = function(val) {
+  // Note that undefined == null.
+  return val != null;
+};
+
+//==============================================================================
+// goog.defineClass implementation
+//==============================================================================
+
+
+// There's a bug in the compiler where without collapse properties the
+// Closure namespace defines do not guard code correctly. To help reduce code
+// size also check for !COMPILED even though it redundant until this is fixed.
+
+/**
+ * Tries to detect the base path of base.js script that bootstraps Closure.
+ * @private
+ */
+goog.findBasePath_ = function() {
+  /** @type {!Document} */
+  var doc = goog.global.document;
+  // If we have a currentScript available, use it exclusively.
+  var currentScript = doc.currentScript;
+  if (currentScript) {
+    var scripts = [currentScript];
+  } else {
+    var scripts = doc.getElementsByTagName('SCRIPT');
+  }
+  // Search backwards since the current script is in almost all cases the one
+  // that has base.js.
+  for (var i = scripts.length - 1; i >= 0; --i) {
+    var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
+    var src = script.src;
+    var qmark = src.lastIndexOf('?');
+    var l = qmark == -1 ? src.length : qmark;
+    if (src.substr(l - 7, 7) == 'base.js') {
+      goog.basePath = src.substr(0, l - 7);
+      return;
+    }
+  }
+};
+
+goog.findBasePath_();
+
+/**
+ * A debug loader is responsible for downloading and executing javascript
+ * files in an unbundled, uncompiled environment.
+ *
+ * @struct @constructor @final @private
+ */
+goog.DebugLoader_ = function() {
+  /** @private @const {!Object<string, !goog.Dependency>} */
+  this.dependencies_ = {};
+  /** @private @const {!Object<string, string>} */
+  this.idToPath_ = {};
+  /** @private @const {!Object<string, boolean>} */
+  this.written_ = {};
+  /** @private {!Array<!goog.Dependency>} */
+  this.depsToLoad_ = [];
+};
+
+
+/**
+ * Travserses the dependency graph and queues the given dependency, and all of
+ * its transitive dependencies, for loading and then starts loading if not
+ * paused.
+ *
+ * @param {string} namespace
+ * @private
+ */
+goog.DebugLoader_.prototype.load_ = function(namespace) {
+  if (!this.getPathFromDeps_(namespace)) {
+    throw Error('goog.require could not find: ' + namespace);
+  } else {
+    var loader = this;
+
+    var deps = [];
+
+    /** @param {string} namespace */
+    var visit = function(namespace) {
+      var path = loader.getPathFromDeps_(namespace);
+
+      if (!path) {
+        throw Error('Bad dependency path or symbol: ' + namespace);
+      }
+
+      if (loader.written_[path]) {
+        return;
+      }
+
+      loader.written_[path] = true;
+
+      var dep = loader.dependencies_[path];
+      for (var i = 0; i < dep.requires.length; i++) {
+        if (!goog.isProvided_(dep.requires[i])) {
+          visit(dep.requires[i]);
+        }
+      }
+
+      deps.push(dep);
+    };
+
+    visit(namespace);
+
+    var wasLoading = !!this.depsToLoad_.length;
+    this.depsToLoad_ = this.depsToLoad_.concat(deps);
+
+    if (!wasLoading) {
+      this.loadDeps_();
+    }
+  }
+};
+
+
+/**
+ * Loads any queued dependencies until they are all loaded or paused.
+ *
+ * @private
+ */
+goog.DebugLoader_.prototype.loadDeps_ = function() {
+  var loader = this;
+
+  while (this.depsToLoad_.length) {
+    (function() {
+      var loadCallDone = false;
+      var dep = loader.depsToLoad_.shift();
+
+      try {
+        dep.load();
+      } finally {
+        loadCallDone = true;
+      }
+    })();
+  }
+};
+
+
+/**
+ * @param {string} absPathOrId
+ * @return {?string}
+ * @private
+ */
+goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
+  return this.idToPath_[absPathOrId];
+};
+
+
+/**
+ * Basic super class for all dependencies Closure Library can load.
+ *
+ * This default implementation is designed to load untranspiled, non-module
+ * scripts in a web broswer.
+ *
+ * For transpiled non-goog.module files {@see goog.TranspiledDependency}.
+ * For goog.modules see {@see goog.GoogModuleDependency}.
+ * For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.
+ *
+ * @param {string} path Absolute path of this script.
+ * @param {!Array<string>} requires goog symbols or relative paths to Closure
+ *     this depends on.
+ * @struct @constructor
+ */
+goog.Dependency = function(path, requires) {
+  /** @const */
+  this.path = path;
+  /** @const */
+  this.requires = requires;
+};
+
+/**
+ * Map of script ready / state change callbacks. Old IE cannot handle putting
+ * these properties on goog.global.
+ *
+ * @private @const {!Object<string, function(?):undefined>}
+ */
+goog.Dependency.callbackMap_ = {};
+
+
+/**
+ * Starts loading this dependency. This dependency can pause loading if it
+ * needs to and resume it later via the controller interface.
+ *
+ * When this is loaded it should call controller.loaded(). Note that this will
+ * end up calling the loaded method of this dependency; there is no need to
+ * call it explicitly.
+ */
+goog.Dependency.prototype.load = function() {
+  /** @type {!HTMLDocument} */
+  var doc = goog.global.document;
+  doc.write('<script src="' + this.path + '" type="text/javascript"><' +
+      '/script>');
+};
+
+
+/**
+ * @param {string} relPath
+ * @param {!Array<string>|undefined} provides
+ * @param {!Array<string>} requires
+ * @see goog.addDependency
+ */
+goog.DebugLoader_.prototype.addDependency = function(
+    relPath, provides, requires) {
+  relPath = relPath.replace(/\\/g, '/');
+  var path = goog.normalizePath_(goog.basePath + relPath);
+  var dep = new goog.Dependency(path, requires);
+  this.dependencies_[path] = dep;
+  for (var i = 0; i < provides.length; i++) {
+    this.idToPath_[provides[i]] = path;
+  }
+  this.idToPath_[relPath] = path;
+};
+
+
+/** @private @const */
+goog.debugLoader_ = new goog.DebugLoader_();

blockly/core/block_animations.js

@@ -0,0 +1,205 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Methods animating a block on connection and disconnection.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.blockAnimations');
+
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.Svg');
+
+goog.requireType('Blockly.BlockSvg');
+
+
+/**
+ * PID of disconnect UI animation.  There can only be one at a time.
+ * @type {number}
+ * @private
+ */
+Blockly.blockAnimations.disconnectPid_ = 0;
+
+/**
+ * SVG group of wobbling block.  There can only be one at a time.
+ * @type {Element}
+ * @private
+ */
+Blockly.blockAnimations.disconnectGroup_ = null;
+
+/**
+ * Play some UI effects (sound, animation) when disposing of a block.
+ * @param {!Blockly.BlockSvg} block The block being disposed of.
+ * @package
+ */
+Blockly.blockAnimations.disposeUiEffect = function(block) {
+  var workspace = block.workspace;
+  var svgGroup = block.getSvgRoot();
+  workspace.getAudioManager().play('delete');
+
+  var xy = workspace.getSvgXY(svgGroup);
+  // Deeply clone the current block.
+  var clone = svgGroup.cloneNode(true);
+  clone.translateX_ = xy.x;
+  clone.translateY_ = xy.y;
+  clone.setAttribute('transform', 'translate(' + xy.x + ',' + xy.y + ')');
+  workspace.getParentSvg().appendChild(clone);
+  clone.bBox_ = clone.getBBox();
+  // Start the animation.
+  Blockly.blockAnimations.disposeUiStep_(clone, workspace.RTL, new Date,
+      workspace.scale);
+};
+
+/**
+ * Animate a cloned block and eventually dispose of it.
+ * This is a class method, not an instance method since the original block has
+ * been destroyed and is no longer accessible.
+ * @param {!Element} clone SVG element to animate and dispose of.
+ * @param {boolean} rtl True if RTL, false if LTR.
+ * @param {!Date} start Date of animation's start.
+ * @param {number} workspaceScale Scale of workspace.
+ * @private
+ */
+Blockly.blockAnimations.disposeUiStep_ = function(clone, rtl, start,
+    workspaceScale) {
+  var ms = new Date - start;
+  var percent = ms / 150;
+  if (percent > 1) {
+    Blockly.utils.dom.removeNode(clone);
+  } else {
+    var x = clone.translateX_ +
+        (rtl ? -1 : 1) * clone.bBox_.width * workspaceScale / 2 * percent;
+    var y = clone.translateY_ + clone.bBox_.height * workspaceScale * percent;
+    var scale = (1 - percent) * workspaceScale;
+    clone.setAttribute('transform', 'translate(' + x + ',' + y + ')' +
+        ' scale(' + scale + ')');
+    setTimeout(Blockly.blockAnimations.disposeUiStep_, 10, clone, rtl, start,
+        workspaceScale);
+  }
+};
+
+/**
+ * Play some UI effects (sound, ripple) after a connection has been established.
+ * @param {!Blockly.BlockSvg} block The block being connected.
+ * @package
+ */
+Blockly.blockAnimations.connectionUiEffect = function(block) {
+  var workspace = block.workspace;
+  var scale = workspace.scale;
+  workspace.getAudioManager().play('click');
+  if (scale < 1) {
+    return;  // Too small to care about visual effects.
+  }
+  // Determine the absolute coordinates of the inferior block.
+  var xy = workspace.getSvgXY(block.getSvgRoot());
+  // Offset the coordinates based on the two connection types, fix scale.
+  if (block.outputConnection) {
+    xy.x += (block.RTL ? 3 : -3) * scale;
+    xy.y += 13 * scale;
+  } else if (block.previousConnection) {
+    xy.x += (block.RTL ? -23 : 23) * scale;
+    xy.y += 3 * scale;
+  }
+  var ripple = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.CIRCLE,
+      {
+        'cx': xy.x,
+        'cy': xy.y,
+        'r': 0,
+        'fill': 'none',
+        'stroke': '#888',
+        'stroke-width': 10
+      },
+      workspace.getParentSvg());
+  // Start the animation.
+  Blockly.blockAnimations.connectionUiStep_(ripple, new Date, scale);
+};
+
+/**
+ * Expand a ripple around a connection.
+ * @param {!SVGElement} ripple Element to animate.
+ * @param {!Date} start Date of animation's start.
+ * @param {number} scale Scale of workspace.
+ * @private
+ */
+Blockly.blockAnimations.connectionUiStep_ = function(ripple, start, scale) {
+  var ms = new Date - start;
+  var percent = ms / 150;
+  if (percent > 1) {
+    Blockly.utils.dom.removeNode(ripple);
+  } else {
+    ripple.setAttribute('r', percent * 25 * scale);
+    ripple.style.opacity = 1 - percent;
+    Blockly.blockAnimations.disconnectPid_ = setTimeout(
+        Blockly.blockAnimations.connectionUiStep_, 10, ripple, start, scale);
+  }
+};
+
+/**
+ * Play some UI effects (sound, animation) when disconnecting a block.
+ * @param {!Blockly.BlockSvg} block The block being disconnected.
+ * @package
+ */
+Blockly.blockAnimations.disconnectUiEffect = function(block) {
+  block.workspace.getAudioManager().play('disconnect');
+  if (block.workspace.scale < 1) {
+    return;  // Too small to care about visual effects.
+  }
+  // Horizontal distance for bottom of block to wiggle.
+  var DISPLACEMENT = 10;
+  // Scale magnitude of skew to height of block.
+  var height = block.getHeightWidth().height;
+  var magnitude = Math.atan(DISPLACEMENT / height) / Math.PI * 180;
+  if (!block.RTL) {
+    magnitude *= -1;
+  }
+  // Start the animation.
+  Blockly.blockAnimations.disconnectUiStep_(
+      block.getSvgRoot(), magnitude, new Date);
+};
+/**
+ * Animate a brief wiggle of a disconnected block.
+ * @param {!SVGElement} group SVG element to animate.
+ * @param {number} magnitude Maximum degrees skew (reversed for RTL).
+ * @param {!Date} start Date of animation's start.
+ * @private
+ */
+Blockly.blockAnimations.disconnectUiStep_ = function(group, magnitude, start) {
+  var DURATION = 200;  // Milliseconds.
+  var WIGGLES = 3;  // Half oscillations.
+
+  var ms = new Date - start;
+  var percent = ms / DURATION;
+
+  if (percent > 1) {
+    group.skew_ = '';
+  } else {
+    var skew = Math.round(
+        Math.sin(percent * Math.PI * WIGGLES) * (1 - percent) * magnitude);
+    group.skew_ = 'skewX(' + skew + ')';
+    Blockly.blockAnimations.disconnectGroup_ = group;
+    Blockly.blockAnimations.disconnectPid_ =
+        setTimeout(Blockly.blockAnimations.disconnectUiStep_, 10, group,
+            magnitude, start);
+  }
+  group.setAttribute('transform', group.translate_ + group.skew_);
+};
+
+/**
+ * Stop the disconnect UI animation immediately.
+ * @package
+ */
+Blockly.blockAnimations.disconnectUiStop = function() {
+  if (Blockly.blockAnimations.disconnectGroup_) {
+    clearTimeout(Blockly.blockAnimations.disconnectPid_);
+    var group = Blockly.blockAnimations.disconnectGroup_;
+    group.skew_ = '';
+    group.setAttribute('transform', group.translate_);
+    Blockly.blockAnimations.disconnectGroup_ = null;
+  }
+};

blockly/core/block_drag_surface.js

@@ -0,0 +1,259 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview A class that manages a surface for dragging blocks.  When a
+ * block drag is started, we move the block (and children) to a separate DOM
+ * element that we move around using translate3d. At the end of the drag, the
+ * blocks are put back in into the SVG they came from. This helps performance by
+ * avoiding repainting the entire SVG on every mouse move while dragging blocks.
+ * @author picklesrus
+ */
+
+'use strict';
+
+goog.provide('Blockly.BlockDragSurfaceSvg');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.Coordinate');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.Svg');
+
+
+/**
+ * Class for a drag surface for the currently dragged block. This is a separate
+ * SVG that contains only the currently moving block, or nothing.
+ * @param {!Element} container Containing element.
+ * @constructor
+ */
+Blockly.BlockDragSurfaceSvg = function(container) {
+  /**
+   * @type {!Element}
+   * @private
+   */
+  this.container_ = container;
+  this.createDom();
+};
+
+/**
+ * The SVG drag surface. Set once by Blockly.BlockDragSurfaceSvg.createDom.
+ * @type {?SVGElement}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.SVG_ = null;
+
+/**
+ * This is where blocks live while they are being dragged if the drag surface
+ * is enabled.
+ * @type {?SVGElement}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.dragGroup_ = null;
+
+/**
+ * Containing HTML element; parent of the workspace and the drag surface.
+ * @type {?Element}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.container_ = null;
+
+/**
+ * Cached value for the scale of the drag surface.
+ * Used to set/get the correct translation during and after a drag.
+ * @type {number}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.scale_ = 1;
+
+/**
+ * Cached value for the translation of the drag surface.
+ * This translation is in pixel units, because the scale is applied to the
+ * drag group rather than the top-level SVG.
+ * @type {?Blockly.utils.Coordinate}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.surfaceXY_ = null;
+
+/**
+ * Cached value for the translation of the child drag surface in pixel units.
+ * Since the child drag surface tracks the translation of the workspace this is
+ * ultimately the translation of the workspace.
+ * @type {!Blockly.utils.Coordinate}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.childSurfaceXY_ =
+    new Blockly.utils.Coordinate(0, 0);
+
+/**
+ * Create the drag surface and inject it into the container.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.createDom = function() {
+  if (this.SVG_) {
+    return;  // Already created.
+  }
+  this.SVG_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.SVG, {
+        'xmlns': Blockly.utils.dom.SVG_NS,
+        'xmlns:html': Blockly.utils.dom.HTML_NS,
+        'xmlns:xlink': Blockly.utils.dom.XLINK_NS,
+        'version': '1.1',
+        'class': 'blocklyBlockDragSurface'
+      },
+      this.container_);
+  this.dragGroup_ =
+      Blockly.utils.dom.createSvgElement(Blockly.utils.Svg.G, {}, this.SVG_);
+};
+
+/**
+ * Set the SVG blocks on the drag surface's group and show the surface.
+ * Only one block group should be on the drag surface at a time.
+ * @param {!SVGElement} blocks Block or group of blocks to place on the drag
+ * surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.setBlocksAndShow = function(blocks) {
+  if (this.dragGroup_.childNodes.length) {
+    throw Error('Already dragging a block.');
+  }
+  // appendChild removes the blocks from the previous parent
+  this.dragGroup_.appendChild(blocks);
+  this.SVG_.style.display = 'block';
+  this.surfaceXY_ = new Blockly.utils.Coordinate(0, 0);
+};
+
+/**
+ * Translate and scale the entire drag surface group to the given position, to
+ * keep in sync with the workspace.
+ * @param {number} x X translation in pixel coordinates.
+ * @param {number} y Y translation in pixel coordinates.
+ * @param {number} scale Scale of the group.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.translateAndScaleGroup = function(
+    x, y, scale) {
+  this.scale_ = scale;
+  // This is a work-around to prevent a the blocks from rendering
+  // fuzzy while they are being dragged on the drag surface.
+  var fixedX = x.toFixed(0);
+  var fixedY = y.toFixed(0);
+
+  this.childSurfaceXY_.x = parseInt(fixedX, 10);
+  this.childSurfaceXY_.y = parseInt(fixedY, 10);
+
+  this.dragGroup_.setAttribute(
+      'transform',
+      'translate(' + fixedX + ',' + fixedY + ') scale(' + scale + ')');
+};
+
+/**
+ * Translate the drag surface's SVG based on its internal state.
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.translateSurfaceInternal_ = function() {
+  var x = this.surfaceXY_.x;
+  var y = this.surfaceXY_.y;
+  // This is a work-around to prevent a the blocks from rendering
+  // fuzzy while they are being dragged on the drag surface.
+  x = x.toFixed(0);
+  y = y.toFixed(0);
+  this.SVG_.style.display = 'block';
+
+  Blockly.utils.dom.setCssTransform(
+      this.SVG_, 'translate3d(' + x + 'px, ' + y + 'px, 0px)');
+};
+
+/**
+ * Translates the entire surface by a relative offset.
+ * @param {number} deltaX Horizontal offset in pixel units.
+ * @param {number} deltaY Vertical offset in pixel units.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.translateBy = function(deltaX, deltaY) {
+  var x = this.surfaceXY_.x + deltaX;
+  var y = this.surfaceXY_.y + deltaY;
+  this.surfaceXY_ = new Blockly.utils.Coordinate(x, y);
+  this.translateSurfaceInternal_();
+};
+
+/**
+ * Translate the entire drag surface during a drag.
+ * We translate the drag surface instead of the blocks inside the surface
+ * so that the browser avoids repainting the SVG.
+ * Because of this, the drag coordinates must be adjusted by scale.
+ * @param {number} x X translation for the entire surface.
+ * @param {number} y Y translation for the entire surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.translateSurface = function(x, y) {
+  this.surfaceXY_ =
+      new Blockly.utils.Coordinate(x * this.scale_, y * this.scale_);
+  this.translateSurfaceInternal_();
+};
+
+/**
+ * Reports the surface translation in scaled workspace coordinates.
+ * Use this when finishing a drag to return blocks to the correct position.
+ * @return {!Blockly.utils.Coordinate} Current translation of the surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.getSurfaceTranslation = function() {
+  var xy = Blockly.utils.getRelativeXY(/** @type {!SVGElement} */ (this.SVG_));
+  return new Blockly.utils.Coordinate(xy.x / this.scale_, xy.y / this.scale_);
+};
+
+/**
+ * Provide a reference to the drag group (primarily for
+ * BlockSvg.getRelativeToSurfaceXY).
+ * @return {?SVGElement} Drag surface group element.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.getGroup = function() {
+  return this.dragGroup_;
+};
+
+/**
+ * Returns the SVG drag surface.
+ * @returns {?SVGElement} The SVG drag surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.getSvgRoot = function() {
+  return this.SVG_;
+};
+
+/**
+ * Get the current blocks on the drag surface, if any (primarily
+ * for BlockSvg.getRelativeToSurfaceXY).
+ * @return {?Element} Drag surface block DOM element, or null if no blocks exist.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.getCurrentBlock = function() {
+  return /** @type {Element} */ (this.dragGroup_.firstChild);
+};
+
+/**
+ * Gets the translation of the child block surface
+ * This surface is in charge of keeping track of how much the workspace has
+ * moved.
+ * @return {!Blockly.utils.Coordinate} The amount the workspace has been moved.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.getWsTranslation = function() {
+  // Returning a copy so the coordinate can not be changed outside this class.
+  return this.childSurfaceXY_.clone();
+};
+
+/**
+ * Clear the group and hide the surface; move the blocks off onto the provided
+ * element.
+ * If the block is being deleted it doesn't need to go back to the original
+ * surface, since it would be removed immediately during dispose.
+ * @param {Element=} opt_newSurface Surface the dragging blocks should be moved
+ *     to, or null if the blocks should be removed from this surface without
+ *     being moved to a different surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.clearAndHide = function(opt_newSurface) {
+  if (opt_newSurface) {
+    // appendChild removes the node from this.dragGroup_
+    opt_newSurface.appendChild(this.getCurrentBlock());
+  } else {
+    this.dragGroup_.removeChild(this.getCurrentBlock());
+  }
+  this.SVG_.style.display = 'none';
+  if (this.dragGroup_.childNodes.length) {
+    throw Error('Drag group was not cleared.');
+  }
+  this.surfaceXY_ = null;
+};

blockly/core/block_dragger.js

@@ -0,0 +1,472 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Methods for dragging a block visually.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.BlockDragger');
+
+goog.require('Blockly.blockAnimations');
+/** @suppress {extraRequire} */
+goog.require('Blockly.constants');
+goog.require('Blockly.Events');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BlockDrag');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BlockMove');
+goog.require('Blockly.IBlockDragger');
+goog.require('Blockly.InsertionMarkerManager');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.Coordinate');
+goog.require('Blockly.utils.dom');
+
+goog.requireType('Blockly.BlockSvg');
+goog.requireType('Blockly.IDragTarget');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Class for a block dragger.  It moves blocks around the workspace when they
+ * are being dragged by a mouse or touch.
+ * @param {!Blockly.BlockSvg} block The block to drag.
+ * @param {!Blockly.WorkspaceSvg} workspace The workspace to drag on.
+ * @constructor
+ * @implements {Blockly.IBlockDragger}
+ */
+Blockly.BlockDragger = function(block, workspace) {
+  /**
+   * The top block in the stack that is being dragged.
+   * @type {!Blockly.BlockSvg}
+   * @protected
+   */
+  this.draggingBlock_ = block;
+
+  /**
+   * The workspace on which the block is being dragged.
+   * @type {!Blockly.WorkspaceSvg}
+   * @protected
+   */
+  this.workspace_ = workspace;
+
+  /**
+   * Object that keeps track of connections on dragged blocks.
+   * @type {!Blockly.InsertionMarkerManager}
+   * @protected
+   */
+  this.draggedConnectionManager_ =
+      new Blockly.InsertionMarkerManager(this.draggingBlock_);
+
+  /**
+   * Which drag area the mouse pointer is over, if any.
+   * @type {?Blockly.IDragTarget}
+   * @private
+   */
+  this.dragTarget_ = null;
+
+  /**
+   * Whether the block would be deleted if dropped immediately.
+   * @type {boolean}
+   * @protected
+   */
+  this.wouldDeleteBlock_ = false;
+
+  /**
+   * The location of the top left corner of the dragging block at the beginning
+   * of the drag in workspace coordinates.
+   * @type {!Blockly.utils.Coordinate}
+   * @protected
+   */
+  this.startXY_ = this.draggingBlock_.getRelativeToSurfaceXY();
+
+  /**
+   * A list of all of the icons (comment, warning, and mutator) that are
+   * on this block and its descendants.  Moving an icon moves the bubble that
+   * extends from it if that bubble is open.
+   * @type {Array<!Object>}
+   * @protected
+   */
+  this.dragIconData_ = Blockly.BlockDragger.initIconData_(block);
+};
+
+/**
+ * Sever all links from this object.
+ * @package
+ */
+Blockly.BlockDragger.prototype.dispose = function() {
+  this.dragIconData_.length = 0;
+
+  if (this.draggedConnectionManager_) {
+    this.draggedConnectionManager_.dispose();
+  }
+};
+
+/**
+ * Make a list of all of the icons (comment, warning, and mutator) that are
+ * on this block and its descendants.  Moving an icon moves the bubble that
+ * extends from it if that bubble is open.
+ * @param {!Blockly.BlockSvg} block The root block that is being dragged.
+ * @return {!Array<!Object>} The list of all icons and their locations.
+ * @private
+ */
+Blockly.BlockDragger.initIconData_ = function(block) {
+  // Build a list of icons that need to be moved and where they started.
+  var dragIconData = [];
+  var descendants = block.getDescendants(false);
+  for (var i = 0, descendant; (descendant = descendants[i]); i++) {
+    var icons = descendant.getIcons();
+    for (var j = 0; j < icons.length; j++) {
+      var data = {
+        // Blockly.utils.Coordinate with x and y properties (workspace
+        // coordinates).
+        location: icons[j].getIconLocation(),
+        // Blockly.Icon
+        icon: icons[j]
+      };
+      dragIconData.push(data);
+    }
+  }
+  return dragIconData;
+};
+
+/**
+ * Start dragging a block.  This includes moving it to the drag surface.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at mouse down, in pixel units.
+ * @param {boolean} healStack Whether or not to heal the stack after
+ *     disconnecting.
+ * @public
+ */
+Blockly.BlockDragger.prototype.startDrag = function(
+    currentDragDeltaXY, healStack) {
+  if (!Blockly.Events.getGroup()) {
+    Blockly.Events.setGroup(true);
+  }
+  this.fireDragStartEvent_();
+
+  // Mutators don't have the same type of z-ordering as the normal workspace
+  // during a drag.  They have to rely on the order of the blocks in the SVG.
+  // For performance reasons that usually happens at the end of a drag,
+  // but do it at the beginning for mutators.
+  if (this.workspace_.isMutator) {
+    this.draggingBlock_.bringToFront();
+  }
+
+  // During a drag there may be a lot of rerenders, but not field changes.
+  // Turn the cache on so we don't do spurious remeasures during the drag.
+  Blockly.utils.dom.startTextWidthCache();
+  this.workspace_.setResizesEnabled(false);
+  Blockly.blockAnimations.disconnectUiStop();
+
+  if (this.shouldDisconnect_(healStack)) {
+    this.disconnectBlock_(healStack, currentDragDeltaXY);
+  }
+  this.draggingBlock_.setDragging(true);
+  // For future consideration: we may be able to put moveToDragSurface inside
+  // the block dragger, which would also let the block not track the block drag
+  // surface.
+  this.draggingBlock_.moveToDragSurface();
+};
+
+/**
+ * Whether or not we should disconnect the block when a drag is started.
+ * @param {boolean} healStack Whether or not to heal the stack after
+ *     disconnecting.
+ * @return {boolean} True to disconnect the block, false otherwise.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.shouldDisconnect_ = function(healStack) {
+  return !!(
+    this.draggingBlock_.getParent() ||
+      (healStack && this.draggingBlock_.nextConnection &&
+       this.draggingBlock_.nextConnection.targetBlock()));
+};
+
+/**
+ * Disconnects the block and moves it to a new location.
+ * @param {boolean} healStack Whether or not to heal the stack after
+ *     disconnecting.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at mouse down, in pixel units.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.disconnectBlock_ = function(
+    healStack, currentDragDeltaXY) {
+  this.draggingBlock_.unplug(healStack);
+  var delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+  var newLoc = Blockly.utils.Coordinate.sum(this.startXY_, delta);
+
+  this.draggingBlock_.translate(newLoc.x, newLoc.y);
+  Blockly.blockAnimations.disconnectUiEffect(this.draggingBlock_);
+  this.draggedConnectionManager_.updateAvailableConnections();
+};
+
+/**
+ * Fire a UI event at the start of a block drag.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.fireDragStartEvent_ = function() {
+  var event = new (Blockly.Events.get(Blockly.Events.BLOCK_DRAG))(
+      this.draggingBlock_, true, this.draggingBlock_.getDescendants(false));
+  Blockly.Events.fire(event);
+};
+
+/**
+ * Execute a step of block dragging, based on the given event.  Update the
+ * display accordingly.
+ * @param {!Event} e The most recent move event.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at the start of the drag, in pixel units.
+ * @public
+ */
+Blockly.BlockDragger.prototype.drag = function(e, currentDragDeltaXY) {
+  var delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+  var newLoc = Blockly.utils.Coordinate.sum(this.startXY_, delta);
+  this.draggingBlock_.moveDuringDrag(newLoc);
+  this.dragIcons_(delta);
+
+  var oldDragTarget = this.dragTarget_;
+  this.dragTarget_ = this.workspace_.getDragTarget(e);
+
+  this.draggedConnectionManager_.update(delta, this.dragTarget_);
+  var oldWouldDeleteBlock = this.wouldDeleteBlock_;
+  this.wouldDeleteBlock_ = this.draggedConnectionManager_.wouldDeleteBlock();
+  if (oldWouldDeleteBlock != this.wouldDeleteBlock_) {
+    // Prevent unnecessary add/remove class calls.
+    this.updateCursorDuringBlockDrag_();
+  }
+
+  // Call drag enter/exit/over after wouldDeleteBlock is called in
+  // InsertionMarkerManager.update.
+  if (this.dragTarget_ !== oldDragTarget) {
+    oldDragTarget && oldDragTarget.onDragExit(this.draggingBlock_);
+    this.dragTarget_ && this.dragTarget_.onDragEnter(this.draggingBlock_);
+  }
+  this.dragTarget_ && this.dragTarget_.onDragOver(this.draggingBlock_);
+};
+
+/**
+ * Finish a block drag and put the block back on the workspace.
+ * @param {!Event} e The mouseup/touchend event.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at the start of the drag, in pixel units.
+ * @public
+ */
+Blockly.BlockDragger.prototype.endDrag = function(e, currentDragDeltaXY) {
+  // Make sure internal state is fresh.
+  this.drag(e, currentDragDeltaXY);
+  this.dragIconData_ = [];
+  this.fireDragEndEvent_();
+
+  Blockly.utils.dom.stopTextWidthCache();
+
+  Blockly.blockAnimations.disconnectUiStop();
+
+  var preventMove = !!this.dragTarget_ &&
+      this.dragTarget_.shouldPreventMove(this.draggingBlock_);
+  if (preventMove) {
+    var newLoc = this.startXY_;
+  } else {
+    var newValues = this.getNewLocationAfterDrag_(currentDragDeltaXY);
+    var delta = newValues.delta;
+    var newLoc = newValues.newLocation;
+  }
+  this.draggingBlock_.moveOffDragSurface(newLoc);
+
+  if (this.dragTarget_) {
+    this.dragTarget_.onDrop(this.draggingBlock_);
+  }
+
+  var deleted = this.maybeDeleteBlock_();
+  if (!deleted) {
+    // These are expensive and don't need to be done if we're deleting.
+    this.draggingBlock_.setDragging(false);
+    if (delta) {  // !preventMove
+      this.updateBlockAfterMove_(delta);
+    } else {
+      // Blocks dragged directly from a flyout may need to be bumped into
+      // bounds.
+      Blockly.bumpObjectIntoBounds_(
+          this.draggingBlock_.workspace,
+          this.workspace_.getMetricsManager().getScrollMetrics(true),
+          this.draggingBlock_);
+    }
+  }
+  this.workspace_.setResizesEnabled(true);
+
+  Blockly.Events.setGroup(false);
+};
+
+/**
+ * Calculates the drag delta and new location values after a block is dragged.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the start of the drag, in pixel units.
+ * @return {{delta: !Blockly.utils.Coordinate, newLocation:
+ *     !Blockly.utils.Coordinate}} New location after drag. delta is in
+ *     workspace units. newLocation is the new coordinate where the block should
+ *     end up.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.getNewLocationAfterDrag_ = function(
+    currentDragDeltaXY) {
+  var newValues = {};
+  newValues.delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+  newValues.newLocation =
+      Blockly.utils.Coordinate.sum(this.startXY_, newValues.delta);
+  return newValues;
+};
+
+/**
+ * May delete the dragging block, if allowed. If `this.wouldDeleteBlock_` is not
+ * true, the block will not be deleted. This should be called at the end of a
+ * block drag.
+ * @return {boolean} True if the block was deleted.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.maybeDeleteBlock_ = function() {
+  if (this.wouldDeleteBlock_) {
+    // Fire a move event, so we know where to go back to for an undo.
+    this.fireMoveEvent_();
+    this.draggingBlock_.dispose(false, true);
+    Blockly.draggingConnections = [];
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Updates the necessary information to place a block at a certain location.
+ * @param {!Blockly.utils.Coordinate} delta The change in location from where
+ *     the block started the drag to where it ended the drag.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.updateBlockAfterMove_ = function(delta) {
+  this.draggingBlock_.moveConnections(delta.x, delta.y);
+  this.fireMoveEvent_();
+  if (this.draggedConnectionManager_.wouldConnectBlock()) {
+    // Applying connections also rerenders the relevant blocks.
+    this.draggedConnectionManager_.applyConnections();
+  } else {
+    this.draggingBlock_.render();
+  }
+  this.draggingBlock_.scheduleSnapAndBump();
+};
+
+/**
+ * Fire a UI event at the end of a block drag.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.fireDragEndEvent_ = function() {
+  var event = new (Blockly.Events.get(Blockly.Events.BLOCK_DRAG))(
+      this.draggingBlock_, false, this.draggingBlock_.getDescendants(false));
+  Blockly.Events.fire(event);
+};
+
+/**
+ * Adds or removes the style of the cursor for the toolbox.
+ * This is what changes the cursor to display an x when a deletable block is
+ * held over the toolbox.
+ * @param {boolean} isEnd True if we are at the end of a drag, false otherwise.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.updateToolboxStyle_ = function(isEnd) {
+  var toolbox = this.workspace_.getToolbox();
+
+  if (toolbox) {
+    var style = this.draggingBlock_.isDeletable() ? 'blocklyToolboxDelete' :
+                                                    'blocklyToolboxGrab';
+
+    if (isEnd && typeof toolbox.removeStyle == 'function') {
+      toolbox.removeStyle(style);
+    } else if (!isEnd && typeof toolbox.addStyle == 'function') {
+      toolbox.addStyle(style);
+    }
+  }
+};
+
+
+/**
+ * Fire a move event at the end of a block drag.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.fireMoveEvent_ = function() {
+  var event =
+      new (Blockly.Events.get(Blockly.Events.BLOCK_MOVE))(this.draggingBlock_);
+  event.oldCoordinate = this.startXY_;
+  event.recordNew();
+  Blockly.Events.fire(event);
+};
+
+/**
+ * Update the cursor (and possibly the trash can lid) to reflect whether the
+ * dragging block would be deleted if released immediately.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.updateCursorDuringBlockDrag_ = function() {
+  this.draggingBlock_.setDeleteStyle(this.wouldDeleteBlock_);
+};
+
+/**
+ * Convert a coordinate object from pixels to workspace units, including a
+ * correction for mutator workspaces.
+ * This function does not consider differing origins.  It simply scales the
+ * input's x and y values.
+ * @param {!Blockly.utils.Coordinate} pixelCoord A coordinate with x and y
+ *     values in CSS pixel units.
+ * @return {!Blockly.utils.Coordinate} The input coordinate divided by the
+ *     workspace scale.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.pixelsToWorkspaceUnits_ = function(pixelCoord) {
+  var result = new Blockly.utils.Coordinate(
+      pixelCoord.x / this.workspace_.scale,
+      pixelCoord.y / this.workspace_.scale);
+  if (this.workspace_.isMutator) {
+    // If we're in a mutator, its scale is always 1, purely because of some
+    // oddities in our rendering optimizations.  The actual scale is the same as
+    // the scale on the parent workspace.
+    // Fix that for dragging.
+    var mainScale = this.workspace_.options.parentWorkspace.scale;
+    result.scale(1 / mainScale);
+  }
+  return result;
+};
+
+/**
+ * Move all of the icons connected to this drag.
+ * @param {!Blockly.utils.Coordinate} dxy How far to move the icons from their
+ *     original positions, in workspace units.
+ * @protected
+ */
+Blockly.BlockDragger.prototype.dragIcons_ = function(dxy) {
+  // Moving icons moves their associated bubbles.
+  for (var i = 0; i < this.dragIconData_.length; i++) {
+    var data = this.dragIconData_[i];
+    data.icon.setIconLocation(Blockly.utils.Coordinate.sum(data.location, dxy));
+  }
+};
+
+/**
+ * Get a list of the insertion markers that currently exist.  Drags have 0, 1,
+ * or 2 insertion markers.
+ * @return {!Array<!Blockly.BlockSvg>} A possibly empty list of insertion
+ *     marker blocks.
+ * @public
+ */
+Blockly.BlockDragger.prototype.getInsertionMarkers = function() {
+  // No insertion markers with the old style of dragged connection managers.
+  if (this.draggedConnectionManager_ &&
+      this.draggedConnectionManager_.getInsertionMarkers) {
+    return this.draggedConnectionManager_.getInsertionMarkers();
+  }
+  return [];
+};
+
+Blockly.registry.register(
+    Blockly.registry.Type.BLOCK_DRAGGER, Blockly.registry.DEFAULT,
+    Blockly.BlockDragger);

blockly/core/blockly.js

@@ -0,0 +1,598 @@
+/**
+ * @license
+ * Copyright 2011 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Core JavaScript library for Blockly.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+/**
+ * The top level namespace used to access the Blockly library.
+ * @namespace Blockly
+ */
+goog.provide('Blockly');
+
+goog.require('Blockly.browserEvents');
+goog.require('Blockly.ComponentManager');
+goog.require('Blockly.connectionTypes');
+goog.require('Blockly.constants');
+goog.require('Blockly.DropDownDiv');
+goog.require('Blockly.Events');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BlockCreate');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.FinishedLoading');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.Ui');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.UiBase');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.VarCreate');
+/** @suppress {extraRequire} */
+goog.require('Blockly.inject');
+goog.require('Blockly.inputTypes');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Procedures');
+goog.require('Blockly.ShortcutRegistry');
+goog.require('Blockly.Tooltip');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Touch');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.colour');
+goog.require('Blockly.utils.deprecation');
+goog.require('Blockly.utils.Size');
+goog.require('Blockly.utils.toolbox');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Variables');
+goog.require('Blockly.WidgetDiv');
+goog.require('Blockly.WorkspaceSvg');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Xml');
+
+goog.requireType('Blockly.BlockSvg');
+goog.requireType('Blockly.Connection');
+goog.requireType('Blockly.ICopyable');
+goog.requireType('Blockly.Workspace');
+
+
+/**
+ * Blockly core version.
+ * This constant is overridden by the build script (npm run build) to the value
+ * of the version in package.json. This is done by the Closure Compiler in the
+ * buildCompressed gulp task.
+ * For local builds, you can pass --define='Blockly.VERSION=X.Y.Z' to the
+ * compiler to override this constant.
+ * @define {string}
+ */
+Blockly.VERSION = 'uncompiled';
+
+/**
+ * The main workspace most recently used.
+ * Set by Blockly.WorkspaceSvg.prototype.markFocused
+ * @type {Blockly.Workspace}
+ */
+Blockly.mainWorkspace = null;
+
+/**
+ * Currently selected block.
+ * @type {?Blockly.ICopyable}
+ */
+Blockly.selected = null;
+
+/**
+ * All of the connections on blocks that are currently being dragged.
+ * @type {!Array<!Blockly.Connection>}
+ * @package
+ */
+Blockly.draggingConnections = [];
+
+/**
+ * Contents of the local clipboard.
+ * @type {Element}
+ * @private
+ */
+Blockly.clipboardXml_ = null;
+
+/**
+ * Source of the local clipboard.
+ * @type {Blockly.WorkspaceSvg}
+ * @private
+ */
+Blockly.clipboardSource_ = null;
+
+/**
+ * Map of types to type counts for the clipboard object and descendants.
+ * @type {Object}
+ * @private
+ */
+Blockly.clipboardTypeCounts_ = null;
+
+/**
+ * Cached value for whether 3D is supported.
+ * @type {?boolean}
+ * @private
+ */
+Blockly.cache3dSupported_ = null;
+
+/**
+ * Container element to render the WidgetDiv, DropDownDiv and Tooltip.
+ * @type {?Element}
+ * @package
+ */
+Blockly.parentContainer = null;
+
+/**
+ * Returns the dimensions of the specified SVG image.
+ * @param {!SVGElement} svg SVG image.
+ * @return {!Blockly.utils.Size} Contains width and height properties.
+ * @deprecated Use workspace.setCachedParentSvgSize. (2021 March 5)
+ */
+Blockly.svgSize = function(svg) {
+  // When removing this function, remove svg.cachedWidth_ and svg.cachedHeight_
+  // from setCachedParentSvgSize.
+  Blockly.utils.deprecation.warn(
+      'Blockly.svgSize',
+      'March 2021',
+      'March 2022',
+      'workspace.getCachedParentSvgSize');
+  svg = /** @type {?} */ (svg);
+  return new Blockly.utils.Size(svg.cachedWidth_, svg.cachedHeight_);
+};
+
+/**
+ * Size the workspace when the contents change.  This also updates
+ * scrollbars accordingly.
+ * @param {!Blockly.WorkspaceSvg} workspace The workspace to resize.
+ */
+Blockly.resizeSvgContents = function(workspace) {
+  workspace.resizeContents();
+};
+
+/**
+ * Size the SVG image to completely fill its container. Call this when the view
+ * actually changes sizes (e.g. on a window resize/device orientation change).
+ * See Blockly.resizeSvgContents to resize the workspace when the contents
+ * change (e.g. when a block is added or removed).
+ * Record the height/width of the SVG image.
+ * @param {!Blockly.WorkspaceSvg} workspace Any workspace in the SVG.
+ */
+Blockly.svgResize = function(workspace) {
+  var mainWorkspace = workspace;
+  while (mainWorkspace.options.parentWorkspace) {
+    mainWorkspace = mainWorkspace.options.parentWorkspace;
+  }
+  var svg = mainWorkspace.getParentSvg();
+  var cachedSize = mainWorkspace.getCachedParentSvgSize();
+  var div = svg.parentNode;
+  if (!div) {
+    // Workspace deleted, or something.
+    return;
+  }
+  var width = div.offsetWidth;
+  var height = div.offsetHeight;
+  if (cachedSize.width != width) {
+    svg.setAttribute('width', width + 'px');
+    mainWorkspace.setCachedParentSvgSize(width, null);
+  }
+  if (cachedSize.height != height) {
+    svg.setAttribute('height', height + 'px');
+    mainWorkspace.setCachedParentSvgSize(null, height);
+  }
+  mainWorkspace.resize();
+};
+
+/**
+ * Handle a key-down on SVG drawing surface. Does nothing if the main workspace
+ * is not visible.
+ * @param {!KeyboardEvent} e Key down event.
+ * @package
+ */
+// TODO (https://github.com/google/blockly/issues/1998) handle cases where there
+// are multiple workspaces and non-main workspaces are able to accept input.
+Blockly.onKeyDown = function(e) {
+  var mainWorkspace = Blockly.mainWorkspace;
+  if (!mainWorkspace) {
+    return;
+  }
+
+  if (Blockly.utils.isTargetInput(e) ||
+      (mainWorkspace.rendered && !mainWorkspace.isVisible())) {
+    // When focused on an HTML text input widget, don't trap any keys.
+    // Ignore keypresses on rendered workspaces that have been explicitly
+    // hidden.
+    return;
+  }
+  Blockly.ShortcutRegistry.registry.onKeyDown(mainWorkspace, e);
+};
+
+/**
+ * Delete the given block.
+ * @param {!Blockly.BlockSvg} selected The block to delete.
+ * @package
+ */
+Blockly.deleteBlock = function(selected) {
+  if (!selected.workspace.isFlyout) {
+    Blockly.Events.setGroup(true);
+    Blockly.hideChaff();
+    if (selected.outputConnection) {
+      // Do not attempt to heal rows (https://github.com/google/blockly/issues/4832)
+      selected.dispose(false, true);
+    } else {
+      selected.dispose(/* heal */ true, true);
+    }
+    Blockly.Events.setGroup(false);
+  }
+};
+
+/**
+ * Copy a block or workspace comment onto the local clipboard.
+ * @param {!Blockly.ICopyable} toCopy Block or Workspace Comment to be copied.
+ * @package
+ */
+Blockly.copy = function(toCopy) {
+  var data = toCopy.toCopyData();
+  if (data) {
+    Blockly.clipboardXml_ = data.xml;
+    Blockly.clipboardSource_ = data.source;
+    Blockly.clipboardTypeCounts_ = data.typeCounts;
+  }
+};
+
+/**
+ * Paste a block or workspace comment on to the main workspace.
+ * @return {boolean} True if the paste was successful, false otherwise.
+ * @package
+ */
+Blockly.paste = function() {
+  if (!Blockly.clipboardXml_) {
+    return false;
+  }
+  // Pasting always pastes to the main workspace, even if the copy
+  // started in a flyout workspace.
+  var workspace = Blockly.clipboardSource_;
+  if (workspace.isFlyout) {
+    workspace = workspace.targetWorkspace;
+  }
+  if (Blockly.clipboardTypeCounts_ &&
+      workspace.isCapacityAvailable(Blockly.clipboardTypeCounts_)) {
+    Blockly.Events.setGroup(true);
+    workspace.paste(Blockly.clipboardXml_);
+    Blockly.Events.setGroup(false);
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Duplicate this block and its children, or a workspace comment.
+ * @param {!Blockly.ICopyable} toDuplicate Block or Workspace Comment to be
+ *     copied.
+ * @package
+ */
+Blockly.duplicate = function(toDuplicate) {
+  // Save the clipboard.
+  var clipboardXml = Blockly.clipboardXml_;
+  var clipboardSource = Blockly.clipboardSource_;
+
+  // Create a duplicate via a copy/paste operation.
+  Blockly.copy(toDuplicate);
+  toDuplicate.workspace.paste(Blockly.clipboardXml_);
+
+  // Restore the clipboard.
+  Blockly.clipboardXml_ = clipboardXml;
+  Blockly.clipboardSource_ = clipboardSource;
+};
+
+/**
+ * Cancel the native context menu, unless the focus is on an HTML input widget.
+ * @param {!Event} e Mouse down event.
+ * @private
+ */
+Blockly.onContextMenu_ = function(e) {
+  if (!Blockly.utils.isTargetInput(e)) {
+    // When focused on an HTML text input widget, don't cancel the context menu.
+    e.preventDefault();
+  }
+};
+
+/**
+ * Close tooltips, context menus, dropdown selections, etc.
+ * @param {boolean=} opt_onlyClosePopups Whether only popups should be closed.
+ */
+Blockly.hideChaff = function(opt_onlyClosePopups) {
+  Blockly.Tooltip.hide();
+  Blockly.WidgetDiv.hide();
+  Blockly.DropDownDiv.hideWithoutAnimation();
+
+  var onlyClosePopups = !!opt_onlyClosePopups;
+  var workspace = Blockly.getMainWorkspace();
+  var autoHideables = workspace.getComponentManager().getComponents(
+      Blockly.ComponentManager.Capability.AUTOHIDEABLE, true);
+  autoHideables.forEach(function(autoHideable) {
+    autoHideable.autoHide(onlyClosePopups);
+  });
+};
+
+/**
+ * Returns the main workspace.  Returns the last used main workspace (based on
+ * focus).  Try not to use this function, particularly if there are multiple
+ * Blockly instances on a page.
+ * @return {!Blockly.Workspace} The main workspace.
+ */
+Blockly.getMainWorkspace = function() {
+  return /** @type {!Blockly.Workspace} */ (Blockly.mainWorkspace);
+};
+
+/**
+ * Wrapper to window.alert() that app developers may override to
+ * provide alternatives to the modal browser window.
+ * @param {string} message The message to display to the user.
+ * @param {function()=} opt_callback The callback when the alert is dismissed.
+ */
+Blockly.alert = function(message, opt_callback) {
+  alert(message);
+  if (opt_callback) {
+    opt_callback();
+  }
+};
+
+/**
+ * Wrapper to window.confirm() that app developers may override to
+ * provide alternatives to the modal browser window.
+ * @param {string} message The message to display to the user.
+ * @param {!function(boolean)} callback The callback for handling user response.
+ */
+Blockly.confirm = function(message, callback) {
+  callback(confirm(message));
+};
+
+/**
+ * Wrapper to window.prompt() that app developers may override to provide
+ * alternatives to the modal browser window. Built-in browser prompts are
+ * often used for better text input experience on mobile device. We strongly
+ * recommend testing mobile when overriding this.
+ * @param {string} message The message to display to the user.
+ * @param {string} defaultValue The value to initialize the prompt with.
+ * @param {!function(?string)} callback The callback for handling user response.
+ */
+Blockly.prompt = function(message, defaultValue, callback) {
+  callback(prompt(message, defaultValue));
+};
+
+/**
+ * Helper function for defining a block from JSON.  The resulting function has
+ * the correct value of jsonDef at the point in code where jsonInit is called.
+ * @param {!Object} jsonDef The JSON definition of a block.
+ * @return {function()} A function that calls jsonInit with the correct value
+ *     of jsonDef.
+ * @private
+ */
+Blockly.jsonInitFactory_ = function(jsonDef) {
+  return function() {
+    this.jsonInit(jsonDef);
+  };
+};
+
+/**
+ * Define blocks from an array of JSON block definitions, as might be generated
+ * by the Blockly Developer Tools.
+ * @param {!Array<!Object>} jsonArray An array of JSON block definitions.
+ */
+Blockly.defineBlocksWithJsonArray = function(jsonArray) {
+  for (var i = 0; i < jsonArray.length; i++) {
+    var elem = jsonArray[i];
+    if (!elem) {
+      console.warn(
+          'Block definition #' + i + ' in JSON array is ' + elem + '. ' +
+          'Skipping.');
+    } else {
+      var typename = elem.type;
+      if (typename == null || typename === '') {
+        console.warn(
+            'Block definition #' + i +
+            ' in JSON array is missing a type attribute. Skipping.');
+      } else {
+        if (Blockly.Blocks[typename]) {
+          console.warn(
+              'Block definition #' + i + ' in JSON array' +
+              ' overwrites prior definition of "' + typename + '".');
+        }
+        Blockly.Blocks[typename] = {
+          init: Blockly.jsonInitFactory_(elem)
+        };
+      }
+    }
+  }
+};
+
+/**
+ * Is the given string a number (includes negative and decimals).
+ * @param {string} str Input string.
+ * @return {boolean} True if number, false otherwise.
+ */
+Blockly.isNumber = function(str) {
+  return /^\s*-?\d+(\.\d+)?\s*$/.test(str);
+};
+
+/**
+ * Convert a hue (HSV model) into an RGB hex triplet.
+ * @param {number} hue Hue on a colour wheel (0-360).
+ * @return {string} RGB code, e.g. '#5ba65b'.
+ */
+Blockly.hueToHex = function(hue) {
+  return Blockly.utils.colour.hsvToHex(hue, Blockly.HSV_SATURATION,
+      Blockly.HSV_VALUE * 255);
+};
+
+/**
+ * Checks old colour constants are not overwritten by the host application.
+ * If a constant is overwritten, it prints a console warning directing the
+ * developer to use the equivalent Msg constant.
+ * @package
+ */
+Blockly.checkBlockColourConstants = function() {
+  Blockly.checkBlockColourConstant_(
+      'LOGIC_HUE', ['Blocks', 'logic', 'HUE'], undefined);
+  Blockly.checkBlockColourConstant_(
+      'LOGIC_HUE', ['Constants', 'Logic', 'HUE'], 210);
+  Blockly.checkBlockColourConstant_(
+      'LOOPS_HUE', ['Blocks', 'loops', 'HUE'], undefined);
+  Blockly.checkBlockColourConstant_(
+      'LOOPS_HUE', ['Constants', 'Loops', 'HUE'], 120);
+  Blockly.checkBlockColourConstant_(
+      'MATH_HUE', ['Blocks', 'math', 'HUE'], undefined);
+  Blockly.checkBlockColourConstant_(
+      'MATH_HUE', ['Constants', 'Math', 'HUE'], 230);
+  Blockly.checkBlockColourConstant_(
+      'TEXTS_HUE', ['Blocks', 'texts', 'HUE'], undefined);
+  Blockly.checkBlockColourConstant_(
+      'TEXTS_HUE', ['Constants', 'Text', 'HUE'], 160);
+  Blockly.checkBlockColourConstant_(
+      'LISTS_HUE', ['Blocks', 'lists', 'HUE'], undefined);
+  Blockly.checkBlockColourConstant_(
+      'LISTS_HUE', ['Constants', 'Lists', 'HUE'], 260);
+  Blockly.checkBlockColourConstant_(
+      'COLOUR_HUE', ['Blocks', 'colour', 'HUE'], undefined);
+  Blockly.checkBlockColourConstant_(
+      'COLOUR_HUE', ['Constants', 'Colour', 'HUE'], 20);
+  Blockly.checkBlockColourConstant_(
+      'VARIABLES_HUE', ['Blocks', 'variables', 'HUE'], undefined);
+  Blockly.checkBlockColourConstant_(
+      'VARIABLES_HUE', ['Constants', 'Variables', 'HUE'], 330);
+  // Blockly.Blocks.variables_dynamic.HUE never existed.
+  Blockly.checkBlockColourConstant_(
+      'VARIABLES_DYNAMIC_HUE', ['Constants', 'VariablesDynamic', 'HUE'], 310);
+  Blockly.checkBlockColourConstant_(
+      'PROCEDURES_HUE', ['Blocks', 'procedures', 'HUE'], undefined);
+  // Blockly.Constants.Procedures.HUE never existed.
+};
+
+/**
+ * Checks for a constant in the Blockly namespace, verifying it is undefined or
+ * has the old/original value. Prints a warning if this is not true.
+ * @param {string} msgName The Msg constant identifier.
+ * @param {!Array<string>} blocklyNamePath The name parts of the tested
+ *     constant.
+ * @param {number|undefined} expectedValue The expected value of the constant.
+ * @private
+ */
+Blockly.checkBlockColourConstant_ = function(
+    msgName, blocklyNamePath, expectedValue) {
+  var namePath = 'Blockly';
+  var value = Blockly;
+  for (var i = 0; i < blocklyNamePath.length; ++i) {
+    namePath += '.' + blocklyNamePath[i];
+    if (value) {
+      value = value[blocklyNamePath[i]];
+    }
+  }
+
+  if (value && value !== expectedValue) {
+    var warningPattern = (expectedValue === undefined) ?
+        '%1 has been removed. Use Blockly.Msg["%2"].' :
+        '%1 is deprecated and unused. Override Blockly.Msg["%2"].';
+    var warning = warningPattern.replace('%1', namePath).replace('%2', msgName);
+    console.warn(warning);
+  }
+};
+
+/**
+ * Set the parent container.  This is the container element that the WidgetDiv,
+ * DropDownDiv, and Tooltip are rendered into the first time `Blockly.inject`
+ * is called.
+ * This method is a NOP if called after the first ``Blockly.inject``.
+ * @param {!Element} container The container element.
+ */
+Blockly.setParentContainer = function(container) {
+  Blockly.parentContainer = container;
+};
+
+/** Aliases. */
+
+/**
+ * @see Blockly.browserEvents.bind
+ */
+Blockly.bindEvent_ = Blockly.browserEvents.bind;
+
+/**
+ * @see Blockly.browserEvents.unbind
+ */
+Blockly.unbindEvent_ = Blockly.browserEvents.unbind;
+
+/**
+ * @see Blockly.browserEvents.conditionalBind
+ */
+Blockly.bindEventWithChecks_ = Blockly.browserEvents.conditionalBind;
+
+/**
+ * @see Blockly.constants.ALIGN.LEFT
+ */
+Blockly.ALIGN_LEFT = Blockly.constants.ALIGN.LEFT;
+
+/**
+ * @see Blockly.constants.ALIGN.CENTRE
+ */
+Blockly.ALIGN_CENTRE = Blockly.constants.ALIGN.CENTRE;
+
+/**
+ * @see Blockly.constants.ALIGN.RIGHT
+ */
+Blockly.ALIGN_RIGHT = Blockly.constants.ALIGN.RIGHT;
+
+
+/**
+ * Aliases for constants used for connection and input types.
+ */
+
+/**
+ * @see Blockly.connectionTypes.INPUT_VALUE
+ */
+Blockly.INPUT_VALUE = Blockly.connectionTypes.INPUT_VALUE;
+
+/**
+ * @see Blockly.connectionTypes.OUTPUT_VALUE
+ */
+Blockly.OUTPUT_VALUE = Blockly.connectionTypes.OUTPUT_VALUE;
+
+/**
+ * @see Blockly.connectionTypes.NEXT_STATEMENT
+ */
+Blockly.NEXT_STATEMENT = Blockly.connectionTypes.NEXT_STATEMENT;
+
+/**
+ * @see Blockly.connectionTypes.PREVIOUS_STATEMENT
+ */
+Blockly.PREVIOUS_STATEMENT = Blockly.connectionTypes.PREVIOUS_STATEMENT;
+
+/**
+ * @see Blockly.inputTypes.DUMMY_INPUT
+ */
+Blockly.DUMMY_INPUT = Blockly.inputTypes.DUMMY;
+
+/**
+ * Aliases for toolbox positions.
+ */
+
+/**
+ * @see Blockly.utils.toolbox.Position.TOP
+ */
+Blockly.TOOLBOX_AT_TOP = Blockly.utils.toolbox.Position.TOP;
+
+/**
+ * @see Blockly.utils.toolbox.Position.BOTTOM
+ */
+Blockly.TOOLBOX_AT_BOTTOM = Blockly.utils.toolbox.Position.BOTTOM;
+
+/**
+ * @see Blockly.utils.toolbox.Position.LEFT
+ */
+Blockly.TOOLBOX_AT_LEFT = Blockly.utils.toolbox.Position.LEFT;
+
+/**
+ * @see Blockly.utils.toolbox.Position.RIGHT
+ */
+Blockly.TOOLBOX_AT_RIGHT = Blockly.utils.toolbox.Position.RIGHT;

blockly/core/blocks.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2013 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview A mapping of block type names to block prototype objects.
+ * @author spertus@google.com (Ellen Spertus)
+ */
+'use strict';
+
+/**
+ * A mapping of block type names to block prototype objects.
+ * @name Blockly.Blocks
+ */
+goog.provide('Blockly.Blocks');
+
+/**
+ * A mapping of block type names to block prototype objects.
+ * @type {!Object<string,Object>}
+ */
+Blockly.Blocks = Object.create(null);

blockly/core/browser_events.js

@@ -0,0 +1,175 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Browser event handling.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.browserEvents');
+
+goog.require('Blockly.Touch');
+goog.require('Blockly.utils.global');
+
+
+/**
+ * Blockly opaque event data used to unbind events when using
+ * `Blockly.browserEvents.bind` and
+ * `Blockly.browserEvents.conditionalBind`.
+ * @typedef {!Array<!Array>}
+ */
+Blockly.browserEvents.Data;
+
+/**
+ * Bind an event handler that can be ignored if it is not part of the active
+ * touch stream.
+ * Use this for events that either start or continue a multi-part gesture (e.g.
+ * mousedown or mousemove, which may be part of a drag or click).
+ * @param {!EventTarget} node Node upon which to listen.
+ * @param {string} name Event name to listen to (e.g. 'mousedown').
+ * @param {?Object} thisObject The value of 'this' in the function.
+ * @param {!Function} func Function to call when event is triggered.
+ * @param {boolean=} opt_noCaptureIdentifier True if triggering on this event
+ *     should not block execution of other event handlers on this touch or
+ *     other simultaneous touches.  False by default.
+ * @param {boolean=} opt_noPreventDefault True if triggering on this event
+ *     should prevent the default handler.  False by default.  If
+ *     opt_noPreventDefault is provided, opt_noCaptureIdentifier must also be
+ *     provided.
+ * @return {!Blockly.browserEvents.Data} Opaque data that can be passed to
+ *     unbindEvent_.
+ * @public
+ */
+Blockly.browserEvents.conditionalBind = function(
+    node, name, thisObject, func, opt_noCaptureIdentifier,
+    opt_noPreventDefault) {
+  var handled = false;
+  var wrapFunc = function(e) {
+    var captureIdentifier = !opt_noCaptureIdentifier;
+    // Handle each touch point separately.  If the event was a mouse event, this
+    // will hand back an array with one element, which we're fine handling.
+    var events = Blockly.Touch.splitEventByTouches(e);
+    for (var i = 0, event; (event = events[i]); i++) {
+      if (captureIdentifier && !Blockly.Touch.shouldHandleEvent(event)) {
+        continue;
+      }
+      Blockly.Touch.setClientFromTouch(event);
+      if (thisObject) {
+        func.call(thisObject, event);
+      } else {
+        func(event);
+      }
+      handled = true;
+    }
+  };
+
+  var bindData = [];
+  if (Blockly.utils.global['PointerEvent'] &&
+      (name in Blockly.Touch.TOUCH_MAP)) {
+    for (var i = 0, type; (type = Blockly.Touch.TOUCH_MAP[name][i]); i++) {
+      node.addEventListener(type, wrapFunc, false);
+      bindData.push([node, type, wrapFunc]);
+    }
+  } else {
+    node.addEventListener(name, wrapFunc, false);
+    bindData.push([node, name, wrapFunc]);
+
+    // Add equivalent touch event.
+    if (name in Blockly.Touch.TOUCH_MAP) {
+      var touchWrapFunc = function(e) {
+        wrapFunc(e);
+        // Calling preventDefault stops the browser from scrolling/zooming the
+        // page.
+        var preventDef = !opt_noPreventDefault;
+        if (handled && preventDef) {
+          e.preventDefault();
+        }
+      };
+      for (var i = 0, type; (type = Blockly.Touch.TOUCH_MAP[name][i]); i++) {
+        node.addEventListener(type, touchWrapFunc, false);
+        bindData.push([node, type, touchWrapFunc]);
+      }
+    }
+  }
+  return bindData;
+};
+
+
+/**
+ * Bind an event handler that should be called regardless of whether it is part
+ * of the active touch stream.
+ * Use this for events that are not part of a multi-part gesture (e.g.
+ * mouseover for tooltips).
+ * @param {!EventTarget} node Node upon which to listen.
+ * @param {string} name Event name to listen to (e.g. 'mousedown').
+ * @param {?Object} thisObject The value of 'this' in the function.
+ * @param {!Function} func Function to call when event is triggered.
+ * @return {!Blockly.browserEvents.Data} Opaque data that can be passed to
+ *     unbindEvent_.
+ * @public
+ */
+Blockly.browserEvents.bind = function(node, name, thisObject, func) {
+  var wrapFunc = function(e) {
+    if (thisObject) {
+      func.call(thisObject, e);
+    } else {
+      func(e);
+    }
+  };
+
+  var bindData = [];
+  if (Blockly.utils.global['PointerEvent'] &&
+      (name in Blockly.Touch.TOUCH_MAP)) {
+    for (var i = 0, type; (type = Blockly.Touch.TOUCH_MAP[name][i]); i++) {
+      node.addEventListener(type, wrapFunc, false);
+      bindData.push([node, type, wrapFunc]);
+    }
+  } else {
+    node.addEventListener(name, wrapFunc, false);
+    bindData.push([node, name, wrapFunc]);
+
+    // Add equivalent touch event.
+    if (name in Blockly.Touch.TOUCH_MAP) {
+      var touchWrapFunc = function(e) {
+        // Punt on multitouch events.
+        if (e.changedTouches && e.changedTouches.length == 1) {
+          // Map the touch event's properties to the event.
+          var touchPoint = e.changedTouches[0];
+          e.clientX = touchPoint.clientX;
+          e.clientY = touchPoint.clientY;
+        }
+        wrapFunc(e);
+
+        // Stop the browser from scrolling/zooming the page.
+        e.preventDefault();
+      };
+      for (var i = 0, type; (type = Blockly.Touch.TOUCH_MAP[name][i]); i++) {
+        node.addEventListener(type, touchWrapFunc, false);
+        bindData.push([node, type, touchWrapFunc]);
+      }
+    }
+  }
+  return bindData;
+};
+
+/**
+ * Unbind one or more events event from a function call.
+ * @param {!Blockly.browserEvents.Data} bindData Opaque data from bindEvent_.
+ *     This list is emptied during the course of calling this function.
+ * @return {!Function} The function call.
+ * @public
+ */
+Blockly.browserEvents.unbind = function(bindData) {
+  while (bindData.length) {
+    var bindDatum = bindData.pop();
+    var node = bindDatum[0];
+    var name = bindDatum[1];
+    var func = bindDatum[2];
+    node.removeEventListener(name, func, false);
+  }
+  return func;
+};

blockly/core/bubble.js

@@ -0,0 +1,936 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Object representing a UI bubble.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Bubble');
+
+goog.require('Blockly.browserEvents');
+goog.require('Blockly.IBubble');
+goog.require('Blockly.Scrollbar');
+goog.require('Blockly.Touch');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.Coordinate');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.math');
+goog.require('Blockly.utils.Size');
+goog.require('Blockly.utils.Svg');
+goog.require('Blockly.utils.userAgent');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Workspace');
+
+goog.requireType('Blockly.BlockDragSurfaceSvg');
+goog.requireType('Blockly.BlockSvg');
+goog.requireType('Blockly.MetricsManager');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Class for UI bubble.
+ * @param {!Blockly.WorkspaceSvg} workspace The workspace on which to draw the
+ *     bubble.
+ * @param {!Element} content SVG content for the bubble.
+ * @param {!Element} shape SVG element to avoid eclipsing.
+ * @param {!Blockly.utils.Coordinate} anchorXY Absolute position of bubble's
+ *     anchor point.
+ * @param {?number} bubbleWidth Width of bubble, or null if not resizable.
+ * @param {?number} bubbleHeight Height of bubble, or null if not resizable.
+ * @implements {Blockly.IBubble}
+ * @constructor
+ */
+Blockly.Bubble = function(
+    workspace, content, shape, anchorXY, bubbleWidth, bubbleHeight) {
+  this.workspace_ = workspace;
+  this.content_ = content;
+  this.shape_ = shape;
+
+  /**
+   * Method to call on resize of bubble.
+   * @type {?function()}
+   * @private
+   */
+  this.resizeCallback_ = null;
+
+  /**
+   * Method to call on move of bubble.
+   * @type {?function()}
+   * @private
+   */
+  this.moveCallback_ = null;
+
+  /**
+   * Mouse down on bubbleBack_ event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onMouseDownBubbleWrapper_ = null;
+
+  /**
+   * Mouse down on resizeGroup_ event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onMouseDownResizeWrapper_ = null;
+
+  /**
+   * Describes whether this bubble has been disposed of (nodes and event
+   * listeners removed from the page) or not.
+   * @type {boolean}
+   * @package
+   */
+  this.disposed = false;
+
+  var angle = Blockly.Bubble.ARROW_ANGLE;
+  if (this.workspace_.RTL) {
+    angle = -angle;
+  }
+  this.arrow_radians_ = Blockly.utils.math.toRadians(angle);
+
+  var canvas = workspace.getBubbleCanvas();
+  canvas.appendChild(this.createDom_(content, !!(bubbleWidth && bubbleHeight)));
+
+  this.setAnchorLocation(anchorXY);
+  if (!bubbleWidth || !bubbleHeight) {
+    var bBox = /** @type {SVGLocatable} */ (this.content_).getBBox();
+    bubbleWidth = bBox.width + 2 * Blockly.Bubble.BORDER_WIDTH;
+    bubbleHeight = bBox.height + 2 * Blockly.Bubble.BORDER_WIDTH;
+  }
+  this.setBubbleSize(bubbleWidth, bubbleHeight);
+
+  // Render the bubble.
+  this.positionBubble_();
+  this.renderArrow_();
+  this.rendered_ = true;
+};
+
+/**
+ * Width of the border around the bubble.
+ */
+Blockly.Bubble.BORDER_WIDTH = 6;
+
+/**
+ * Determines the thickness of the base of the arrow in relation to the size
+ * of the bubble.  Higher numbers result in thinner arrows.
+ */
+Blockly.Bubble.ARROW_THICKNESS = 5;
+
+/**
+ * The number of degrees that the arrow bends counter-clockwise.
+ */
+Blockly.Bubble.ARROW_ANGLE = 20;
+
+/**
+ * The sharpness of the arrow's bend.  Higher numbers result in smoother arrows.
+ */
+Blockly.Bubble.ARROW_BEND = 4;
+
+/**
+ * Distance between arrow point and anchor point.
+ */
+Blockly.Bubble.ANCHOR_RADIUS = 8;
+
+/**
+ * Mouse up event data.
+ * @type {?Blockly.browserEvents.Data}
+ * @private
+ */
+Blockly.Bubble.onMouseUpWrapper_ = null;
+
+/**
+ * Mouse move event data.
+ * @type {?Blockly.browserEvents.Data}
+ * @private
+ */
+Blockly.Bubble.onMouseMoveWrapper_ = null;
+
+/**
+ * Stop binding to the global mouseup and mousemove events.
+ * @private
+ */
+Blockly.Bubble.unbindDragEvents_ = function() {
+  if (Blockly.Bubble.onMouseUpWrapper_) {
+    Blockly.browserEvents.unbind(Blockly.Bubble.onMouseUpWrapper_);
+    Blockly.Bubble.onMouseUpWrapper_ = null;
+  }
+  if (Blockly.Bubble.onMouseMoveWrapper_) {
+    Blockly.browserEvents.unbind(Blockly.Bubble.onMouseMoveWrapper_);
+    Blockly.Bubble.onMouseMoveWrapper_ = null;
+  }
+};
+
+/**
+ * Handle a mouse-up event while dragging a bubble's border or resize handle.
+ * @param {!Event} _e Mouse up event.
+ * @private
+ */
+Blockly.Bubble.bubbleMouseUp_ = function(_e) {
+  Blockly.Touch.clearTouchIdentifier();
+  Blockly.Bubble.unbindDragEvents_();
+};
+
+/**
+ * Flag to stop incremental rendering during construction.
+ * @private
+ */
+Blockly.Bubble.prototype.rendered_ = false;
+
+/**
+ * Absolute coordinate of anchor point, in workspace coordinates.
+ * @type {Blockly.utils.Coordinate}
+ * @private
+ */
+Blockly.Bubble.prototype.anchorXY_ = null;
+
+/**
+ * Relative X coordinate of bubble with respect to the anchor's centre,
+ * in workspace units.
+ * In RTL mode the initial value is negated.
+ * @private
+ */
+Blockly.Bubble.prototype.relativeLeft_ = 0;
+
+/**
+ * Relative Y coordinate of bubble with respect to the anchor's centre, in
+ * workspace units.
+ * @private
+ */
+Blockly.Bubble.prototype.relativeTop_ = 0;
+
+/**
+ * Width of bubble, in workspace units.
+ * @private
+ */
+Blockly.Bubble.prototype.width_ = 0;
+
+/**
+ * Height of bubble, in workspace units.
+ * @private
+ */
+Blockly.Bubble.prototype.height_ = 0;
+
+/**
+ * Automatically position and reposition the bubble.
+ * @private
+ */
+Blockly.Bubble.prototype.autoLayout_ = true;
+
+/**
+ * Create the bubble's DOM.
+ * @param {!Element} content SVG content for the bubble.
+ * @param {boolean} hasResize Add diagonal resize gripper if true.
+ * @return {!SVGElement} The bubble's SVG group.
+ * @private
+ */
+Blockly.Bubble.prototype.createDom_ = function(content, hasResize) {
+  /* Create the bubble.  Here's the markup that will be generated:
+  <g>
+    <g filter="url(#blocklyEmbossFilter837493)">
+      <path d="... Z" />
+      <rect class="blocklyDraggable" rx="8" ry="8" width="180" height="180"/>
+    </g>
+    <g transform="translate(165, 165)" class="blocklyResizeSE">
+      <polygon points="0,15 15,15 15,0"/>
+      <line class="blocklyResizeLine" x1="5" y1="14" x2="14" y2="5"/>
+      <line class="blocklyResizeLine" x1="10" y1="14" x2="14" y2="10"/>
+    </g>
+    [...content goes here...]
+  </g>
+  */
+  this.bubbleGroup_ =
+      Blockly.utils.dom.createSvgElement(Blockly.utils.Svg.G, {}, null);
+  var filter = {
+    'filter': 'url(#' +
+        this.workspace_.getRenderer().getConstants().embossFilterId + ')'
+  };
+  if (Blockly.utils.userAgent.JAVA_FX) {
+    // Multiple reports that JavaFX can't handle filters.
+    // https://github.com/google/blockly/issues/99
+    filter = {};
+  }
+  var bubbleEmboss = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.G, filter, this.bubbleGroup_);
+  this.bubbleArrow_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.PATH, {}, bubbleEmboss);
+  this.bubbleBack_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.RECT, {
+        'class': 'blocklyDraggable',
+        'x': 0,
+        'y': 0,
+        'rx': Blockly.Bubble.BORDER_WIDTH,
+        'ry': Blockly.Bubble.BORDER_WIDTH
+      },
+      bubbleEmboss);
+  if (hasResize) {
+    this.resizeGroup_ = Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.G,
+        {'class': this.workspace_.RTL ? 'blocklyResizeSW' : 'blocklyResizeSE'},
+        this.bubbleGroup_);
+    var resizeSize = 2 * Blockly.Bubble.BORDER_WIDTH;
+    Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.POLYGON,
+        {'points': '0,x x,x x,0'.replace(/x/g, resizeSize.toString())},
+        this.resizeGroup_);
+    Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.LINE, {
+          'class': 'blocklyResizeLine',
+          'x1': resizeSize / 3,
+          'y1': resizeSize - 1,
+          'x2': resizeSize - 1,
+          'y2': resizeSize / 3
+        },
+        this.resizeGroup_);
+    Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.LINE, {
+          'class': 'blocklyResizeLine',
+          'x1': resizeSize * 2 / 3,
+          'y1': resizeSize - 1,
+          'x2': resizeSize - 1,
+          'y2': resizeSize * 2 / 3
+        },
+        this.resizeGroup_);
+  } else {
+    this.resizeGroup_ = null;
+  }
+
+  if (!this.workspace_.options.readOnly) {
+    this.onMouseDownBubbleWrapper_ = Blockly.browserEvents.conditionalBind(
+        this.bubbleBack_, 'mousedown', this, this.bubbleMouseDown_);
+    if (this.resizeGroup_) {
+      this.onMouseDownResizeWrapper_ = Blockly.browserEvents.conditionalBind(
+          this.resizeGroup_, 'mousedown', this, this.resizeMouseDown_);
+    }
+  }
+  this.bubbleGroup_.appendChild(content);
+  return this.bubbleGroup_;
+};
+
+/**
+ * Return the root node of the bubble's SVG group.
+ * @return {!SVGElement} The root SVG node of the bubble's group.
+ */
+Blockly.Bubble.prototype.getSvgRoot = function() {
+  return this.bubbleGroup_;
+};
+
+/**
+ * Expose the block's ID on the bubble's top-level SVG group.
+ * @param {string} id ID of block.
+ */
+Blockly.Bubble.prototype.setSvgId = function(id) {
+  if (this.bubbleGroup_.dataset) {
+    this.bubbleGroup_.dataset['blockId'] = id;
+  }
+};
+
+/**
+ * Handle a mouse-down on bubble's border.
+ * @param {!Event} e Mouse down event.
+ * @private
+ */
+Blockly.Bubble.prototype.bubbleMouseDown_ = function(e) {
+  var gesture = this.workspace_.getGesture(e);
+  if (gesture) {
+    gesture.handleBubbleStart(e, this);
+  }
+};
+
+/**
+ * Show the context menu for this bubble.
+ * @param {!Event} _e Mouse event.
+ * @package
+ */
+Blockly.Bubble.prototype.showContextMenu = function(_e) {
+  // NOP on bubbles, but used by the bubble dragger to pass events to
+  // workspace comments.
+};
+
+/**
+ * Get whether this bubble is deletable or not.
+ * @return {boolean} True if deletable.
+ * @package
+ */
+Blockly.Bubble.prototype.isDeletable = function() {
+  return false;
+};
+
+/**
+ * Update the style of this bubble when it is dragged over a delete area.
+ * @param {boolean} _enable True if the bubble is about to be deleted, false
+ *     otherwise.
+ */
+Blockly.Bubble.prototype.setDeleteStyle = function(_enable) {
+  // NOP if bubble is not deletable.
+};
+
+/**
+ * Handle a mouse-down on bubble's resize corner.
+ * @param {!Event} e Mouse down event.
+ * @private
+ */
+Blockly.Bubble.prototype.resizeMouseDown_ = function(e) {
+  this.promote();
+  Blockly.Bubble.unbindDragEvents_();
+  if (Blockly.utils.isRightButton(e)) {
+    // No right-click.
+    e.stopPropagation();
+    return;
+  }
+  // Left-click (or middle click)
+  this.workspace_.startDrag(
+      e,
+      new Blockly.utils.Coordinate(
+          this.workspace_.RTL ? -this.width_ : this.width_, this.height_));
+
+  Blockly.Bubble.onMouseUpWrapper_ = Blockly.browserEvents.conditionalBind(
+      document, 'mouseup', this, Blockly.Bubble.bubbleMouseUp_);
+  Blockly.Bubble.onMouseMoveWrapper_ = Blockly.browserEvents.conditionalBind(
+      document, 'mousemove', this, this.resizeMouseMove_);
+  Blockly.hideChaff();
+  // This event has been handled.  No need to bubble up to the document.
+  e.stopPropagation();
+};
+
+/**
+ * Resize this bubble to follow the mouse.
+ * @param {!Event} e Mouse move event.
+ * @private
+ */
+Blockly.Bubble.prototype.resizeMouseMove_ = function(e) {
+  this.autoLayout_ = false;
+  var newXY = this.workspace_.moveDrag(e);
+  this.setBubbleSize(this.workspace_.RTL ? -newXY.x : newXY.x, newXY.y);
+  if (this.workspace_.RTL) {
+    // RTL requires the bubble to move its left edge.
+    this.positionBubble_();
+  }
+};
+
+/**
+ * Register a function as a callback event for when the bubble is resized.
+ * @param {!Function} callback The function to call on resize.
+ */
+Blockly.Bubble.prototype.registerResizeEvent = function(callback) {
+  this.resizeCallback_ = callback;
+};
+
+/**
+ * Register a function as a callback event for when the bubble is moved.
+ * @param {!Function} callback The function to call on move.
+ */
+Blockly.Bubble.prototype.registerMoveEvent = function(callback) {
+  this.moveCallback_ = callback;
+};
+
+/**
+ * Move this bubble to the top of the stack.
+ * @return {boolean} Whether or not the bubble has been moved.
+ * @package
+ */
+Blockly.Bubble.prototype.promote = function() {
+  var svgGroup = this.bubbleGroup_.parentNode;
+  if (svgGroup.lastChild !== this.bubbleGroup_) {
+    svgGroup.appendChild(this.bubbleGroup_);
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Notification that the anchor has moved.
+ * Update the arrow and bubble accordingly.
+ * @param {!Blockly.utils.Coordinate} xy Absolute location.
+ */
+Blockly.Bubble.prototype.setAnchorLocation = function(xy) {
+  this.anchorXY_ = xy;
+  if (this.rendered_) {
+    this.positionBubble_();
+  }
+};
+
+/**
+ * Position the bubble so that it does not fall off-screen.
+ * @private
+ */
+Blockly.Bubble.prototype.layoutBubble_ = function() {
+  // Get the metrics in workspace units.
+  var viewMetrics = this.workspace_.getMetricsManager().getViewMetrics(true);
+
+  var optimalLeft = this.getOptimalRelativeLeft_(viewMetrics);
+  var optimalTop = this.getOptimalRelativeTop_(viewMetrics);
+  var bbox = this.shape_.getBBox();
+
+  var topPosition = {
+    x: optimalLeft,
+    y: -this.height_ -
+        this.workspace_.getRenderer().getConstants().MIN_BLOCK_HEIGHT
+  };
+  var startPosition = {x: -this.width_ - 30, y: optimalTop};
+  var endPosition = {x: bbox.width, y: optimalTop};
+  var bottomPosition = {x: optimalLeft, y: bbox.height};
+
+  var closerPosition = bbox.width < bbox.height ? endPosition : bottomPosition;
+  var fartherPosition = bbox.width < bbox.height ? bottomPosition : endPosition;
+
+  var topPositionOverlap = this.getOverlap_(topPosition, viewMetrics);
+  var startPositionOverlap = this.getOverlap_(startPosition, viewMetrics);
+  var closerPositionOverlap = this.getOverlap_(closerPosition, viewMetrics);
+  var fartherPositionOverlap = this.getOverlap_(fartherPosition, viewMetrics);
+
+  // Set the position to whichever position shows the most of the bubble,
+  // with tiebreaks going in the order: top > start > close > far.
+  var mostOverlap = Math.max(
+      topPositionOverlap, startPositionOverlap, closerPositionOverlap,
+      fartherPositionOverlap);
+  if (topPositionOverlap == mostOverlap) {
+    this.relativeLeft_ = topPosition.x;
+    this.relativeTop_ = topPosition.y;
+    return;
+  }
+  if (startPositionOverlap == mostOverlap) {
+    this.relativeLeft_ = startPosition.x;
+    this.relativeTop_ = startPosition.y;
+    return;
+  }
+  if (closerPositionOverlap == mostOverlap) {
+    this.relativeLeft_ = closerPosition.x;
+    this.relativeTop_ = closerPosition.y;
+    return;
+  }
+  // TODO: I believe relativeLeft_ should actually be called relativeStart_
+  //  and then the math should be fixed to reflect this. (hopefully it'll
+  //  make it look simpler)
+  this.relativeLeft_ = fartherPosition.x;
+  this.relativeTop_ = fartherPosition.y;
+};
+
+/**
+ * Calculate the what percentage of the bubble overlaps with the visible
+ * workspace (what percentage of the bubble is visible).
+ * @param {!{x: number, y: number}} relativeMin The position of the top-left
+ *     corner of the bubble relative to the anchor point.
+ * @param {!Blockly.MetricsManager.ContainerRegion} viewMetrics The view metrics
+ *     of the workspace the bubble will appear in.
+ * @return {number} The percentage of the bubble that is visible.
+ * @private
+ */
+Blockly.Bubble.prototype.getOverlap_ = function(relativeMin, viewMetrics) {
+  // The position of the top-left corner of the bubble in workspace units.
+  var bubbleMin = {
+    x: this.workspace_.RTL ? (this.anchorXY_.x - relativeMin.x - this.width_) :
+                             (relativeMin.x + this.anchorXY_.x),
+    y: relativeMin.y + this.anchorXY_.y
+  };
+  // The position of the bottom-right corner of the bubble in workspace units.
+  var bubbleMax = {x: bubbleMin.x + this.width_, y: bubbleMin.y + this.height_};
+
+  // We could adjust these values to account for the scrollbars, but the
+  // bubbles should have been adjusted to not collide with them anyway, so
+  // giving the workspace a slightly larger "bounding box" shouldn't affect the
+  // calculation.
+
+  // The position of the top-left corner of the workspace.
+  var workspaceMin = {x: viewMetrics.left, y: viewMetrics.top};
+  // The position of the bottom-right corner of the workspace.
+  var workspaceMax = {
+    x: viewMetrics.left + viewMetrics.width,
+    y: viewMetrics.top + viewMetrics.height
+  };
+
+  var overlapWidth = Math.min(bubbleMax.x, workspaceMax.x) -
+      Math.max(bubbleMin.x, workspaceMin.x);
+  var overlapHeight = Math.min(bubbleMax.y, workspaceMax.y) -
+      Math.max(bubbleMin.y, workspaceMin.y);
+  return Math.max(
+      0,
+      Math.min(
+          1, (overlapWidth * overlapHeight) / (this.width_ * this.height_)));
+};
+
+/**
+ * Calculate what the optimal horizontal position of the top-left corner of the
+ * bubble is (relative to the anchor point) so that the most area of the
+ * bubble is shown.
+ * @param {!Blockly.MetricsManager.ContainerRegion} viewMetrics The view metrics
+ *     of the workspace the bubble will appear in.
+ * @return {number} The optimal horizontal position of the top-left corner
+ *     of the bubble.
+ * @private
+ */
+Blockly.Bubble.prototype.getOptimalRelativeLeft_ = function(viewMetrics) {
+  var relativeLeft = -this.width_ / 4;
+
+  // No amount of sliding left or right will give us a better overlap.
+  if (this.width_ > viewMetrics.width) {
+    return relativeLeft;
+  }
+
+  if (this.workspace_.RTL) {
+    // Bubble coordinates are flipped in RTL.
+    var bubbleRight = this.anchorXY_.x - relativeLeft;
+    var bubbleLeft = bubbleRight - this.width_;
+
+    var workspaceRight = viewMetrics.left + viewMetrics.width;
+    var workspaceLeft = viewMetrics.left +
+        // Thickness in workspace units.
+        (Blockly.Scrollbar.scrollbarThickness / this.workspace_.scale);
+  } else {
+    var bubbleLeft = relativeLeft + this.anchorXY_.x;
+    var bubbleRight = bubbleLeft + this.width_;
+
+    var workspaceLeft = viewMetrics.left;
+    var workspaceRight = viewMetrics.left + viewMetrics.width -
+        // Thickness in workspace units.
+        (Blockly.Scrollbar.scrollbarThickness / this.workspace_.scale);
+  }
+
+  if (this.workspace_.RTL) {
+    if (bubbleLeft < workspaceLeft) {
+      // Slide the bubble right until it is onscreen.
+      relativeLeft = -(workspaceLeft - this.anchorXY_.x + this.width_);
+    } else if (bubbleRight > workspaceRight) {
+      // Slide the bubble left until it is onscreen.
+      relativeLeft = -(workspaceRight - this.anchorXY_.x);
+    }
+  } else {
+    if (bubbleLeft < workspaceLeft) {
+      // Slide the bubble right until it is onscreen.
+      relativeLeft = workspaceLeft - this.anchorXY_.x;
+    } else if (bubbleRight > workspaceRight) {
+      // Slide the bubble left until it is onscreen.
+      relativeLeft = workspaceRight - this.anchorXY_.x - this.width_;
+    }
+  }
+
+  return relativeLeft;
+};
+
+/**
+ * Calculate what the optimal vertical position of the top-left corner of
+ * the bubble is (relative to the anchor point) so that the most area of the
+ * bubble is shown.
+ * @param {!Blockly.MetricsManager.ContainerRegion} viewMetrics The view metrics
+ *     of the workspace the bubble will appear in.
+ * @return {number} The optimal vertical position of the top-left corner
+ *     of the bubble.
+ * @private
+ */
+Blockly.Bubble.prototype.getOptimalRelativeTop_ = function(viewMetrics) {
+  var relativeTop = -this.height_ / 4;
+
+  // No amount of sliding up or down will give us a better overlap.
+  if (this.height_ > viewMetrics.height) {
+    return relativeTop;
+  }
+
+  var bubbleTop = this.anchorXY_.y + relativeTop;
+  var bubbleBottom = bubbleTop + this.height_;
+  var workspaceTop = viewMetrics.top;
+  var workspaceBottom = viewMetrics.top + viewMetrics.height -
+      // Thickness in workspace units.
+      (Blockly.Scrollbar.scrollbarThickness / this.workspace_.scale);
+
+  var anchorY = this.anchorXY_.y;
+  if (bubbleTop < workspaceTop) {
+    // Slide the bubble down until it is onscreen.
+    relativeTop = workspaceTop - anchorY;
+  } else if (bubbleBottom > workspaceBottom) {
+    // Slide the bubble up until it is onscreen.
+    relativeTop = workspaceBottom - anchorY - this.height_;
+  }
+
+  return relativeTop;
+};
+
+/**
+ * Move the bubble to a location relative to the anchor's centre.
+ * @private
+ */
+Blockly.Bubble.prototype.positionBubble_ = function() {
+  var left = this.anchorXY_.x;
+  if (this.workspace_.RTL) {
+    left -= this.relativeLeft_ + this.width_;
+  } else {
+    left += this.relativeLeft_;
+  }
+  var top = this.relativeTop_ + this.anchorXY_.y;
+  this.moveTo(left, top);
+};
+
+/**
+ * Move the bubble group to the specified location in workspace coordinates.
+ * @param {number} x The x position to move to.
+ * @param {number} y The y position to move to.
+ * @package
+ */
+Blockly.Bubble.prototype.moveTo = function(x, y) {
+  this.bubbleGroup_.setAttribute('transform', 'translate(' + x + ',' + y + ')');
+};
+
+/**
+ * Triggers a move callback if one exists at the end of a drag.
+ * @param {boolean} adding True if adding, false if removing.
+ * @package
+ */
+Blockly.Bubble.prototype.setDragging = function(adding) {
+  if (!adding && this.moveCallback_) {
+    this.moveCallback_();
+  }
+};
+
+/**
+ * Get the dimensions of this bubble.
+ * @return {!Blockly.utils.Size} The height and width of the bubble.
+ */
+Blockly.Bubble.prototype.getBubbleSize = function() {
+  return new Blockly.utils.Size(this.width_, this.height_);
+};
+
+/**
+ * Size this bubble.
+ * @param {number} width Width of the bubble.
+ * @param {number} height Height of the bubble.
+ */
+Blockly.Bubble.prototype.setBubbleSize = function(width, height) {
+  var doubleBorderWidth = 2 * Blockly.Bubble.BORDER_WIDTH;
+  // Minimum size of a bubble.
+  width = Math.max(width, doubleBorderWidth + 45);
+  height = Math.max(height, doubleBorderWidth + 20);
+  this.width_ = width;
+  this.height_ = height;
+  this.bubbleBack_.setAttribute('width', width);
+  this.bubbleBack_.setAttribute('height', height);
+  if (this.resizeGroup_) {
+    if (this.workspace_.RTL) {
+      // Mirror the resize group.
+      var resizeSize = 2 * Blockly.Bubble.BORDER_WIDTH;
+      this.resizeGroup_.setAttribute(
+          'transform',
+          'translate(' + resizeSize + ',' + (height - doubleBorderWidth) +
+              ') scale(-1 1)');
+    } else {
+      this.resizeGroup_.setAttribute(
+          'transform',
+          'translate(' + (width - doubleBorderWidth) + ',' +
+              (height - doubleBorderWidth) + ')');
+    }
+  }
+  if (this.autoLayout_) {
+    this.layoutBubble_();
+  }
+  this.positionBubble_();
+  this.renderArrow_();
+
+  // Allow the contents to resize.
+  if (this.resizeCallback_) {
+    this.resizeCallback_();
+  }
+};
+
+/**
+ * Draw the arrow between the bubble and the origin.
+ * @private
+ */
+Blockly.Bubble.prototype.renderArrow_ = function() {
+  var steps = [];
+  // Find the relative coordinates of the center of the bubble.
+  var relBubbleX = this.width_ / 2;
+  var relBubbleY = this.height_ / 2;
+  // Find the relative coordinates of the center of the anchor.
+  var relAnchorX = -this.relativeLeft_;
+  var relAnchorY = -this.relativeTop_;
+  if (relBubbleX == relAnchorX && relBubbleY == relAnchorY) {
+    // Null case.  Bubble is directly on top of the anchor.
+    // Short circuit this rather than wade through divide by zeros.
+    steps.push('M ' + relBubbleX + ',' + relBubbleY);
+  } else {
+    // Compute the angle of the arrow's line.
+    var rise = relAnchorY - relBubbleY;
+    var run = relAnchorX - relBubbleX;
+    if (this.workspace_.RTL) {
+      run *= -1;
+    }
+    var hypotenuse = Math.sqrt(rise * rise + run * run);
+    var angle = Math.acos(run / hypotenuse);
+    if (rise < 0) {
+      angle = 2 * Math.PI - angle;
+    }
+    // Compute a line perpendicular to the arrow.
+    var rightAngle = angle + Math.PI / 2;
+    if (rightAngle > Math.PI * 2) {
+      rightAngle -= Math.PI * 2;
+    }
+    var rightRise = Math.sin(rightAngle);
+    var rightRun = Math.cos(rightAngle);
+
+    // Calculate the thickness of the base of the arrow.
+    var bubbleSize = this.getBubbleSize();
+    var thickness =
+        (bubbleSize.width + bubbleSize.height) / Blockly.Bubble.ARROW_THICKNESS;
+    thickness = Math.min(thickness, bubbleSize.width, bubbleSize.height) / 4;
+
+    // Back the tip of the arrow off of the anchor.
+    var backoffRatio = 1 - Blockly.Bubble.ANCHOR_RADIUS / hypotenuse;
+    relAnchorX = relBubbleX + backoffRatio * run;
+    relAnchorY = relBubbleY + backoffRatio * rise;
+
+    // Coordinates for the base of the arrow.
+    var baseX1 = relBubbleX + thickness * rightRun;
+    var baseY1 = relBubbleY + thickness * rightRise;
+    var baseX2 = relBubbleX - thickness * rightRun;
+    var baseY2 = relBubbleY - thickness * rightRise;
+
+    // Distortion to curve the arrow.
+    var swirlAngle = angle + this.arrow_radians_;
+    if (swirlAngle > Math.PI * 2) {
+      swirlAngle -= Math.PI * 2;
+    }
+    var swirlRise =
+        Math.sin(swirlAngle) * hypotenuse / Blockly.Bubble.ARROW_BEND;
+    var swirlRun =
+        Math.cos(swirlAngle) * hypotenuse / Blockly.Bubble.ARROW_BEND;
+
+    steps.push('M' + baseX1 + ',' + baseY1);
+    steps.push(
+        'C' + (baseX1 + swirlRun) + ',' + (baseY1 + swirlRise) + ' ' +
+        relAnchorX + ',' + relAnchorY + ' ' + relAnchorX + ',' + relAnchorY);
+    steps.push(
+        'C' + relAnchorX + ',' + relAnchorY + ' ' + (baseX2 + swirlRun) + ',' +
+        (baseY2 + swirlRise) + ' ' + baseX2 + ',' + baseY2);
+  }
+  steps.push('z');
+  this.bubbleArrow_.setAttribute('d', steps.join(' '));
+};
+
+/**
+ * Change the colour of a bubble.
+ * @param {string} hexColour Hex code of colour.
+ */
+Blockly.Bubble.prototype.setColour = function(hexColour) {
+  this.bubbleBack_.setAttribute('fill', hexColour);
+  this.bubbleArrow_.setAttribute('fill', hexColour);
+};
+
+/**
+ * Dispose of this bubble.
+ */
+Blockly.Bubble.prototype.dispose = function() {
+  if (this.onMouseDownBubbleWrapper_) {
+    Blockly.browserEvents.unbind(this.onMouseDownBubbleWrapper_);
+  }
+  if (this.onMouseDownResizeWrapper_) {
+    Blockly.browserEvents.unbind(this.onMouseDownResizeWrapper_);
+  }
+  Blockly.Bubble.unbindDragEvents_();
+  Blockly.utils.dom.removeNode(this.bubbleGroup_);
+  this.disposed = true;
+};
+
+/**
+ * Move this bubble during a drag, taking into account whether or not there is
+ * a drag surface.
+ * @param {Blockly.BlockDragSurfaceSvg} dragSurface The surface that carries
+ *     rendered items during a drag, or null if no drag surface is in use.
+ * @param {!Blockly.utils.Coordinate} newLoc The location to translate to, in
+ *     workspace coordinates.
+ * @package
+ */
+Blockly.Bubble.prototype.moveDuringDrag = function(dragSurface, newLoc) {
+  if (dragSurface) {
+    dragSurface.translateSurface(newLoc.x, newLoc.y);
+  } else {
+    this.moveTo(newLoc.x, newLoc.y);
+  }
+  if (this.workspace_.RTL) {
+    this.relativeLeft_ = this.anchorXY_.x - newLoc.x - this.width_;
+  } else {
+    this.relativeLeft_ = newLoc.x - this.anchorXY_.x;
+  }
+  this.relativeTop_ = newLoc.y - this.anchorXY_.y;
+  this.renderArrow_();
+};
+
+/**
+ * Return the coordinates of the top-left corner of this bubble's body relative
+ * to the drawing surface's origin (0,0), in workspace units.
+ * @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
+ */
+Blockly.Bubble.prototype.getRelativeToSurfaceXY = function() {
+  return new Blockly.utils.Coordinate(
+      this.workspace_.RTL ?
+          -this.relativeLeft_ + this.anchorXY_.x - this.width_ :
+          this.anchorXY_.x + this.relativeLeft_,
+      this.anchorXY_.y + this.relativeTop_);
+};
+
+/**
+ * Set whether auto-layout of this bubble is enabled.  The first time a bubble
+ * is shown it positions itself to not cover any blocks.  Once a user has
+ * dragged it to reposition, it renders where the user put it.
+ * @param {boolean} enable True if auto-layout should be enabled, false
+ *     otherwise.
+ * @package
+ */
+Blockly.Bubble.prototype.setAutoLayout = function(enable) {
+  this.autoLayout_ = enable;
+};
+
+/**
+ * Create the text for a non editable bubble.
+ * @param {string} text The text to display.
+ * @return {!SVGTextElement} The top-level node of the text.
+ * @package
+ */
+Blockly.Bubble.textToDom = function(text) {
+  var paragraph = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.TEXT, {
+        'class': 'blocklyText blocklyBubbleText blocklyNoPointerEvents',
+        'y': Blockly.Bubble.BORDER_WIDTH
+      },
+      null);
+  var lines = text.split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    var tspanElement = Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.TSPAN,
+        {'dy': '1em', 'x': Blockly.Bubble.BORDER_WIDTH}, paragraph);
+    var textNode = document.createTextNode(lines[i]);
+    tspanElement.appendChild(textNode);
+  }
+  return paragraph;
+};
+
+/**
+ * Creates a bubble that can not be edited.
+ * @param {!SVGTextElement} paragraphElement The text element for the non
+ *     editable bubble.
+ * @param {!Blockly.BlockSvg} block The block that the bubble is attached to.
+ * @param {!Blockly.utils.Coordinate} iconXY The coordinate of the icon.
+ * @return {!Blockly.Bubble} The non editable bubble.
+ * @package
+ */
+Blockly.Bubble.createNonEditableBubble = function(
+    paragraphElement, block, iconXY) {
+  var bubble = new Blockly.Bubble(
+      /** @type {!Blockly.WorkspaceSvg} */ (block.workspace), paragraphElement,
+      block.pathObject.svgPath,
+      /** @type {!Blockly.utils.Coordinate} */ (iconXY), null, null);
+  // Expose this bubble's block's ID on its top-level SVG group.
+  bubble.setSvgId(block.id);
+  if (block.RTL) {
+    // Right-align the paragraph.
+    // This cannot be done until the bubble is rendered on screen.
+    var maxWidth = paragraphElement.getBBox().width;
+    for (var i = 0, textElement; (textElement = paragraphElement.childNodes[i]);
+      i++) {
+      textElement.setAttribute('text-anchor', 'end');
+      textElement.setAttribute('x', maxWidth + Blockly.Bubble.BORDER_WIDTH);
+    }
+  }
+  return bubble;
+};

blockly/core/bubble_dragger.js

@@ -0,0 +1,276 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Methods for dragging a bubble visually.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.BubbleDragger');
+
+/** @suppress {extraRequire} */
+goog.require('Blockly.Bubble');
+goog.require('Blockly.ComponentManager');
+/** @suppress {extraRequire} */
+goog.require('Blockly.constants');
+goog.require('Blockly.Events');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.CommentMove');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.Coordinate');
+
+goog.requireType('Blockly.BlockDragSurfaceSvg');
+goog.requireType('Blockly.IBubble');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Class for a bubble dragger.  It moves things on the bubble canvas around the
+ * workspace when they are being dragged by a mouse or touch.  These can be
+ * block comments, mutators, warnings, or workspace comments.
+ * @param {!Blockly.IBubble} bubble The item on the bubble canvas to drag.
+ * @param {!Blockly.WorkspaceSvg} workspace The workspace to drag on.
+ * @constructor
+ */
+Blockly.BubbleDragger = function(bubble, workspace) {
+  /**
+   * The item on the bubble canvas that is being dragged.
+   * @type {!Blockly.IBubble}
+   * @private
+   */
+  this.draggingBubble_ = bubble;
+
+  /**
+   * The workspace on which the bubble is being dragged.
+   * @type {!Blockly.WorkspaceSvg}
+   * @private
+   */
+  this.workspace_ = workspace;
+
+  /**
+   * Which drag target the mouse pointer is over, if any.
+   * @type {?Blockly.IDragTarget}
+   * @private
+   */
+  this.dragTarget_ = null;
+
+  /**
+   * Whether the bubble would be deleted if dropped immediately.
+   * @type {boolean}
+   * @private
+   */
+  this.wouldDeleteBubble_ = false;
+
+  /**
+   * The location of the top left corner of the dragging bubble's body at the
+   * beginning of the drag, in workspace coordinates.
+   * @type {!Blockly.utils.Coordinate}
+   * @private
+   */
+  this.startXY_ = this.draggingBubble_.getRelativeToSurfaceXY();
+
+  /**
+   * The drag surface to move bubbles to during a drag, or null if none should
+   * be used.  Block dragging and bubble dragging use the same surface.
+   * @type {Blockly.BlockDragSurfaceSvg}
+   * @private
+   */
+  this.dragSurface_ =
+      Blockly.utils.is3dSupported() && !!workspace.getBlockDragSurface() ?
+      workspace.getBlockDragSurface() :
+      null;
+};
+
+/**
+ * Sever all links from this object.
+ * @package
+ * @suppress {checkTypes}
+ */
+Blockly.BubbleDragger.prototype.dispose = function() {
+  this.draggingBubble_ = null;
+  this.workspace_ = null;
+  this.dragSurface_ = null;
+};
+
+/**
+ * Start dragging a bubble.  This includes moving it to the drag surface.
+ * @package
+ */
+Blockly.BubbleDragger.prototype.startBubbleDrag = function() {
+  if (!Blockly.Events.getGroup()) {
+    Blockly.Events.setGroup(true);
+  }
+
+  this.workspace_.setResizesEnabled(false);
+  this.draggingBubble_.setAutoLayout(false);
+  if (this.dragSurface_) {
+    this.moveToDragSurface_();
+  }
+
+  this.draggingBubble_.setDragging && this.draggingBubble_.setDragging(true);
+};
+
+/**
+ * Execute a step of bubble dragging, based on the given event.  Update the
+ * display accordingly.
+ * @param {!Event} e The most recent move event.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at the start of the drag, in pixel units.
+ * @package
+ */
+Blockly.BubbleDragger.prototype.dragBubble = function(e, currentDragDeltaXY) {
+  var delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+  var newLoc = Blockly.utils.Coordinate.sum(this.startXY_, delta);
+  this.draggingBubble_.moveDuringDrag(this.dragSurface_, newLoc);
+
+  var oldDragTarget = this.dragTarget_;
+  this.dragTarget_ = this.workspace_.getDragTarget(e);
+
+  var oldWouldDeleteBubble = this.wouldDeleteBubble_;
+  this.wouldDeleteBubble_ = this.shouldDelete_(this.dragTarget_);
+  if (oldWouldDeleteBubble != this.wouldDeleteBubble_) {
+    // Prevent unnecessary add/remove class calls.
+    this.updateCursorDuringBubbleDrag_();
+  }
+
+  // Call drag enter/exit/over after wouldDeleteBlock is called in shouldDelete_
+  if (this.dragTarget_ !== oldDragTarget) {
+    oldDragTarget && oldDragTarget.onDragExit(this.draggingBubble_);
+    this.dragTarget_ && this.dragTarget_.onDragEnter(this.draggingBubble_);
+  }
+  this.dragTarget_ && this.dragTarget_.onDragOver(this.draggingBubble_);
+};
+
+/**
+ * Whether ending the drag would delete the bubble.
+ * @param {?Blockly.IDragTarget} dragTarget The drag target that the bubblee is
+ *     currently over.
+ * @return {boolean} Whether dropping the bubble immediately would delete the
+ *    block.
+ * @private
+ */
+Blockly.BubbleDragger.prototype.shouldDelete_ = function(dragTarget) {
+  if (dragTarget) {
+    var componentManager = this.workspace_.getComponentManager();
+    var isDeleteArea = componentManager.hasCapability(dragTarget.id,
+        Blockly.ComponentManager.Capability.DELETE_AREA);
+    if (isDeleteArea) {
+      return (/** @type {!Blockly.IDeleteArea} */ (dragTarget))
+          .wouldDelete(this.draggingBubble_, false);
+    }
+  }
+  return false;
+};
+
+/**
+ * Update the cursor (and possibly the trash can lid) to reflect whether the
+ * dragging bubble would be deleted if released immediately.
+ * @private
+ */
+Blockly.BubbleDragger.prototype.updateCursorDuringBubbleDrag_ = function() {
+  this.draggingBubble_.setDeleteStyle(this.wouldDeleteBubble_);
+};
+
+/**
+ * Finish a bubble drag and put the bubble back on the workspace.
+ * @param {!Event} e The mouseup/touchend event.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at the start of the drag, in pixel units.
+ * @package
+ */
+Blockly.BubbleDragger.prototype.endBubbleDrag = function(
+    e, currentDragDeltaXY) {
+  // Make sure internal state is fresh.
+  this.dragBubble(e, currentDragDeltaXY);
+
+  var preventMove = this.dragTarget_ &&
+      this.dragTarget_.shouldPreventMove(this.draggingBubble_);
+  if (preventMove) {
+    var newLoc = this.startXY_;
+  } else {
+    var delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+    var newLoc = Blockly.utils.Coordinate.sum(this.startXY_, delta);
+  }
+  // Move the bubble to its final location.
+  this.draggingBubble_.moveTo(newLoc.x, newLoc.y);
+
+  if (this.dragTarget_) {
+    this.dragTarget_.onDrop(this.draggingBubble_);
+  }
+
+  if (this.wouldDeleteBubble_) {
+    // Fire a move event, so we know where to go back to for an undo.
+    this.fireMoveEvent_();
+    this.draggingBubble_.dispose(false, true);
+  } else {
+    // Put everything back onto the bubble canvas.
+    if (this.dragSurface_) {
+      this.dragSurface_.clearAndHide(this.workspace_.getBubbleCanvas());
+    }
+    if (this.draggingBubble_.setDragging) {
+      this.draggingBubble_.setDragging(false);
+    }
+    this.fireMoveEvent_();
+  }
+  this.workspace_.setResizesEnabled(true);
+
+  Blockly.Events.setGroup(false);
+};
+
+/**
+ * Fire a move event at the end of a bubble drag.
+ * @private
+ */
+Blockly.BubbleDragger.prototype.fireMoveEvent_ = function() {
+  if (this.draggingBubble_.isComment) {
+    var event = new (Blockly.Events.get(Blockly.Events.COMMENT_MOVE))(
+        /** @type {!Blockly.WorkspaceCommentSvg} */ (this.draggingBubble_));
+    event.setOldCoordinate(this.startXY_);
+    event.recordNew();
+    Blockly.Events.fire(event);
+  }
+  // TODO (fenichel): move events for comments.
+  return;
+};
+
+/**
+ * Convert a coordinate object from pixels to workspace units, including a
+ * correction for mutator workspaces.
+ * This function does not consider differing origins.  It simply scales the
+ * input's x and y values.
+ * @param {!Blockly.utils.Coordinate} pixelCoord A coordinate with x and y
+ *     values in CSS pixel units.
+ * @return {!Blockly.utils.Coordinate} The input coordinate divided by the
+ *     workspace scale.
+ * @private
+ */
+Blockly.BubbleDragger.prototype.pixelsToWorkspaceUnits_ = function(pixelCoord) {
+  var result = new Blockly.utils.Coordinate(
+      pixelCoord.x / this.workspace_.scale,
+      pixelCoord.y / this.workspace_.scale);
+  if (this.workspace_.isMutator) {
+    // If we're in a mutator, its scale is always 1, purely because of some
+    // oddities in our rendering optimizations.  The actual scale is the same as
+    // the scale on the parent workspace.
+    // Fix that for dragging.
+    var mainScale = this.workspace_.options.parentWorkspace.scale;
+    result.scale(1 / mainScale);
+  }
+  return result;
+};
+
+/**
+ * Move the bubble onto the drag surface at the beginning of a drag.  Move the
+ * drag surface to preserve the apparent location of the bubble.
+ * @private
+ */
+Blockly.BubbleDragger.prototype.moveToDragSurface_ = function() {
+  this.draggingBubble_.moveTo(0, 0);
+  this.dragSurface_.translateSurface(this.startXY_.x, this.startXY_.y);
+  // Execute the move on the top-level SVG component.
+  this.dragSurface_.setBlocksAndShow(this.draggingBubble_.getSvgRoot());
+};

blockly/core/comment.js

@@ -0,0 +1,414 @@
+/**
+ * @license
+ * Copyright 2011 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Object representing a code comment.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Comment');
+
+goog.require('Blockly.browserEvents');
+goog.require('Blockly.Bubble');
+goog.require('Blockly.Css');
+goog.require('Blockly.Events');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BlockChange');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BubbleOpen');
+goog.require('Blockly.Icon');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.Svg');
+goog.require('Blockly.utils.userAgent');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Warning');
+
+goog.requireType('Blockly.Block');
+goog.requireType('Blockly.BlockSvg');
+goog.requireType('Blockly.utils.Coordinate');
+goog.requireType('Blockly.utils.Size');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Class for a comment.
+ * @param {!Blockly.Block} block The block associated with this comment.
+ * @extends {Blockly.Icon}
+ * @constructor
+ */
+Blockly.Comment = function(block) {
+  Blockly.Comment.superClass_.constructor.call(this, block);
+
+  /**
+   * The model for this comment.
+   * @type {!Blockly.Block.CommentModel}
+   * @private
+   */
+  this.model_ = block.commentModel;
+  // If someone creates the comment directly instead of calling
+  // block.setCommentText we want to make sure the text is non-null;
+  this.model_.text = this.model_.text || '';
+
+  /**
+   * The model's text value at the start of an edit.
+   * Used to tell if an event should be fired at the end of an edit.
+   * @type {?string}
+   * @private
+   */
+  this.cachedText_ = '';
+
+  /**
+   * Mouse up event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onMouseUpWrapper_ = null;
+
+  /**
+   * Wheel event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onWheelWrapper_ = null;
+
+  /**
+   * Change event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onChangeWrapper_ = null;
+
+  /**
+   * Input event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onInputWrapper_ = null;
+
+  this.createIcon();
+};
+Blockly.utils.object.inherits(Blockly.Comment, Blockly.Icon);
+
+/**
+ * Draw the comment icon.
+ * @param {!Element} group The icon group.
+ * @protected
+ */
+Blockly.Comment.prototype.drawIcon_ = function(group) {
+  // Circle.
+  Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.CIRCLE,
+      {'class': 'blocklyIconShape', 'r': '8', 'cx': '8', 'cy': '8'},
+      group);
+  // Can't use a real '?' text character since different browsers and operating
+  // systems render it differently.
+  // Body of question mark.
+  Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.PATH,
+      {
+        'class': 'blocklyIconSymbol',
+        'd': 'm6.8,10h2c0.003,-0.617 0.271,-0.962 0.633,-1.266 2.875,-2.405' +
+          '0.607,-5.534 -3.765,-3.874v1.7c3.12,-1.657 3.698,0.118 2.336,1.25' +
+          '-1.201,0.998 -1.201,1.528 -1.204,2.19z'},
+      group);
+  // Dot of question mark.
+  Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.RECT,
+      {
+        'class': 'blocklyIconSymbol',
+        'x': '6.8',
+        'y': '10.78',
+        'height': '2',
+        'width': '2'
+      },
+      group);
+};
+
+/**
+ * Create the editor for the comment's bubble.
+ * @return {!SVGElement} The top-level node of the editor.
+ * @private
+ */
+Blockly.Comment.prototype.createEditor_ = function() {
+  /* Create the editor.  Here's the markup that will be generated in
+   * editable mode:
+    <foreignObject x="8" y="8" width="164" height="164">
+      <body xmlns="http://www.w3.org/1999/xhtml" class="blocklyMinimalBody">
+        <textarea xmlns="http://www.w3.org/1999/xhtml"
+            class="blocklyCommentTextarea"
+            style="height: 164px; width: 164px;"></textarea>
+      </body>
+    </foreignObject>
+   * For non-editable mode see Warning.textToDom_.
+   */
+
+  this.foreignObject_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.FOREIGNOBJECT,
+      {'x': Blockly.Bubble.BORDER_WIDTH, 'y': Blockly.Bubble.BORDER_WIDTH},
+      null);
+
+  var body = document.createElementNS(Blockly.utils.dom.HTML_NS, 'body');
+  body.setAttribute('xmlns', Blockly.utils.dom.HTML_NS);
+  body.className = 'blocklyMinimalBody';
+
+  this.textarea_ = document.createElementNS(
+      Blockly.utils.dom.HTML_NS, 'textarea');
+  var textarea = this.textarea_;
+  textarea.className = 'blocklyCommentTextarea';
+  textarea.setAttribute('dir', this.block_.RTL ? 'RTL' : 'LTR');
+  textarea.value = this.model_.text;
+  this.resizeTextarea_();
+
+  body.appendChild(textarea);
+  this.foreignObject_.appendChild(body);
+
+  // Ideally this would be hooked to the focus event for the comment.
+  // However doing so in Firefox swallows the cursor for unknown reasons.
+  // So this is hooked to mouseup instead.  No big deal.
+  this.onMouseUpWrapper_ = Blockly.browserEvents.conditionalBind(
+      textarea, 'mouseup', this, this.startEdit_, true, true);
+  // Don't zoom with mousewheel.
+  this.onWheelWrapper_ = Blockly.browserEvents.conditionalBind(
+      textarea, 'wheel', this, function(e) {
+        e.stopPropagation();
+      });
+  this.onChangeWrapper_ = Blockly.browserEvents.conditionalBind(
+      textarea, 'change', this, function(_e) {
+        if (this.cachedText_ != this.model_.text) {
+          Blockly.Events.fire(
+              new (Blockly.Events.get(Blockly.Events.BLOCK_CHANGE))(
+                  this.block_, 'comment', null, this.cachedText_,
+                  this.model_.text));
+        }
+      });
+  this.onInputWrapper_ = Blockly.browserEvents.conditionalBind(
+      textarea, 'input', this, function(_e) {
+        this.model_.text = textarea.value;
+      });
+
+  setTimeout(textarea.focus.bind(textarea), 0);
+
+  return this.foreignObject_;
+};
+
+/**
+ * Add or remove editability of the comment.
+ * @override
+ */
+Blockly.Comment.prototype.updateEditable = function() {
+  Blockly.Comment.superClass_.updateEditable.call(this);
+  if (this.isVisible()) {
+    // Recreate the bubble with the correct UI.
+    this.disposeBubble_();
+    this.createBubble_();
+  }
+};
+
+/**
+ * Callback function triggered when the bubble has resized.
+ * Resize the text area accordingly.
+ * @private
+ */
+Blockly.Comment.prototype.onBubbleResize_ = function() {
+  if (!this.isVisible()) {
+    return;
+  }
+  this.model_.size = this.bubble_.getBubbleSize();
+  this.resizeTextarea_();
+};
+
+/**
+ * Resizes the text area to match the size defined on the model (which is
+ * the size of the bubble).
+ * @private
+ */
+Blockly.Comment.prototype.resizeTextarea_ = function() {
+  var size = this.model_.size;
+  var doubleBorderWidth = 2 * Blockly.Bubble.BORDER_WIDTH;
+  var widthMinusBorder = size.width - doubleBorderWidth;
+  var heightMinusBorder = size.height - doubleBorderWidth;
+  this.foreignObject_.setAttribute('width', widthMinusBorder);
+  this.foreignObject_.setAttribute('height', heightMinusBorder);
+  this.textarea_.style.width = (widthMinusBorder - 4) + 'px';
+  this.textarea_.style.height = (heightMinusBorder - 4) + 'px';
+};
+
+/**
+ * Show or hide the comment bubble.
+ * @param {boolean} visible True if the bubble should be visible.
+ */
+Blockly.Comment.prototype.setVisible = function(visible) {
+  if (visible == this.isVisible()) {
+    return;
+  }
+  Blockly.Events.fire(new (Blockly.Events.get(Blockly.Events.BUBBLE_OPEN))(
+      this.block_, visible, 'comment'));
+  this.model_.pinned = visible;
+  if (visible) {
+    this.createBubble_();
+  } else {
+    this.disposeBubble_();
+  }
+};
+
+/**
+ * Show the bubble. Handles deciding if it should be editable or not.
+ * @private
+ */
+Blockly.Comment.prototype.createBubble_ = function() {
+  if (!this.block_.isEditable() || Blockly.utils.userAgent.IE) {
+    // MSIE does not support foreignobject; textareas are impossible.
+    // https://docs.microsoft.com/en-us/openspecs/ie_standards/ms-svg/56e6e04c-7c8c-44dd-8100-bd745ee42034
+    // Always treat comments in IE as uneditable.
+    this.createNonEditableBubble_();
+  } else {
+    this.createEditableBubble_();
+  }
+};
+
+/**
+ * Show an editable bubble.
+ * @private
+ */
+Blockly.Comment.prototype.createEditableBubble_ = function() {
+  this.bubble_ = new Blockly.Bubble(
+      /** @type {!Blockly.WorkspaceSvg} */ (this.block_.workspace),
+      this.createEditor_(), this.block_.pathObject.svgPath,
+      /** @type {!Blockly.utils.Coordinate} */ (this.iconXY_),
+      this.model_.size.width, this.model_.size.height);
+  // Expose this comment's block's ID on its top-level SVG group.
+  this.bubble_.setSvgId(this.block_.id);
+  this.bubble_.registerResizeEvent(this.onBubbleResize_.bind(this));
+  this.applyColour();
+};
+
+/**
+ * Show a non-editable bubble.
+ * @private
+ * @suppress {checkTypes} Suppress `this` type mismatch.
+ */
+Blockly.Comment.prototype.createNonEditableBubble_ = function() {
+  // TODO (#2917): It would be great if the comment could support line breaks.
+  this.paragraphElement_ = Blockly.Bubble.textToDom(this.block_.getCommentText());
+  this.bubble_ = Blockly.Bubble.createNonEditableBubble(
+      this.paragraphElement_, /** @type {!Blockly.BlockSvg} */ (this.block_),
+      /** @type {!Blockly.utils.Coordinate} */ (this.iconXY_));
+  this.applyColour();
+};
+
+/**
+ * Dispose of the bubble.
+ * @private
+ * @suppress {checkTypes} Suppress `this` type mismatch.
+ */
+Blockly.Comment.prototype.disposeBubble_ = function() {
+  if (this.onMouseUpWrapper_) {
+    Blockly.browserEvents.unbind(this.onMouseUpWrapper_);
+    this.onMouseUpWrapper_ = null;
+  }
+  if (this.onWheelWrapper_) {
+    Blockly.browserEvents.unbind(this.onWheelWrapper_);
+    this.onWheelWrapper_ = null;
+  }
+  if (this.onChangeWrapper_) {
+    Blockly.browserEvents.unbind(this.onChangeWrapper_);
+    this.onChangeWrapper_ = null;
+  }
+  if (this.onInputWrapper_) {
+    Blockly.browserEvents.unbind(this.onInputWrapper_);
+    this.onInputWrapper_ = null;
+  }
+  this.bubble_.dispose();
+  this.bubble_ = null;
+  this.textarea_ = null;
+  this.foreignObject_ = null;
+  this.paragraphElement_ = null;
+};
+
+/**
+ * Callback fired when an edit starts.
+ *
+ * Bring the comment to the top of the stack when clicked on. Also cache the
+ * current text so it can be used to fire a change event.
+ * @param {!Event} _e Mouse up event.
+ * @private
+ */
+Blockly.Comment.prototype.startEdit_ = function(_e) {
+  if (this.bubble_.promote()) {
+    // Since the act of moving this node within the DOM causes a loss of focus,
+    // we need to reapply the focus.
+    this.textarea_.focus();
+  }
+
+  this.cachedText_ = this.model_.text;
+};
+
+/**
+ * Get the dimensions of this comment's bubble.
+ * @return {Blockly.utils.Size} Object with width and height properties.
+ */
+Blockly.Comment.prototype.getBubbleSize = function() {
+  return this.model_.size;
+};
+
+/**
+ * Size this comment's bubble.
+ * @param {number} width Width of the bubble.
+ * @param {number} height Height of the bubble.
+ */
+Blockly.Comment.prototype.setBubbleSize = function(width, height) {
+  if (this.bubble_) {
+    this.bubble_.setBubbleSize(width, height);
+  } else {
+    this.model_.size.width = width;
+    this.model_.size.height = height;
+  }
+};
+
+/**
+ * Update the comment's view to match the model.
+ * @package
+ */
+Blockly.Comment.prototype.updateText = function() {
+  if (this.textarea_) {
+    this.textarea_.value = this.model_.text;
+  } else if (this.paragraphElement_) {
+    // Non-Editable mode.
+    // TODO (#2917): If 2917 gets added this will probably need to be updated.
+    this.paragraphElement_.firstChild.textContent = this.model_.text;
+  }
+};
+
+/**
+ * Dispose of this comment.
+ *
+ * If you want to receive a comment "delete" event (newValue: null), then this
+ * should not be called directly. Instead call block.setCommentText(null);
+ */
+Blockly.Comment.prototype.dispose = function() {
+  this.block_.comment = null;
+  Blockly.Icon.prototype.dispose.call(this);
+};
+
+/**
+ * CSS for block comment.  See css.js for use.
+ */
+Blockly.Css.register([
+  /* eslint-disable indent */
+  '.blocklyCommentTextarea {',
+    'background-color: #fef49c;',
+    'border: 0;',
+    'outline: 0;',
+    'margin: 0;',
+    'padding: 3px;',
+    'resize: none;',
+    'display: block;',
+    'text-overflow: hidden;',
+  '}'
+  /* eslint-enable indent */
+]);

blockly/core/component_manager.js

@@ -0,0 +1,244 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Manager for all items registered with the workspace.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.ComponentManager');
+
+goog.requireType('Blockly.IAutoHideable');
+goog.requireType('Blockly.IComponent');
+goog.requireType('Blockly.IDeleteArea');
+goog.requireType('Blockly.IDragTarget');
+goog.requireType('Blockly.IPositionable');
+
+
+/**
+ * Manager for all items registered with the workspace.
+ * @constructor
+ */
+Blockly.ComponentManager = function() {
+  /**
+   * A map of the components registered with the workspace, mapped to id.
+   * @type {!Object<string, !Blockly.ComponentManager.ComponentDatum>}
+   * @private
+   */
+  this.componentData_ = Object.create(null);
+
+  /**
+   * A map of capabilities to component IDs.
+   * @type {!Object<string, !Array<string>>}
+   * @private
+   */
+  this.capabilityToComponentIds_ = Object.create(null);
+};
+
+/**
+ * An object storing component information.
+ * @typedef {{
+ *    component: !Blockly.IComponent,
+ *    capabilities: (
+ *     !Array<string|!Blockly.ComponentManager.Capability<!Blockly.IComponent>>
+ *       ),
+ *    weight: number
+ *  }}
+ */
+Blockly.ComponentManager.ComponentDatum;
+
+/**
+ * Adds a component.
+ * @param {!Blockly.ComponentManager.ComponentDatum} componentInfo The data for
+ *   the component to register.
+ * @param {boolean=} opt_allowOverrides True to prevent an error when overriding
+ *     an already registered item.
+ */
+Blockly.ComponentManager.prototype.addComponent = function(
+    componentInfo, opt_allowOverrides) {
+  // Don't throw an error if opt_allowOverrides is true.
+  var id = componentInfo.component.id;
+  if (!opt_allowOverrides && this.componentData_[id]) {
+    throw Error(
+        'Plugin "' + id + '" with capabilities "' +
+        this.componentData_[id].capabilities + '" already added.');
+  }
+  this.componentData_[id] = componentInfo;
+  var stringCapabilities = [];
+  for (var i = 0; i < componentInfo.capabilities.length; i++) {
+    var capability = String(componentInfo.capabilities[i]).toLowerCase();
+    stringCapabilities.push(capability);
+    if (this.capabilityToComponentIds_[capability] === undefined) {
+      this.capabilityToComponentIds_[capability] = [id];
+    } else {
+      this.capabilityToComponentIds_[capability].push(id);
+    }
+  }
+  this.componentData_[id].capabilities = stringCapabilities;
+};
+
+/**
+ * Removes a component.
+ * @param {string} id The ID of the component to remove.
+ */
+Blockly.ComponentManager.prototype.removeComponent = function(id) {
+  var componentInfo = this.componentData_[id];
+  if (!componentInfo) {
+    return;
+  }
+  for (var i = 0; i < componentInfo.capabilities.length; i++) {
+    var capability = String(componentInfo.capabilities[i]).toLowerCase();
+    this.capabilityToComponentIds_[capability].splice(
+        this.capabilityToComponentIds_[capability].indexOf(id), 1);
+  }
+  delete this.componentData_[id];
+};
+
+/**
+ * Adds a capability to a existing registered component.
+ * @param {string} id The ID of the component to add the capability to.
+ * @param {string|!Blockly.ComponentManager.Capability<T>} capability The
+ *     capability to add.
+ * @template T
+ */
+Blockly.ComponentManager.prototype.addCapability = function(id, capability) {
+  if (!this.getComponent(id)) {
+    throw Error('Cannot add capability, "' + capability + '". Plugin "' +
+        id + '" has not been added to the ComponentManager');
+  }
+  if (this.hasCapability(id, capability)) {
+    console.warn('Plugin "' + id + 'already has capability "' +
+        capability + '"');
+    return;
+  }
+  capability = String(capability).toLowerCase();
+  this.componentData_[id].capabilities.push(capability);
+  this.capabilityToComponentIds_[capability].push(id);
+};
+
+/**
+ * Removes a capability from an existing registered component.
+ * @param {string} id The ID of the component to remove the capability from.
+ * @param {string|!Blockly.ComponentManager.Capability<T>} capability The
+ *     capability to remove.
+ * @template T
+ */
+Blockly.ComponentManager.prototype.removeCapability = function(id, capability) {
+  if (!this.getComponent(id)) {
+    throw Error('Cannot remove capability, "' + capability + '". Plugin "' +
+        id + '" has not been added to the ComponentManager');
+  }
+  if (!this.hasCapability(id, capability)) {
+    console.warn('Plugin "' + id + 'doesn\'t have capability "' +
+        capability + '" to remove');
+    return;
+  }
+  capability = String(capability).toLowerCase();
+  this.componentData_[id].capabilities.splice(
+      this.componentData_[id].capabilities.indexOf(capability), 1);
+  this.capabilityToComponentIds_[capability].splice(
+      this.capabilityToComponentIds_[capability].indexOf(id), 1);
+};
+
+/**
+ * Returns whether the component with this id has the specified capability.
+ * @param {string} id The ID of the component to check.
+ * @param {string|!Blockly.ComponentManager.Capability<T>} capability The
+ *     capability to check for.
+ * @return {boolean} Whether the component has the capability.
+ * @template T
+ */
+Blockly.ComponentManager.prototype.hasCapability = function(id, capability) {
+  capability = String(capability).toLowerCase();
+  return this.componentData_[id].capabilities.indexOf(capability) !== -1;
+};
+
+/**
+ * Gets the component with the given ID.
+ * @param {string} id The ID of the component to get.
+ * @return {!Blockly.IComponent|undefined} The component with the given name
+ *    or undefined if not found.
+ */
+Blockly.ComponentManager.prototype.getComponent = function(id) {
+  return this.componentData_[id] && this.componentData_[id].component;
+};
+
+/**
+ * Gets all the components with the specified capability.
+ * @param {string|!Blockly.ComponentManager.Capability<T>
+ *   } capability The capability of the component.
+ * @param {boolean} sorted Whether to return list ordered by weights.
+ * @return {!Array<T>} The components that match the specified capability.
+ * @template T
+ */
+Blockly.ComponentManager.prototype.getComponents = function(capability, sorted) {
+  capability = String(capability).toLowerCase();
+  var componentIds = this.capabilityToComponentIds_[capability];
+  if (!componentIds) {
+    return [];
+  }
+  var components = [];
+  if (sorted) {
+    var componentDataList = [];
+    var componentData = this.componentData_;
+    componentIds.forEach(function(id) {
+      componentDataList.push(componentData[id]);
+    });
+    componentDataList.sort(function(a, b) {
+      return a.weight - b.weight;
+    });
+    componentDataList.forEach(function(ComponentDatum) {
+      components.push(ComponentDatum.component);
+    });
+  } else {
+    var componentData = this.componentData_;
+    componentIds.forEach(function(id) {
+      components.push(componentData[id].component);
+    });
+  }
+  return components;
+};
+
+/**
+ * A name with the capability of the element stored in the generic.
+ * @param {string} name The name of the component capability.
+ * @constructor
+ * @template T
+ */
+Blockly.ComponentManager.Capability = function(name) {
+  /**
+   * @type {string}
+   * @private
+   */
+  this.name_ = name;
+};
+
+/**
+ * Returns the name of the capability.
+ * @return {string} The name.
+ * @override
+ */
+Blockly.ComponentManager.Capability.prototype.toString = function() {
+  return this.name_;
+};
+
+/** @type {!Blockly.ComponentManager.Capability<!Blockly.IPositionable>} */
+Blockly.ComponentManager.Capability.POSITIONABLE =
+    new Blockly.ComponentManager.Capability('positionable');
+
+/** @type {!Blockly.ComponentManager.Capability<!Blockly.IDragTarget>} */
+Blockly.ComponentManager.Capability.DRAG_TARGET =
+    new Blockly.ComponentManager.Capability('drag_target');
+
+/** @type {!Blockly.ComponentManager.Capability<!Blockly.IDeleteArea>} */
+Blockly.ComponentManager.Capability.DELETE_AREA =
+    new Blockly.ComponentManager.Capability('delete_area');
+
+/** @type {!Blockly.ComponentManager.Capability<!Blockly.IAutoHideable>} */
+Blockly.ComponentManager.Capability.AUTOHIDEABLE =
+    new Blockly.ComponentManager.Capability('autohideable');

blockly/core/connection.js

@@ -0,0 +1,677 @@
+/**
+ * @license
+ * Copyright 2011 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Components for creating connections between blocks.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Connection');
+
+goog.require('Blockly.connectionTypes');
+/** @suppress {extraRequire} */
+goog.require('Blockly.constants');
+goog.require('Blockly.Events');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BlockMove');
+goog.require('Blockly.IASTNodeLocationWithBlock');
+goog.require('Blockly.utils.deprecation');
+goog.require('Blockly.Xml');
+
+goog.requireType('Blockly.Block');
+goog.requireType('Blockly.IConnectionChecker');
+goog.requireType('Blockly.Input');
+
+
+/**
+ * Class for a connection between blocks.
+ * @param {!Blockly.Block} source The block establishing this connection.
+ * @param {number} type The type of the connection.
+ * @constructor
+ * @implements {Blockly.IASTNodeLocationWithBlock}
+ */
+Blockly.Connection = function(source, type) {
+  /**
+   * @type {!Blockly.Block}
+   * @protected
+   */
+  this.sourceBlock_ = source;
+  /** @type {number} */
+  this.type = type;
+};
+
+/**
+ * Constants for checking whether two connections are compatible.
+ */
+Blockly.Connection.CAN_CONNECT = 0;
+Blockly.Connection.REASON_SELF_CONNECTION = 1;
+Blockly.Connection.REASON_WRONG_TYPE = 2;
+Blockly.Connection.REASON_TARGET_NULL = 3;
+Blockly.Connection.REASON_CHECKS_FAILED = 4;
+Blockly.Connection.REASON_DIFFERENT_WORKSPACES = 5;
+Blockly.Connection.REASON_SHADOW_PARENT = 6;
+Blockly.Connection.REASON_DRAG_CHECKS_FAILED = 7;
+
+/**
+ * Connection this connection connects to.  Null if not connected.
+ * @type {Blockly.Connection}
+ */
+Blockly.Connection.prototype.targetConnection = null;
+
+/**
+ * Has this connection been disposed of?
+ * @type {boolean}
+ * @package
+ */
+Blockly.Connection.prototype.disposed = false;
+
+/**
+ * List of compatible value types.  Null if all types are compatible.
+ * @type {Array}
+ * @private
+ */
+Blockly.Connection.prototype.check_ = null;
+
+/**
+ * DOM representation of a shadow block, or null if none.
+ * @type {Element}
+ * @private
+ */
+Blockly.Connection.prototype.shadowDom_ = null;
+
+/**
+ * Horizontal location of this connection.
+ * @type {number}
+ * @package
+ */
+Blockly.Connection.prototype.x = 0;
+
+/**
+ * Vertical location of this connection.
+ * @type {number}
+ * @package
+ */
+Blockly.Connection.prototype.y = 0;
+
+/**
+ * Connect two connections together.  This is the connection on the superior
+ * block.
+ * @param {!Blockly.Connection} childConnection Connection on inferior block.
+ * @protected
+ */
+Blockly.Connection.prototype.connect_ = function(childConnection) {
+  var INPUT = Blockly.connectionTypes.INPUT_VALUE;
+  var parentConnection = this;
+  var parentBlock = parentConnection.getSourceBlock();
+  var childBlock = childConnection.getSourceBlock();
+
+  // Make sure the childConnection is available.
+  if (childConnection.isConnected()) {
+    childConnection.disconnect();
+  }
+
+  // Make sure the parentConnection is available.
+  var orphan;
+  if (parentConnection.isConnected()) {
+    var shadowDom = parentConnection.getShadowDom(true);
+    parentConnection.shadowDom_ = null;  // Set to null so it doesn't respawn.
+    var target = parentConnection.targetBlock();
+    if (target.isShadow()) {
+      target.dispose(false);
+    } else {
+      parentConnection.disconnect();
+      orphan = target;
+    }
+    parentConnection.shadowDom_ = shadowDom;
+  }
+
+  // Connect the new connection to the parent.
+  var event;
+  if (Blockly.Events.isEnabled()) {
+    event = new (Blockly.Events.get(Blockly.Events.BLOCK_MOVE))(childBlock);
+  }
+  Blockly.Connection.connectReciprocally_(parentConnection, childConnection);
+  childBlock.setParent(parentBlock);
+  if (event) {
+    event.recordNew();
+    Blockly.Events.fire(event);
+  }
+
+  // Deal with the orphan if it exists.
+  if (orphan) {
+    var orphanConnection = parentConnection.type === INPUT ?
+        orphan.outputConnection : orphan.previousConnection;
+    var connection = Blockly.Connection.getConnectionForOrphanedConnection(
+        childBlock, /** @type {!Blockly.Connection} */ (orphanConnection));
+    if (connection) {
+      orphanConnection.connect(connection);
+    } else {
+      orphanConnection.onFailedConnect(parentConnection);
+    }
+  }
+};
+
+
+/**
+ * Dispose of this connection and deal with connected blocks.
+ * @package
+ */
+Blockly.Connection.prototype.dispose = function() {
+
+  // isConnected returns true for shadows and non-shadows.
+  if (this.isConnected()) {
+    // Destroy the attached shadow block & its children (if it exists).
+    this.setShadowDom(null);
+
+    var targetBlock = this.targetBlock();
+    if (targetBlock) {
+      // Disconnect the attached normal block.
+      targetBlock.unplug();
+    }
+  }
+
+  this.disposed = true;
+};
+
+/**
+ * Get the source block for this connection.
+ * @return {!Blockly.Block} The source block.
+ */
+Blockly.Connection.prototype.getSourceBlock = function() {
+  return this.sourceBlock_;
+};
+
+/**
+ * Does the connection belong to a superior block (higher in the source stack)?
+ * @return {boolean} True if connection faces down or right.
+ */
+Blockly.Connection.prototype.isSuperior = function() {
+  return this.type == Blockly.connectionTypes.INPUT_VALUE ||
+      this.type == Blockly.connectionTypes.NEXT_STATEMENT;
+};
+
+/**
+ * Is the connection connected?
+ * @return {boolean} True if connection is connected to another connection.
+ */
+Blockly.Connection.prototype.isConnected = function() {
+  return !!this.targetConnection;
+};
+
+/**
+ * Checks whether the current connection can connect with the target
+ * connection.
+ * @param {Blockly.Connection} target Connection to check compatibility with.
+ * @return {number} Blockly.Connection.CAN_CONNECT if the connection is legal,
+ *    an error code otherwise.
+ * @deprecated July 2020. Will be deleted July 2021. Use the workspace's
+ *     connectionChecker instead.
+ */
+Blockly.Connection.prototype.canConnectWithReason = function(target) {
+  Blockly.utils.deprecation.warn(
+      'Connection.prototype.canConnectWithReason',
+      'July 2020',
+      'July 2021',
+      'the workspace\'s connection checker');
+  return this.getConnectionChecker().canConnectWithReason(
+      this, target, false);
+};
+
+/**
+ * Checks whether the current connection and target connection are compatible
+ * and throws an exception if they are not.
+ * @param {Blockly.Connection} target The connection to check compatibility
+ *    with.
+ * @package
+ * @deprecated July 2020. Will be deleted July 2021. Use the workspace's
+ *     connectionChecker instead.
+ */
+Blockly.Connection.prototype.checkConnection = function(target) {
+  Blockly.utils.deprecation.warn(
+      'Connection.prototype.checkConnection',
+      'July 2020',
+      'July 2021',
+      'the workspace\'s connection checker');
+  var checker = this.getConnectionChecker();
+  var reason = checker.canConnectWithReason(this, target, false);
+  if (reason != Blockly.Connection.CAN_CONNECT) {
+    throw new Error(checker.getErrorMessage(reason, this, target));
+  }
+};
+
+/**
+ * Get the workspace's connection type checker object.
+ * @return {!Blockly.IConnectionChecker} The connection type checker for the
+ *     source block's workspace.
+ * @package
+ */
+Blockly.Connection.prototype.getConnectionChecker = function() {
+  return this.sourceBlock_.workspace.connectionChecker;
+};
+
+/**
+ * Check if the two connections can be dragged to connect to each other.
+ * @param {!Blockly.Connection} candidate A nearby connection to check.
+ * @return {boolean} True if the connection is allowed, false otherwise.
+ * @deprecated July 2020. Will be deleted July 2021. Use the workspace's
+ *     connectionChecker instead.
+ */
+Blockly.Connection.prototype.isConnectionAllowed = function(candidate) {
+  Blockly.utils.deprecation.warn(
+      'Connection.prototype.isConnectionAllowed',
+      'July 2020',
+      'July 2021',
+      'the workspace\'s connection checker');
+  return this.getConnectionChecker().canConnect(this, candidate, true);
+};
+
+/**
+ * Called when an attempted connection fails. NOP by default (i.e. for headless
+ * workspaces).
+ * @param {!Blockly.Connection} _otherConnection Connection that this connection
+ *     failed to connect to.
+ * @package
+ */
+Blockly.Connection.prototype.onFailedConnect = function(_otherConnection) {
+  // NOP
+};
+
+/**
+ * Connect this connection to another connection.
+ * @param {!Blockly.Connection} otherConnection Connection to connect to.
+ */
+Blockly.Connection.prototype.connect = function(otherConnection) {
+  if (this.targetConnection == otherConnection) {
+    // Already connected together.  NOP.
+    return;
+  }
+
+  var checker = this.getConnectionChecker();
+  if (checker.canConnect(this, otherConnection, false)) {
+    var eventGroup = Blockly.Events.getGroup();
+    if (!eventGroup) {
+      Blockly.Events.setGroup(true);
+    }
+    // Determine which block is superior (higher in the source stack).
+    if (this.isSuperior()) {
+      // Superior block.
+      this.connect_(otherConnection);
+    } else {
+      // Inferior block.
+      otherConnection.connect_(this);
+    }
+    if (!eventGroup) {
+      Blockly.Events.setGroup(false);
+    }
+  }
+};
+
+/**
+ * Update two connections to target each other.
+ * @param {Blockly.Connection} first The first connection to update.
+ * @param {Blockly.Connection} second The second connection to update.
+ * @private
+ */
+Blockly.Connection.connectReciprocally_ = function(first, second) {
+  if (!first || !second) {
+    throw Error('Cannot connect null connections.');
+  }
+  first.targetConnection = second;
+  second.targetConnection = first;
+};
+
+/**
+ * Returns the single connection on the block that will accept the orphaned
+ * block, if one can be found. If the block has multiple compatible connections
+ * (even if they are filled) this returns null. If the block has no compatible
+ * connections, this returns null.
+ * @param {!Blockly.Block} block The superior block.
+ * @param {!Blockly.Block} orphanBlock The inferior block.
+ * @return {?Blockly.Connection} The suitable connection point on 'block',
+ *     or null.
+ * @private
+ */
+Blockly.Connection.getSingleConnection_ = function(block, orphanBlock) {
+  var foundConnection = null;
+  var output = orphanBlock.outputConnection;
+  var typeChecker = output.getConnectionChecker();
+
+  for (var i = 0, input; (input = block.inputList[i]); i++) {
+    var connection = input.connection;
+    if (connection && typeChecker.canConnect(output, connection, false)) {
+      if (foundConnection) {
+        return null;  // More than one connection.
+      }
+      foundConnection = connection;
+    }
+  }
+  return foundConnection;
+};
+
+/**
+ * Walks down a row a blocks, at each stage checking if there are any
+ * connections that will accept the orphaned block.  If at any point there
+ * are zero or multiple eligible connections, returns null.  Otherwise
+ * returns the only input on the last block in the chain.
+ * Terminates early for shadow blocks.
+ * @param {!Blockly.Block} startBlock The block on which to start the search.
+ * @param {!Blockly.Block} orphanBlock The block that is looking for a home.
+ * @return {?Blockly.Connection} The suitable connection point on the chain
+ *     of blocks, or null.
+ * @private
+ */
+Blockly.Connection.getConnectionForOrphanedOutput_ =
+    function(startBlock, orphanBlock) {
+      var newBlock = startBlock;
+      var connection;
+      while ((connection = Blockly.Connection.getSingleConnection_(
+          /** @type {!Blockly.Block} */ (newBlock), orphanBlock))) {
+        newBlock = connection.targetBlock();
+        if (!newBlock || newBlock.isShadow()) {
+          return connection;
+        }
+      }
+      return null;
+    };
+
+/**
+ * Returns the connection (starting at the startBlock) which will accept
+ * the given connection. This includes compatible connection types and
+ * connection checks.
+ * @param {!Blockly.Block} startBlock The block on which to start the search.
+ * @param {!Blockly.Connection} orphanConnection The connection that is looking
+ *     for a home.
+ * @return {?Blockly.Connection} The suitable connection point on the chain of
+ *     blocks, or null.
+ */
+Blockly.Connection.getConnectionForOrphanedConnection =
+    function(startBlock, orphanConnection) {
+      if (orphanConnection.type === Blockly.connectionTypes.OUTPUT_VALUE) {
+        return Blockly.Connection.getConnectionForOrphanedOutput_(
+            startBlock, orphanConnection.getSourceBlock());
+      }
+      // Otherwise we're dealing with a stack.
+      var connection = startBlock.lastConnectionInStack(true);
+      var checker = orphanConnection.getConnectionChecker();
+      if (connection &&
+          checker.canConnect(orphanConnection, connection, false)) {
+        return connection;
+      }
+      return null;
+    };
+
+/**
+ * Disconnect this connection.
+ */
+Blockly.Connection.prototype.disconnect = function() {
+  var otherConnection = this.targetConnection;
+  if (!otherConnection) {
+    throw Error('Source connection not connected.');
+  }
+  if (otherConnection.targetConnection != this) {
+    throw Error('Target connection not connected to source connection.');
+  }
+  var parentBlock, childBlock, parentConnection;
+  if (this.isSuperior()) {
+    // Superior block.
+    parentBlock = this.sourceBlock_;
+    childBlock = otherConnection.getSourceBlock();
+    parentConnection = this;
+  } else {
+    // Inferior block.
+    parentBlock = otherConnection.getSourceBlock();
+    childBlock = this.sourceBlock_;
+    parentConnection = otherConnection;
+  }
+
+  var eventGroup = Blockly.Events.getGroup();
+  if (!eventGroup) {
+    Blockly.Events.setGroup(true);
+  }
+  this.disconnectInternal_(parentBlock, childBlock);
+  if (!childBlock.isShadow()) {
+    // If we were disconnecting a shadow, no need to spawn a new one.
+    parentConnection.respawnShadow_();
+  }
+  if (!eventGroup) {
+    Blockly.Events.setGroup(false);
+  }
+};
+
+/**
+ * Disconnect two blocks that are connected by this connection.
+ * @param {!Blockly.Block} parentBlock The superior block.
+ * @param {!Blockly.Block} childBlock The inferior block.
+ * @protected
+ */
+Blockly.Connection.prototype.disconnectInternal_ = function(parentBlock,
+    childBlock) {
+  var event;
+  if (Blockly.Events.isEnabled()) {
+    event = new (Blockly.Events.get(Blockly.Events.BLOCK_MOVE))(childBlock);
+  }
+  var otherConnection = this.targetConnection;
+  otherConnection.targetConnection = null;
+  this.targetConnection = null;
+  childBlock.setParent(null);
+  if (event) {
+    event.recordNew();
+    Blockly.Events.fire(event);
+  }
+};
+
+/**
+ * Respawn the shadow block if there was one connected to the this connection.
+ * @protected
+ */
+Blockly.Connection.prototype.respawnShadow_ = function() {
+  var parentBlock = this.getSourceBlock();
+  var shadow = this.getShadowDom();
+  if (parentBlock.workspace && shadow) {
+    var blockShadow = Blockly.Xml.domToBlock(shadow, parentBlock.workspace);
+    if (blockShadow.outputConnection) {
+      this.connect(blockShadow.outputConnection);
+    } else if (blockShadow.previousConnection) {
+      this.connect(blockShadow.previousConnection);
+    } else {
+      throw Error('Child block does not have output or previous statement.');
+    }
+  }
+};
+
+/**
+ * Returns the block that this connection connects to.
+ * @return {?Blockly.Block} The connected block or null if none is connected.
+ */
+Blockly.Connection.prototype.targetBlock = function() {
+  if (this.isConnected()) {
+    return this.targetConnection.getSourceBlock();
+  }
+  return null;
+};
+
+/**
+ * Is this connection compatible with another connection with respect to the
+ * value type system.  E.g. square_root("Hello") is not compatible.
+ * @param {!Blockly.Connection} otherConnection Connection to compare against.
+ * @return {boolean} True if the connections share a type.
+ * @deprecated July 2020. Will be deleted July 2021. Use the workspace's
+ *     connectionChecker instead.
+ */
+Blockly.Connection.prototype.checkType = function(otherConnection) {
+  Blockly.utils.deprecation.warn(
+      'Connection.prototype.checkType',
+      'October 2019',
+      'January 2021',
+      'the workspace\'s connection checker');
+  return this.getConnectionChecker().canConnect(this, otherConnection,
+      false);
+};
+
+/**
+ * Is this connection compatible with another connection with respect to the
+ * value type system.  E.g. square_root("Hello") is not compatible.
+ * @param {!Blockly.Connection} otherConnection Connection to compare against.
+ * @return {boolean} True if the connections share a type.
+ * @private
+ * @deprecated October 2019. Will be deleted January 2021. Use the workspace's
+ *     connectionChecker instead.
+ * @suppress {unusedPrivateMembers}
+ */
+Blockly.Connection.prototype.checkType_ = function(otherConnection) {
+  Blockly.utils.deprecation.warn(
+      'Connection.prototype.checkType_',
+      'October 2019',
+      'January 2021',
+      'the workspace\'s connection checker');
+  return this.checkType(otherConnection);
+};
+
+/**
+ * Function to be called when this connection's compatible types have changed.
+ * @protected
+ */
+Blockly.Connection.prototype.onCheckChanged_ = function() {
+  // The new value type may not be compatible with the existing connection.
+  if (this.isConnected() && (!this.targetConnection ||
+      !this.getConnectionChecker().canConnect(
+          this, this.targetConnection, false))) {
+    var child = this.isSuperior() ? this.targetBlock() : this.sourceBlock_;
+    child.unplug();
+  }
+};
+
+/**
+ * Change a connection's compatibility.
+ * @param {?(string|!Array<string>)} check Compatible value type or list of
+ *     value types. Null if all types are compatible.
+ * @return {!Blockly.Connection} The connection being modified
+ *     (to allow chaining).
+ */
+Blockly.Connection.prototype.setCheck = function(check) {
+  if (check) {
+    // Ensure that check is in an array.
+    if (!Array.isArray(check)) {
+      check = [check];
+    }
+    this.check_ = check;
+    this.onCheckChanged_();
+  } else {
+    this.check_ = null;
+  }
+  return this;
+};
+
+/**
+ * Get a connection's compatibility.
+ * @return {?Array} List of compatible value types.
+ *     Null if all types are compatible.
+ * @public
+ */
+Blockly.Connection.prototype.getCheck = function() {
+  return this.check_;
+};
+
+/**
+ * Changes the connection's shadow block.
+ * @param {?Element} shadow DOM representation of a block or null.
+ */
+Blockly.Connection.prototype.setShadowDom = function(shadow) {
+  this.shadowDom_ = shadow;
+  var target = this.targetBlock();
+  if (!target) {
+    this.respawnShadow_();
+  } else if (target.isShadow()) {
+    // The disconnect from dispose will automatically generate the new shadow.
+    target.dispose(false);
+    this.respawnShadow_();
+  }
+};
+
+/**
+ * Returns the xml representation of the connection's shadow block.
+ * @param {boolean=} returnCurrent If true, and the shadow block is currently
+ *     attached to this connection, this serializes the state of that block
+ *     and returns it (so that field values are correct). Otherwise the saved
+ *     shadowDom is just returned.
+ * @return {?Element} Shadow DOM representation of a block or null.
+ */
+Blockly.Connection.prototype.getShadowDom = function(returnCurrent) {
+  return (returnCurrent && this.targetBlock().isShadow()) ?
+      /** @type {!Element} */ (Blockly.Xml.blockToDom(
+          /** @type {!Blockly.Block} */ (this.targetBlock()))) :
+      this.shadowDom_;
+};
+
+/**
+ * Find all nearby compatible connections to this connection.
+ * Type checking does not apply, since this function is used for bumping.
+ *
+ * Headless configurations (the default) do not have neighboring connection,
+ * and always return an empty list (the default).
+ * {@link Blockly.RenderedConnection} overrides this behavior with a list
+ * computed from the rendered positioning.
+ * @param {number} _maxLimit The maximum radius to another connection.
+ * @return {!Array<!Blockly.Connection>} List of connections.
+ * @package
+ */
+Blockly.Connection.prototype.neighbours = function(_maxLimit) {
+  return [];
+};
+
+/**
+ * Get the parent input of a connection.
+ * @return {?Blockly.Input} The input that the connection belongs to or null if
+ *     no parent exists.
+ * @package
+ */
+Blockly.Connection.prototype.getParentInput = function() {
+  var parentInput = null;
+  var inputs = this.sourceBlock_.inputList;
+  for (var i = 0; i < inputs.length; i++) {
+    if (inputs[i].connection === this) {
+      parentInput = inputs[i];
+      break;
+    }
+  }
+  return parentInput;
+};
+
+/**
+ * This method returns a string describing this Connection in developer terms
+ * (English only). Intended to on be used in console logs and errors.
+ * @return {string} The description.
+ */
+Blockly.Connection.prototype.toString = function() {
+  var block = this.sourceBlock_;
+  if (!block) {
+    return 'Orphan Connection';
+  }
+  var msg;
+  if (block.outputConnection == this) {
+    msg = 'Output Connection of ';
+  } else if (block.previousConnection == this) {
+    msg = 'Previous Connection of ';
+  } else if (block.nextConnection == this) {
+    msg = 'Next Connection of ';
+  } else {
+    var parentInput = null;
+    for (var i = 0, input; (input = block.inputList[i]); i++) {
+      if (input.connection == this) {
+        parentInput = input;
+        break;
+      }
+    }
+    if (parentInput) {
+      msg = 'Input "' + parentInput.name + '" connection on ';
+    } else {
+      console.warn('Connection not actually connected to sourceBlock_');
+      return 'Orphan Connection';
+    }
+  }
+  return msg + block.toDevString();
+};

blockly/core/connection_checker.js

@@ -0,0 +1,289 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview An object that encapsulates logic for checking whether a potential
+ * connection is safe and valid.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.ConnectionChecker');
+
+goog.require('Blockly.Connection');
+goog.require('Blockly.connectionTypes');
+/** @suppress {extraRequire} */
+goog.require('Blockly.constants');
+goog.require('Blockly.IConnectionChecker');
+goog.require('Blockly.registry');
+
+goog.requireType('Blockly.RenderedConnection');
+
+
+/**
+ * Class for connection type checking logic.
+ * @implements {Blockly.IConnectionChecker}
+ * @constructor
+ */
+Blockly.ConnectionChecker = function() {
+};
+
+/**
+ * Check whether the current connection can connect with the target
+ * connection.
+ * @param {Blockly.Connection} a Connection to check compatibility with.
+ * @param {Blockly.Connection} b Connection to check compatibility with.
+ * @param {boolean} isDragging True if the connection is being made by dragging
+ *     a block.
+ * @param {number=} opt_distance The max allowable distance between the
+ *     connections for drag checks.
+ * @return {boolean} Whether the connection is legal.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.canConnect = function(a, b,
+    isDragging, opt_distance) {
+  return this.canConnectWithReason(a, b, isDragging, opt_distance) ==
+      Blockly.Connection.CAN_CONNECT;
+};
+
+/**
+ * Checks whether the current connection can connect with the target
+ * connection, and return an error code if there are problems.
+ * @param {Blockly.Connection} a Connection to check compatibility with.
+ * @param {Blockly.Connection} b Connection to check compatibility with.
+ * @param {boolean} isDragging True if the connection is being made by dragging
+ *     a block.
+ * @param {number=} opt_distance The max allowable distance between the
+ *     connections for drag checks.
+ * @return {number} Blockly.Connection.CAN_CONNECT if the connection is legal,
+ *    an error code otherwise.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.canConnectWithReason = function(
+    a, b, isDragging, opt_distance) {
+  var safety = this.doSafetyChecks(a, b);
+  if (safety != Blockly.Connection.CAN_CONNECT) {
+    return safety;
+  }
+
+  // If the safety checks passed, both connections are non-null.
+  var connOne = /** @type {!Blockly.Connection} **/ (a);
+  var connTwo = /** @type {!Blockly.Connection} **/ (b);
+  if (!this.doTypeChecks(connOne, connTwo)) {
+    return Blockly.Connection.REASON_CHECKS_FAILED;
+  }
+
+  if (isDragging &&
+      !this.doDragChecks(
+          /** @type {!Blockly.RenderedConnection} **/ (a),
+          /** @type {!Blockly.RenderedConnection} **/ (b),
+          opt_distance || 0)) {
+    return Blockly.Connection.REASON_DRAG_CHECKS_FAILED;
+  }
+
+  return Blockly.Connection.CAN_CONNECT;
+};
+
+/**
+ * Helper method that translates a connection error code into a string.
+ * @param {number} errorCode The error code.
+ * @param {Blockly.Connection} a One of the two connections being checked.
+ * @param {Blockly.Connection} b The second of the two connections being
+ *     checked.
+ * @return {string} A developer-readable error string.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.getErrorMessage = function(errorCode,
+    a, b) {
+  switch (errorCode) {
+    case Blockly.Connection.REASON_SELF_CONNECTION:
+      return 'Attempted to connect a block to itself.';
+    case Blockly.Connection.REASON_DIFFERENT_WORKSPACES:
+      // Usually this means one block has been deleted.
+      return 'Blocks not on same workspace.';
+    case Blockly.Connection.REASON_WRONG_TYPE:
+      return 'Attempt to connect incompatible types.';
+    case Blockly.Connection.REASON_TARGET_NULL:
+      return 'Target connection is null.';
+    case Blockly.Connection.REASON_CHECKS_FAILED:
+      var connOne = /** @type {!Blockly.Connection} **/ (a);
+      var connTwo = /** @type {!Blockly.Connection} **/ (b);
+      var msg = 'Connection checks failed. ';
+      msg += connOne + ' expected ' + connOne.getCheck() + ', found ' + connTwo.getCheck();
+      return msg;
+    case Blockly.Connection.REASON_SHADOW_PARENT:
+      return 'Connecting non-shadow to shadow block.';
+    case Blockly.Connection.REASON_DRAG_CHECKS_FAILED:
+      return 'Drag checks failed.';
+    default:
+      return 'Unknown connection failure: this should never happen!';
+  }
+};
+
+/**
+ * Check that connecting the given connections is safe, meaning that it would
+ * not break any of Blockly's basic assumptions (e.g. no self connections).
+ * @param {Blockly.Connection} a The first of the connections to check.
+ * @param {Blockly.Connection} b The second of the connections to check.
+ * @return {number} An enum with the reason this connection is safe or unsafe.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.doSafetyChecks = function(a, b) {
+  if (!a || !b) {
+    return Blockly.Connection.REASON_TARGET_NULL;
+  }
+  if (a.isSuperior()) {
+    var blockA = a.getSourceBlock();
+    var blockB = b.getSourceBlock();
+  } else {
+    var blockB = a.getSourceBlock();
+    var blockA = b.getSourceBlock();
+  }
+  if (blockA == blockB) {
+    return Blockly.Connection.REASON_SELF_CONNECTION;
+  } else if (b.type != Blockly.OPPOSITE_TYPE[a.type]) {
+    return Blockly.Connection.REASON_WRONG_TYPE;
+  } else if (blockA.workspace !== blockB.workspace) {
+    return Blockly.Connection.REASON_DIFFERENT_WORKSPACES;
+  } else if (blockA.isShadow() && !blockB.isShadow()) {
+    return Blockly.Connection.REASON_SHADOW_PARENT;
+  }
+  return Blockly.Connection.CAN_CONNECT;
+};
+
+/**
+ * Check whether this connection is compatible with another connection with
+ * respect to the value type system.  E.g. square_root("Hello") is not
+ * compatible.
+ * @param {!Blockly.Connection} a Connection to compare.
+ * @param {!Blockly.Connection} b Connection to compare against.
+ * @return {boolean} True if the connections share a type.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.doTypeChecks = function(a, b) {
+  var checkArrayOne = a.getCheck();
+  var checkArrayTwo = b.getCheck();
+
+  if (!checkArrayOne || !checkArrayTwo) {
+    // One or both sides are promiscuous enough that anything will fit.
+    return true;
+  }
+  // Find any intersection in the check lists.
+  for (var i = 0; i < checkArrayOne.length; i++) {
+    if (checkArrayTwo.indexOf(checkArrayOne[i]) != -1) {
+      return true;
+    }
+  }
+  // No intersection.
+  return false;
+};
+
+/**
+ * Check whether this connection can be made by dragging.
+ * @param {!Blockly.RenderedConnection} a Connection to compare.
+ * @param {!Blockly.RenderedConnection} b Connection to compare against.
+ * @param {number} distance The maximum allowable distance between connections.
+ * @return {boolean} True if the connection is allowed during a drag.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.doDragChecks = function(a, b, distance) {
+  if (a.distanceFrom(b) > distance) {
+    return false;
+  }
+
+  // Don't consider insertion markers.
+  if (b.getSourceBlock().isInsertionMarker()) {
+    return false;
+  }
+
+  switch (b.type) {
+    case Blockly.connectionTypes.PREVIOUS_STATEMENT:
+      return this.canConnectToPrevious_(a, b);
+    case Blockly.connectionTypes.OUTPUT_VALUE: {
+      // Don't offer to connect an already connected left (male) value plug to
+      // an available right (female) value plug.
+      if ((b.isConnected() &&
+          !b.targetBlock().isInsertionMarker()) ||
+          a.isConnected()) {
+        return false;
+      }
+      break;
+    }
+    case Blockly.connectionTypes.INPUT_VALUE: {
+      // Offering to connect the left (male) of a value block to an already
+      // connected value pair is ok, we'll splice it in.
+      // However, don't offer to splice into an immovable block.
+      if (b.isConnected() &&
+          !b.targetBlock().isMovable() &&
+          !b.targetBlock().isShadow()) {
+        return false;
+      }
+      break;
+    }
+    case Blockly.connectionTypes.NEXT_STATEMENT: {
+      // Don't let a block with no next connection bump other blocks out of the
+      // stack.  But covering up a shadow block or stack of shadow blocks is
+      // fine.  Similarly, replacing a terminal statement with another terminal
+      // statement is allowed.
+      if (b.isConnected() &&
+          !a.getSourceBlock().nextConnection &&
+          !b.targetBlock().isShadow() &&
+          b.targetBlock().nextConnection) {
+        return false;
+      }
+      break;
+    }
+    default:
+      // Unexpected connection type.
+      return false;
+  }
+
+  // Don't let blocks try to connect to themselves or ones they nest.
+  if (Blockly.draggingConnections.indexOf(b) != -1) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Helper function for drag checking.
+ * @param {!Blockly.Connection} a The connection to check, which must be a
+ *     statement input or next connection.
+ * @param {!Blockly.Connection} b A nearby connection to check, which
+ *     must be a previous connection.
+ * @return {boolean} True if the connection is allowed, false otherwise.
+ * @protected
+ */
+Blockly.ConnectionChecker.prototype.canConnectToPrevious_ = function(a, b) {
+  if (a.targetConnection) {
+    // This connection is already occupied.
+    // A next connection will never disconnect itself mid-drag.
+    return false;
+  }
+
+  // Don't let blocks try to connect to themselves or ones they nest.
+  if (Blockly.draggingConnections.indexOf(b) != -1) {
+    return false;
+  }
+
+  if (!b.targetConnection) {
+    return true;
+  }
+
+  var targetBlock = b.targetBlock();
+  // If it is connected to a real block, game over.
+  if (!targetBlock.isInsertionMarker()) {
+    return false;
+  }
+  // If it's connected to an insertion marker but that insertion marker
+  // is the first block in a stack, it's still fine.  If that insertion
+  // marker is in the middle of a stack, it won't work.
+  return !targetBlock.getPreviousBlock();
+};
+
+Blockly.registry.register(Blockly.registry.Type.CONNECTION_CHECKER,
+    Blockly.registry.DEFAULT, Blockly.ConnectionChecker);

blockly/core/connection_db.js

@@ -0,0 +1,303 @@
+/**
+ * @license
+ * Copyright 2011 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview A database of all the rendered connections that could
+ *    possibly be connected to (i.e. not collapsed, etc).
+ *    Sorted by y coordinate.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.ConnectionDB');
+
+goog.require('Blockly.connectionTypes');
+/** @suppress {extraRequire} */
+goog.require('Blockly.constants');
+goog.require('Blockly.RenderedConnection');
+
+goog.requireType('Blockly.IConnectionChecker');
+goog.requireType('Blockly.utils.Coordinate');
+
+
+/**
+ * Database of connections.
+ * Connections are stored in order of their vertical component.  This way
+ * connections in an area may be looked up quickly using a binary search.
+ * @param {!Blockly.IConnectionChecker} checker The workspace's
+ *     connection type checker, used to decide if connections are valid during a
+ *     drag.
+ * @constructor
+ */
+Blockly.ConnectionDB = function(checker) {
+  /**
+   * Array of connections sorted by y position in workspace units.
+   * @type {!Array<!Blockly.RenderedConnection>}
+   * @private
+   */
+  this.connections_ = [];
+  /**
+   * The workspace's connection type checker, used to decide if connections are
+   * valid during a drag.
+   * @type {!Blockly.IConnectionChecker}
+   * @private
+   */
+  this.connectionChecker_ = checker;
+};
+
+/**
+ * Add a connection to the database. Should not already exist in the database.
+ * @param {!Blockly.RenderedConnection} connection The connection to be added.
+ * @param {number} yPos The y position used to decide where to insert the
+ *    connection.
+ * @package
+ */
+Blockly.ConnectionDB.prototype.addConnection = function(connection, yPos) {
+  var index = this.calculateIndexForYPos_(yPos);
+  this.connections_.splice(index, 0, connection);
+};
+
+/**
+ * Finds the index of the given connection.
+ *
+ * Starts by doing a binary search to find the approximate location, then
+ * linearly searches nearby for the exact connection.
+ * @param {!Blockly.RenderedConnection} conn The connection to find.
+ * @param {number} yPos The y position used to find the index of the connection.
+ * @return {number} The index of the connection, or -1 if the connection was
+ *     not found.
+ * @private
+ */
+Blockly.ConnectionDB.prototype.findIndexOfConnection_ = function(conn, yPos) {
+  if (!this.connections_.length) {
+    return -1;
+  }
+
+  var bestGuess = this.calculateIndexForYPos_(yPos);
+  if (bestGuess >= this.connections_.length) {
+    // Not in list
+    return -1;
+  }
+
+  yPos = conn.y;
+  // Walk forward and back on the y axis looking for the connection.
+  var pointer = bestGuess;
+  while (pointer >= 0 && this.connections_[pointer].y == yPos) {
+    if (this.connections_[pointer] == conn) {
+      return pointer;
+    }
+    pointer--;
+  }
+
+  pointer = bestGuess;
+  while (pointer < this.connections_.length &&
+         this.connections_[pointer].y == yPos) {
+    if (this.connections_[pointer] == conn) {
+      return pointer;
+    }
+    pointer++;
+  }
+  return -1;
+};
+
+/**
+ * Finds the correct index for the given y position.
+ * @param {number} yPos The y position used to decide where to
+ *    insert the connection.
+ * @return {number} The candidate index.
+ * @private
+ */
+Blockly.ConnectionDB.prototype.calculateIndexForYPos_ = function(yPos) {
+  if (!this.connections_.length) {
+    return 0;
+  }
+  var pointerMin = 0;
+  var pointerMax = this.connections_.length;
+  while (pointerMin < pointerMax) {
+    var pointerMid = Math.floor((pointerMin + pointerMax) / 2);
+    if (this.connections_[pointerMid].y < yPos) {
+      pointerMin = pointerMid + 1;
+    } else if (this.connections_[pointerMid].y > yPos) {
+      pointerMax = pointerMid;
+    } else {
+      pointerMin = pointerMid;
+      break;
+    }
+  }
+  return pointerMin;
+};
+
+/**
+ * Remove a connection from the database.  Must already exist in DB.
+ * @param {!Blockly.RenderedConnection} connection The connection to be removed.
+ * @param {number} yPos The y position used to find the index of the connection.
+ * @throws {Error} If the connection cannot be found in the database.
+ */
+Blockly.ConnectionDB.prototype.removeConnection = function(connection, yPos) {
+  var index = this.findIndexOfConnection_(connection, yPos);
+  if (index == -1) {
+    throw Error('Unable to find connection in connectionDB.');
+  }
+  this.connections_.splice(index, 1);
+};
+
+/**
+ * Find all nearby connections to the given connection.
+ * Type checking does not apply, since this function is used for bumping.
+ * @param {!Blockly.RenderedConnection} connection The connection whose
+ *     neighbours should be returned.
+ * @param {number} maxRadius The maximum radius to another connection.
+ * @return {!Array<!Blockly.RenderedConnection>} List of connections.
+ */
+Blockly.ConnectionDB.prototype.getNeighbours = function(connection, maxRadius) {
+  var db = this.connections_;
+  var currentX = connection.x;
+  var currentY = connection.y;
+
+  // Binary search to find the closest y location.
+  var pointerMin = 0;
+  var pointerMax = db.length - 2;
+  var pointerMid = pointerMax;
+  while (pointerMin < pointerMid) {
+    if (db[pointerMid].y < currentY) {
+      pointerMin = pointerMid;
+    } else {
+      pointerMax = pointerMid;
+    }
+    pointerMid = Math.floor((pointerMin + pointerMax) / 2);
+  }
+
+  var neighbours = [];
+  /**
+   * Computes if the current connection is within the allowed radius of another
+   * connection.
+   * This function is a closure and has access to outside variables.
+   * @param {number} yIndex The other connection's index in the database.
+   * @return {boolean} True if the current connection's vertical distance from
+   *     the other connection is less than the allowed radius.
+   */
+  function checkConnection_(yIndex) {
+    var dx = currentX - db[yIndex].x;
+    var dy = currentY - db[yIndex].y;
+    var r = Math.sqrt(dx * dx + dy * dy);
+    if (r <= maxRadius) {
+      neighbours.push(db[yIndex]);
+    }
+    return dy < maxRadius;
+  }
+
+  // Walk forward and back on the y axis looking for the closest x,y point.
+  pointerMin = pointerMid;
+  pointerMax = pointerMid;
+  if (db.length) {
+    while (pointerMin >= 0 && checkConnection_(pointerMin)) {
+      pointerMin--;
+    }
+    do {
+      pointerMax++;
+    } while (pointerMax < db.length && checkConnection_(pointerMax));
+  }
+
+  return neighbours;
+};
+
+/**
+ * Is the candidate connection close to the reference connection.
+ * Extremely fast; only looks at Y distance.
+ * @param {number} index Index in database of candidate connection.
+ * @param {number} baseY Reference connection's Y value.
+ * @param {number} maxRadius The maximum radius to another connection.
+ * @return {boolean} True if connection is in range.
+ * @private
+ */
+Blockly.ConnectionDB.prototype.isInYRange_ = function(index, baseY, maxRadius) {
+  return (Math.abs(this.connections_[index].y - baseY) <= maxRadius);
+};
+
+/**
+ * Find the closest compatible connection to this connection.
+ * @param {!Blockly.RenderedConnection} conn The connection searching for a compatible
+ *     mate.
+ * @param {number} maxRadius The maximum radius to another connection.
+ * @param {!Blockly.utils.Coordinate} dxy Offset between this connection's
+ *     location in the database and the current location (as a result of
+ *     dragging).
+ * @return {!{connection: Blockly.RenderedConnection, radius: number}}
+ *     Contains two properties: 'connection' which is either another
+ *     connection or null, and 'radius' which is the distance.
+ */
+Blockly.ConnectionDB.prototype.searchForClosest = function(conn, maxRadius,
+    dxy) {
+  if (!this.connections_.length) {
+    // Don't bother.
+    return {connection: null, radius: maxRadius};
+  }
+
+  // Stash the values of x and y from before the drag.
+  var baseY = conn.y;
+  var baseX = conn.x;
+
+  conn.x = baseX + dxy.x;
+  conn.y = baseY + dxy.y;
+
+  // calculateIndexForYPos_ finds an index for insertion, which is always
+  // after any block with the same y index.  We want to search both forward
+  // and back, so search on both sides of the index.
+  var closestIndex = this.calculateIndexForYPos_(conn.y);
+
+  var bestConnection = null;
+  var bestRadius = maxRadius;
+  var temp;
+
+  // Walk forward and back on the y axis looking for the closest x,y point.
+  var pointerMin = closestIndex - 1;
+  while (pointerMin >= 0 && this.isInYRange_(pointerMin, conn.y, maxRadius)) {
+    temp = this.connections_[pointerMin];
+    if (this.connectionChecker_.canConnect(conn, temp, true, bestRadius)) {
+      bestConnection = temp;
+      bestRadius = temp.distanceFrom(conn);
+    }
+    pointerMin--;
+  }
+
+  var pointerMax = closestIndex;
+  while (pointerMax < this.connections_.length &&
+      this.isInYRange_(pointerMax, conn.y, maxRadius)) {
+    temp = this.connections_[pointerMax];
+    if (this.connectionChecker_.canConnect(conn, temp, true, bestRadius)) {
+      bestConnection = temp;
+      bestRadius = temp.distanceFrom(conn);
+    }
+    pointerMax++;
+  }
+
+  // Reset the values of x and y.
+  conn.x = baseX;
+  conn.y = baseY;
+
+  // If there were no valid connections, bestConnection will be null.
+  return {connection: bestConnection, radius: bestRadius};
+};
+
+/**
+ * Initialize a set of connection DBs for a workspace.
+ * @param {!Blockly.IConnectionChecker} checker The workspace's
+ *     connection checker, used to decide if connections are valid during a drag.
+ * @return {!Array<!Blockly.ConnectionDB>} Array of databases.
+ */
+Blockly.ConnectionDB.init = function(checker) {
+  // Create four databases, one for each connection type.
+  var dbList = [];
+  dbList[Blockly.connectionTypes.INPUT_VALUE] =
+      new Blockly.ConnectionDB(checker);
+  dbList[Blockly.connectionTypes.OUTPUT_VALUE] =
+      new Blockly.ConnectionDB(checker);
+  dbList[Blockly.connectionTypes.NEXT_STATEMENT] =
+      new Blockly.ConnectionDB(checker);
+  dbList[Blockly.connectionTypes.PREVIOUS_STATEMENT] =
+      new Blockly.ConnectionDB(checker);
+  return dbList;
+};

blockly/core/connection_types.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview An enum for the possible types of connections.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+
+'use strict';
+
+goog.provide('Blockly.connectionTypes');
+
+/**
+ * Enum for the type of a connection or input.
+ * @enum {number}
+ */
+Blockly.connectionTypes = {
+  // A right-facing value input.  E.g. 'set item to' or 'return'.
+  INPUT_VALUE: 1,
+  // A left-facing value output.  E.g. 'random fraction'.
+  OUTPUT_VALUE: 2,
+  // A down-facing block stack.  E.g. 'if-do' or 'else'.
+  NEXT_STATEMENT: 3,
+  // An up-facing block stack.  E.g. 'break out of loop'.
+  PREVIOUS_STATEMENT: 4
+};

blockly/core/constants.js

@@ -0,0 +1,213 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Blockly constants.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.constants');
+
+goog.require('Blockly.connectionTypes');
+
+
+/**
+ * The multiplier for scroll wheel deltas using the line delta mode.
+ * @type {number}
+ */
+Blockly.LINE_MODE_MULTIPLIER = 40;
+
+/**
+ * The multiplier for scroll wheel deltas using the page delta mode.
+ * @type {number}
+ */
+Blockly.PAGE_MODE_MULTIPLIER = 125;
+
+/**
+ * Number of pixels the mouse must move before a drag starts.
+ */
+Blockly.DRAG_RADIUS = 5;
+
+/**
+ * Number of pixels the mouse must move before a drag/scroll starts from the
+ * flyout.  Because the drag-intention is determined when this is reached, it is
+ * larger than Blockly.DRAG_RADIUS so that the drag-direction is clearer.
+ */
+Blockly.FLYOUT_DRAG_RADIUS = 10;
+
+/**
+ * Maximum misalignment between connections for them to snap together.
+ */
+Blockly.SNAP_RADIUS = 28;
+
+/**
+ * Maximum misalignment between connections for them to snap together,
+ * when a connection is already highlighted.
+ */
+Blockly.CONNECTING_SNAP_RADIUS = Blockly.SNAP_RADIUS;
+
+/**
+ * How much to prefer staying connected to the current connection over moving to
+ * a new connection.  The current previewed connection is considered to be this
+ * much closer to the matching connection on the block than it actually is.
+ */
+Blockly.CURRENT_CONNECTION_PREFERENCE = 8;
+
+/**
+ * Delay in ms between trigger and bumping unconnected block out of alignment.
+ */
+Blockly.BUMP_DELAY = 250;
+
+/**
+ * Maximum randomness in workspace units for bumping a block.
+ */
+Blockly.BUMP_RANDOMNESS = 10;
+
+/**
+ * Number of characters to truncate a collapsed block to.
+ */
+Blockly.COLLAPSE_CHARS = 30;
+
+/**
+ * Length in ms for a touch to become a long press.
+ */
+Blockly.LONGPRESS = 750;
+
+/**
+ * Prevent a sound from playing if another sound preceded it within this many
+ * milliseconds.
+ */
+Blockly.SOUND_LIMIT = 100;
+
+/**
+ * When dragging a block out of a stack, split the stack in two (true), or drag
+ * out the block healing the stack (false).
+ */
+Blockly.DRAG_STACK = true;
+
+/**
+ * The richness of block colours, regardless of the hue.
+ * Must be in the range of 0 (inclusive) to 1 (exclusive).
+ */
+Blockly.HSV_SATURATION = 0.45;
+
+/**
+ * The intensity of block colours, regardless of the hue.
+ * Must be in the range of 0 (inclusive) to 1 (exclusive).
+ */
+Blockly.HSV_VALUE = 0.65;
+
+/**
+ * Sprited icons and images.
+ */
+Blockly.SPRITE = {
+  width: 96,
+  height: 124,
+  url: 'sprites.png'
+};
+
+// Constants below this point are not intended to be changed.
+
+/**
+ * Enum for alignment of inputs.
+ * @enum {number}
+ */
+Blockly.constants.ALIGN = {
+  LEFT: -1,
+  CENTRE: 0,
+  RIGHT: 1
+};
+
+/**
+ * ENUM for no drag operation.
+ * @const
+ */
+Blockly.DRAG_NONE = 0;
+
+/**
+ * ENUM for inside the sticky DRAG_RADIUS.
+ * @const
+ */
+Blockly.DRAG_STICKY = 1;
+
+/**
+ * ENUM for inside the non-sticky DRAG_RADIUS, for differentiating between
+ * clicks and drags.
+ * @const
+ */
+Blockly.DRAG_BEGIN = 1;
+
+/**
+ * ENUM for freely draggable (outside the DRAG_RADIUS, if one applies).
+ * @const
+ */
+Blockly.DRAG_FREE = 2;
+
+/**
+ * Lookup table for determining the opposite type of a connection.
+ * @const
+ */
+Blockly.OPPOSITE_TYPE = [];
+Blockly.OPPOSITE_TYPE[Blockly.connectionTypes.INPUT_VALUE] =
+    Blockly.connectionTypes.OUTPUT_VALUE;
+Blockly.OPPOSITE_TYPE[Blockly.connectionTypes.OUTPUT_VALUE] =
+    Blockly.connectionTypes.INPUT_VALUE;
+Blockly.OPPOSITE_TYPE[Blockly.connectionTypes.NEXT_STATEMENT] =
+    Blockly.connectionTypes.PREVIOUS_STATEMENT;
+Blockly.OPPOSITE_TYPE[Blockly.connectionTypes.PREVIOUS_STATEMENT] =
+    Blockly.connectionTypes.NEXT_STATEMENT;
+
+/**
+ * String for use in the "custom" attribute of a category in toolbox XML.
+ * This string indicates that the category should be dynamically populated with
+ * variable blocks.
+ * @const {string}
+ */
+Blockly.VARIABLE_CATEGORY_NAME = 'VARIABLE';
+/**
+ * String for use in the "custom" attribute of a category in toolbox XML.
+ * This string indicates that the category should be dynamically populated with
+ * variable blocks.
+ * @const {string}
+ */
+Blockly.VARIABLE_DYNAMIC_CATEGORY_NAME = 'VARIABLE_DYNAMIC';
+
+/**
+ * String for use in the "custom" attribute of a category in toolbox XML.
+ * This string indicates that the category should be dynamically populated with
+ * procedure blocks.
+ * @const {string}
+ */
+Blockly.PROCEDURE_CATEGORY_NAME = 'PROCEDURE';
+
+/**
+ * String for use in the dropdown created in field_variable.
+ * This string indicates that this option in the dropdown is 'Rename
+ * variable...' and if selected, should trigger the prompt to rename a variable.
+ * @const {string}
+ */
+Blockly.RENAME_VARIABLE_ID = 'RENAME_VARIABLE_ID';
+
+/**
+ * String for use in the dropdown created in field_variable.
+ * This string indicates that this option in the dropdown is 'Delete the "%1"
+ * variable' and if selected, should trigger the prompt to delete a variable.
+ * @const {string}
+ */
+Blockly.DELETE_VARIABLE_ID = 'DELETE_VARIABLE_ID';
+
+/**
+ * The language-neutral ID given to the collapsed input.
+ * @const {string}
+ */
+Blockly.constants.COLLAPSED_INPUT_NAME = '_TEMP_COLLAPSED_INPUT';
+
+/**
+ * The language-neutral ID given to the collapsed field.
+ * @const {string}
+ */
+Blockly.constants.COLLAPSED_FIELD_NAME = '_TEMP_COLLAPSED_FIELD';

blockly/core/contextmenu.js

@@ -0,0 +1,318 @@
+/**
+ * @license
+ * Copyright 2011 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Functionality for the right-click context menus.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+/**
+ * @name Blockly.ContextMenu
+ * @namespace
+ */
+goog.provide('Blockly.ContextMenu');
+
+goog.require('Blockly.browserEvents');
+/** @suppress {extraRequire} */
+goog.require('Blockly.constants');
+goog.require('Blockly.Events');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BlockCreate');
+goog.require('Blockly.Menu');
+goog.require('Blockly.MenuItem');
+goog.require('Blockly.Msg');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.aria');
+goog.require('Blockly.utils.Coordinate');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.Rect');
+goog.require('Blockly.utils.userAgent');
+goog.require('Blockly.WidgetDiv');
+goog.require('Blockly.Xml');
+
+goog.requireType('Blockly.Block');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Which block is the context menu attached to?
+ * @type {Blockly.Block}
+ */
+Blockly.ContextMenu.currentBlock = null;
+
+/**
+ * Menu object.
+ * @type {Blockly.Menu}
+ * @private
+ */
+Blockly.ContextMenu.menu_ = null;
+
+/**
+ * Construct the menu based on the list of options and show the menu.
+ * @param {!Event} e Mouse event.
+ * @param {!Array<!Object>} options Array of menu options.
+ * @param {boolean} rtl True if RTL, false if LTR.
+ */
+Blockly.ContextMenu.show = function(e, options, rtl) {
+  Blockly.WidgetDiv.show(Blockly.ContextMenu, rtl, Blockly.ContextMenu.dispose);
+  if (!options.length) {
+    Blockly.ContextMenu.hide();
+    return;
+  }
+  var menu = Blockly.ContextMenu.populate_(options, rtl);
+  Blockly.ContextMenu.menu_ = menu;
+
+  Blockly.ContextMenu.position_(menu, e, rtl);
+  // 1ms delay is required for focusing on context menus because some other
+  // mouse event is still waiting in the queue and clears focus.
+  setTimeout(function() {menu.focus();}, 1);
+  Blockly.ContextMenu.currentBlock = null;  // May be set by Blockly.Block.
+};
+
+/**
+ * Create the context menu object and populate it with the given options.
+ * @param {!Array<!Object>} options Array of menu options.
+ * @param {boolean} rtl True if RTL, false if LTR.
+ * @return {!Blockly.Menu} The menu that will be shown on right click.
+ * @private
+ */
+Blockly.ContextMenu.populate_ = function(options, rtl) {
+  /* Here's what one option object looks like:
+    {text: 'Make It So',
+     enabled: true,
+     callback: Blockly.MakeItSo}
+  */
+  var menu = new Blockly.Menu();
+  menu.setRole(Blockly.utils.aria.Role.MENU);
+  for (var i = 0, option; (option = options[i]); i++) {
+    var menuItem = new Blockly.MenuItem(option.text);
+    menuItem.setRightToLeft(rtl);
+    menuItem.setRole(Blockly.utils.aria.Role.MENUITEM);
+    menu.addChild(menuItem);
+    menuItem.setEnabled(option.enabled);
+    if (option.enabled) {
+      var actionHandler = function(_menuItem) {
+        var option = this;
+        Blockly.ContextMenu.hide();
+        option.callback(option.scope);
+      };
+      menuItem.onAction(actionHandler, option);
+    }
+  }
+  return menu;
+};
+
+/**
+ * Add the menu to the page and position it correctly.
+ * @param {!Blockly.Menu} menu The menu to add and position.
+ * @param {!Event} e Mouse event for the right click that is making the context
+ *     menu appear.
+ * @param {boolean} rtl True if RTL, false if LTR.
+ * @private
+ */
+Blockly.ContextMenu.position_ = function(menu, e, rtl) {
+  // Record windowSize and scrollOffset before adding menu.
+  var viewportBBox = Blockly.utils.getViewportBBox();
+  // This one is just a point, but we'll pretend that it's a rect so we can use
+  // some helper functions.
+  var anchorBBox = new Blockly.utils.Rect(
+      e.clientY + viewportBBox.top,
+      e.clientY + viewportBBox.top,
+      e.clientX + viewportBBox.left,
+      e.clientX + viewportBBox.left
+  );
+
+  Blockly.ContextMenu.createWidget_(menu);
+  var menuSize = menu.getSize();
+
+  if (rtl) {
+    anchorBBox.left += menuSize.width;
+    anchorBBox.right += menuSize.width;
+    viewportBBox.left += menuSize.width;
+    viewportBBox.right += menuSize.width;
+  }
+
+  Blockly.WidgetDiv.positionWithAnchor(viewportBBox, anchorBBox, menuSize, rtl);
+  // Calling menuDom.focus() has to wait until after the menu has been placed
+  // correctly.  Otherwise it will cause a page scroll to get the misplaced menu
+  // in view.  See issue #1329.
+  menu.focus();
+};
+
+/**
+ * Create and render the menu widget inside Blockly's widget div.
+ * @param {!Blockly.Menu} menu The menu to add to the widget div.
+ * @private
+ */
+Blockly.ContextMenu.createWidget_ = function(menu) {
+  var div = Blockly.WidgetDiv.DIV;
+  menu.render(div);
+  var menuDom = menu.getElement();
+  Blockly.utils.dom.addClass(
+      /** @type {!Element} */ (menuDom), 'blocklyContextMenu');
+  // Prevent system context menu when right-clicking a Blockly context menu.
+  Blockly.browserEvents.conditionalBind(
+      /** @type {!EventTarget} */ (menuDom), 'contextmenu', null,
+      Blockly.utils.noEvent);
+  // Focus only after the initial render to avoid issue #1329.
+  menu.focus();
+};
+
+/**
+ * Hide the context menu.
+ */
+Blockly.ContextMenu.hide = function() {
+  Blockly.WidgetDiv.hideIfOwner(Blockly.ContextMenu);
+  Blockly.ContextMenu.currentBlock = null;
+};
+
+/**
+ * Dispose of the menu.
+ */
+Blockly.ContextMenu.dispose = function() {
+  if (Blockly.ContextMenu.menu_) {
+    Blockly.ContextMenu.menu_.dispose();
+    Blockly.ContextMenu.menu_ = null;
+  }
+};
+
+/**
+ * Create a callback function that creates and configures a block,
+ *   then places the new block next to the original.
+ * @param {!Blockly.Block} block Original block.
+ * @param {!Element} xml XML representation of new block.
+ * @return {!Function} Function that creates a block.
+ */
+Blockly.ContextMenu.callbackFactory = function(block, xml) {
+  return function() {
+    Blockly.Events.disable();
+    try {
+      var newBlock = Blockly.Xml.domToBlock(xml, block.workspace);
+      // Move the new block next to the old block.
+      var xy = block.getRelativeToSurfaceXY();
+      if (block.RTL) {
+        xy.x -= Blockly.SNAP_RADIUS;
+      } else {
+        xy.x += Blockly.SNAP_RADIUS;
+      }
+      xy.y += Blockly.SNAP_RADIUS * 2;
+      newBlock.moveBy(xy.x, xy.y);
+    } finally {
+      Blockly.Events.enable();
+    }
+    if (Blockly.Events.isEnabled() && !newBlock.isShadow()) {
+      Blockly.Events.fire(
+          new (Blockly.Events.get(Blockly.Events.BLOCK_CREATE))(newBlock));
+    }
+    newBlock.select();
+  };
+};
+
+// Helper functions for creating context menu options.
+
+/**
+ * Make a context menu option for deleting the current workspace comment.
+ * @param {!Blockly.WorkspaceCommentSvg} comment The workspace comment where the
+ *     right-click originated.
+ * @return {!Object} A menu option, containing text, enabled, and a callback.
+ * @package
+ */
+Blockly.ContextMenu.commentDeleteOption = function(comment) {
+  var deleteOption = {
+    text: Blockly.Msg['REMOVE_COMMENT'],
+    enabled: true,
+    callback: function() {
+      Blockly.Events.setGroup(true);
+      comment.dispose(true, true);
+      Blockly.Events.setGroup(false);
+    }
+  };
+  return deleteOption;
+};
+
+/**
+ * Make a context menu option for duplicating the current workspace comment.
+ * @param {!Blockly.WorkspaceCommentSvg} comment The workspace comment where the
+ *     right-click originated.
+ * @return {!Object} A menu option, containing text, enabled, and a callback.
+ * @package
+ */
+Blockly.ContextMenu.commentDuplicateOption = function(comment) {
+  var duplicateOption = {
+    text: Blockly.Msg['DUPLICATE_COMMENT'],
+    enabled: true,
+    callback: function() {
+      Blockly.duplicate(comment);
+    }
+  };
+  return duplicateOption;
+};
+
+/**
+ * Make a context menu option for adding a comment on the workspace.
+ * @param {!Blockly.WorkspaceSvg} ws The workspace where the right-click
+ *     originated.
+ * @param {!Event} e The right-click mouse event.
+ * @return {!Object} A menu option, containing text, enabled, and a callback.
+ * @package
+ * @suppress {strictModuleDepCheck,checkTypes} Suppress checks while workspace
+ *     comments are not bundled in.
+ */
+Blockly.ContextMenu.workspaceCommentOption = function(ws, e) {
+  if (!Blockly.WorkspaceCommentSvg) {
+    throw Error('Missing require for Blockly.WorkspaceCommentSvg');
+  }
+  // Helper function to create and position a comment correctly based on the
+  // location of the mouse event.
+  var addWsComment = function() {
+    var comment = new Blockly.WorkspaceCommentSvg(
+        ws, Blockly.Msg['WORKSPACE_COMMENT_DEFAULT_TEXT'],
+        Blockly.WorkspaceCommentSvg.DEFAULT_SIZE,
+        Blockly.WorkspaceCommentSvg.DEFAULT_SIZE);
+
+    var injectionDiv = ws.getInjectionDiv();
+    // Bounding rect coordinates are in client coordinates, meaning that they
+    // are in pixels relative to the upper left corner of the visible browser
+    // window.  These coordinates change when you scroll the browser window.
+    var boundingRect = injectionDiv.getBoundingClientRect();
+
+    // The client coordinates offset by the injection div's upper left corner.
+    var clientOffsetPixels = new Blockly.utils.Coordinate(
+        e.clientX - boundingRect.left, e.clientY - boundingRect.top);
+
+    // The offset in pixels between the main workspace's origin and the upper
+    // left corner of the injection div.
+    var mainOffsetPixels = ws.getOriginOffsetInPixels();
+
+    // The position of the new comment in pixels relative to the origin of the
+    // main workspace.
+    var finalOffset = Blockly.utils.Coordinate.difference(clientOffsetPixels,
+        mainOffsetPixels);
+    // The position of the new comment in main workspace coordinates.
+    finalOffset.scale(1 / ws.scale);
+
+    var commentX = finalOffset.x;
+    var commentY = finalOffset.y;
+    comment.moveBy(commentX, commentY);
+    if (ws.rendered) {
+      comment.initSvg();
+      comment.render();
+      comment.select();
+    }
+  };
+
+  var wsCommentOption = {
+    // Foreign objects don't work in IE.  Don't let the user create comments
+    // that they won't be able to edit.
+    enabled: !Blockly.utils.userAgent.IE
+  };
+  wsCommentOption.text = Blockly.Msg['ADD_COMMENT'];
+  wsCommentOption.callback = function() {
+    addWsComment();
+  };
+  return wsCommentOption;
+};

blockly/core/contextmenu_items.js

@@ -0,0 +1,542 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Registers default context menu items.
+ * @author maribethb@google.com (Maribeth Bottorff)
+ */
+'use strict';
+
+/**
+ * @name Blockly.ContextMenuItems
+ * @namespace
+ */
+goog.provide('Blockly.ContextMenuItems');
+
+/** @suppress {extraRequire} */
+goog.require('Blockly.constants');
+goog.require('Blockly.ContextMenuRegistry');
+goog.require('Blockly.Events');
+goog.require('Blockly.inputTypes');
+
+goog.requireType('Blockly.BlockSvg');
+
+
+/** Option to undo previous action. */
+Blockly.ContextMenuItems.registerUndo = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var undoOption = {
+    displayText: function() {
+      return Blockly.Msg['UNDO'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (scope.workspace.getUndoStack().length > 0) {
+        return 'enabled';
+      }
+      return 'disabled';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      scope.workspace.undo(false);
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.WORKSPACE,
+    id: 'undoWorkspace',
+    weight: 1,
+  };
+  Blockly.ContextMenuRegistry.registry.register(undoOption);
+};
+
+/** Option to redo previous action. */
+Blockly.ContextMenuItems.registerRedo = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var redoOption = {
+    displayText: function() { return Blockly.Msg['REDO']; },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (scope.workspace.getRedoStack().length > 0) {
+        return 'enabled';
+      }
+      return 'disabled';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      scope.workspace.undo(true);
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.WORKSPACE,
+    id: 'redoWorkspace',
+    weight: 2,
+  };
+  Blockly.ContextMenuRegistry.registry.register(redoOption);
+};
+
+/** Option to clean up blocks. */
+Blockly.ContextMenuItems.registerCleanup = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var cleanOption = {
+    displayText: function() {
+      return Blockly.Msg['CLEAN_UP'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (scope.workspace.isMovable()) {
+        if (scope.workspace.getTopBlocks(false).length > 1) {
+          return 'enabled';
+        }
+        return 'disabled';
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      scope.workspace.cleanUp();
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.WORKSPACE,
+    id: 'cleanWorkspace',
+    weight: 3,
+  };
+  Blockly.ContextMenuRegistry.registry.register(cleanOption);
+};
+
+/**
+ * Creates a callback to collapse or expand top blocks.
+ * @param {boolean} shouldCollapse Whether a block should collapse.
+ * @param {!Array<Blockly.BlockSvg>} topBlocks Top blocks in the workspace.
+ * @private
+ */
+Blockly.ContextMenuItems.toggleOption_ = function(shouldCollapse, topBlocks) {
+  var DELAY = 10;
+  var ms = 0;
+  for (var i = 0; i < topBlocks.length; i++) {
+    var block = topBlocks[i];
+    while (block) {
+      setTimeout(block.setCollapsed.bind(block, shouldCollapse), ms);
+      block = block.getNextBlock();
+      ms += DELAY;
+    }
+  }
+};
+
+/** Option to collapse all blocks. */
+Blockly.ContextMenuItems.registerCollapse = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var collapseOption = {
+    displayText:  function() {
+      return Blockly.Msg['COLLAPSE_ALL'];
+    },
+    preconditionFn:  function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (scope.workspace.options.collapse) {
+        var topBlocks = scope.workspace.getTopBlocks(false);
+        for (var i = 0; i < topBlocks.length; i++) {
+          var block = topBlocks[i];
+          while (block) {
+            if (!block.isCollapsed()) {
+              return 'enabled';
+            }
+            block = block.getNextBlock();
+          }
+        }
+        return 'disabled';
+      }
+      return 'hidden';
+    },
+    callback:  function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      Blockly.ContextMenuItems.toggleOption_(true, scope.workspace.getTopBlocks(true));
+    },
+    scopeType:  Blockly.ContextMenuRegistry.ScopeType.WORKSPACE,
+    id:  'collapseWorkspace',
+    weight:  4,
+  };
+  Blockly.ContextMenuRegistry.registry.register(collapseOption);
+};
+
+/** Option to expand all blocks. */
+Blockly.ContextMenuItems.registerExpand = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var expandOption = {
+    displayText: function() {
+      return Blockly.Msg['EXPAND_ALL'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (scope.workspace.options.collapse) {
+        var topBlocks = scope.workspace.getTopBlocks(false);
+        for (var i = 0; i < topBlocks.length; i++) {
+          var block = topBlocks[i];
+          while (block) {
+            if (block.isCollapsed()) {
+              return 'enabled';
+            }
+            block = block.getNextBlock();
+          }
+        }
+        return 'disabled';
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      Blockly.ContextMenuItems.toggleOption_(false, scope.workspace.getTopBlocks(true));
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.WORKSPACE,
+    id: 'expandWorkspace',
+    weight: 5,
+  };
+  Blockly.ContextMenuRegistry.registry.register(expandOption);
+};
+
+/**
+ * Adds a block and its children to a list of deletable blocks.
+ * @param {!Blockly.BlockSvg} block to delete.
+ * @param {!Array<!Blockly.BlockSvg>} deleteList list of blocks that can be deleted. This will be
+ *    modifed in place with the given block and its descendants.
+ * @private
+ */
+Blockly.ContextMenuItems.addDeletableBlocks_ = function(block, deleteList) {
+  if (block.isDeletable()) {
+    Array.prototype.push.apply(deleteList, block.getDescendants(false));
+  } else {
+    var children = /** @type !Array<!Blockly.BlockSvg> */ (block.getChildren(false));
+    for (var i = 0; i < children.length; i++) {
+      Blockly.ContextMenuItems.addDeletableBlocks_(children[i], deleteList);
+    }
+  }
+};
+
+/**
+ * Constructs a list of blocks that can be deleted in the given workspace.
+ * @param {!Blockly.WorkspaceSvg} workspace to delete all blocks from.
+ * @return {!Array<!Blockly.BlockSvg>} list of blocks to delete.
+ * @private
+ */
+Blockly.ContextMenuItems.getDeletableBlocks_ = function(workspace) {
+  var deleteList = [];
+  var topBlocks = workspace.getTopBlocks(true);
+  for (var i = 0; i < topBlocks.length; i++) {
+    Blockly.ContextMenuItems.addDeletableBlocks_(topBlocks[i], deleteList);
+  }
+  return deleteList;
+};
+
+/** Deletes the given blocks. Used to delete all blocks in the workspace.
+ * @param {!Array<!Blockly.BlockSvg>} deleteList list of blocks to delete.
+ * @param {string} eventGroup event group ID with which all delete events should be associated.
+ * @private
+ */
+Blockly.ContextMenuItems.deleteNext_ = function(deleteList, eventGroup) {
+  var DELAY = 10;
+  Blockly.Events.setGroup(eventGroup);
+  var block = deleteList.shift();
+  if (block) {
+    if (block.workspace) {
+      block.dispose(false, true);
+      setTimeout(Blockly.ContextMenuItems.deleteNext_, DELAY, deleteList, eventGroup);
+    } else {
+      Blockly.ContextMenuItems.deleteNext_(deleteList, eventGroup);
+    }
+  }
+  Blockly.Events.setGroup(false);
+};
+
+/** Option to delete all blocks. */
+Blockly.ContextMenuItems.registerDeleteAll = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var deleteOption = {
+    displayText: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (!scope.workspace) {
+        return;
+      }
+      var deletableBlocksLength =
+          Blockly.ContextMenuItems.getDeletableBlocks_(scope.workspace).length;
+      if (deletableBlocksLength == 1) {
+        return Blockly.Msg['DELETE_BLOCK'];
+      } else {
+        return Blockly.Msg['DELETE_X_BLOCKS'].replace('%1', String(deletableBlocksLength));
+      }
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (!scope.workspace) {
+        return;
+      }
+      var deletableBlocksLength =
+         Blockly.ContextMenuItems.getDeletableBlocks_(scope.workspace).length;
+      return deletableBlocksLength > 0 ? 'enabled' : 'disabled';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (!scope.workspace) {
+        return;
+      }
+      scope.workspace.cancelCurrentGesture();
+      var deletableBlocks = Blockly.ContextMenuItems.getDeletableBlocks_(scope.workspace);
+      var eventGroup = Blockly.utils.genUid();
+      if (deletableBlocks.length < 2) {
+        Blockly.ContextMenuItems.deleteNext_(deletableBlocks, eventGroup);
+      } else {
+        Blockly.confirm(
+            Blockly.Msg['DELETE_ALL_BLOCKS'].replace('%1', deletableBlocks.length),
+            function(ok) {
+              if (ok) {
+                Blockly.ContextMenuItems.deleteNext_(deletableBlocks, eventGroup);
+              }
+            });
+      }
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.WORKSPACE,
+    id: 'workspaceDelete',
+    weight: 6,
+  };
+  Blockly.ContextMenuRegistry.registry.register(deleteOption);
+};
+
+/**
+ * Registers all workspace-scoped context menu items.
+ * @private
+ */
+Blockly.ContextMenuItems.registerWorkspaceOptions_ = function() {
+  Blockly.ContextMenuItems.registerUndo();
+  Blockly.ContextMenuItems.registerRedo();
+  Blockly.ContextMenuItems.registerCleanup();
+  Blockly.ContextMenuItems.registerCollapse();
+  Blockly.ContextMenuItems.registerExpand();
+  Blockly.ContextMenuItems.registerDeleteAll();
+};
+
+/** Option to duplicate a block. */
+Blockly.ContextMenuItems.registerDuplicate = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var duplicateOption = {
+    displayText: function() {
+      return Blockly.Msg['DUPLICATE_BLOCK'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      if (!block.isInFlyout && block.isDeletable() && block.isMovable()) {
+        if (block.isDuplicatable()) {
+          return 'enabled';
+        }
+        return 'disabled';
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (scope.block) {
+        Blockly.duplicate(scope.block);
+      }
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.BLOCK,
+    id: 'blockDuplicate',
+    weight: 1,
+  };
+  Blockly.ContextMenuRegistry.registry.register(duplicateOption);
+};
+
+/** Option to add or remove block-level comment. */
+Blockly.ContextMenuItems.registerComment = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var commentOption = {
+    displayText: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (scope.block.getCommentIcon()) {
+        // If there's already a comment,  option is to remove.
+        return Blockly.Msg['REMOVE_COMMENT'];
+      }
+      // If there's no comment yet, option is to add.
+      return Blockly.Msg['ADD_COMMENT'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      // IE doesn't support necessary features for comment editing.
+      if (!Blockly.utils.userAgent.IE && !block.isInFlyout && block.workspace.options.comments &&
+        !block.isCollapsed() && block.isEditable()) {
+        return 'enabled';
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      if (block.getCommentIcon()) {
+        block.setCommentText(null);
+      } else {
+        block.setCommentText('');
+      }
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.BLOCK,
+    id: 'blockComment',
+    weight: 2,
+  };
+  Blockly.ContextMenuRegistry.registry.register(commentOption);
+};
+
+/** Option to inline variables. */
+Blockly.ContextMenuItems.registerInline = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var inlineOption = {
+    displayText: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      return (scope.block.getInputsInline()) ?
+          Blockly.Msg['EXTERNAL_INPUTS'] : Blockly.Msg['INLINE_INPUTS'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      if (!block.isInFlyout && block.isMovable() && !block.isCollapsed()) {
+        for (var i = 1; i < block.inputList.length; i++) {
+          // Only display this option if there are two value or dummy inputs next to each other.
+          if (block.inputList[i - 1].type != Blockly.inputTypes.STATEMENT &&
+              block.inputList[i].type != Blockly.inputTypes.STATEMENT) {
+            return 'enabled';
+          }
+        }
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      scope.block.setInputsInline(!scope.block.getInputsInline());
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.BLOCK,
+    id: 'blockInline',
+    weight: 3,
+  };
+  Blockly.ContextMenuRegistry.registry.register(inlineOption);
+};
+
+/** Option to collapse or expand a block. */
+Blockly.ContextMenuItems.registerCollapseExpandBlock = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var collapseExpandOption = {
+    displayText: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      return scope.block.isCollapsed() ?
+          Blockly.Msg['EXPAND_BLOCK'] : Blockly.Msg['COLLAPSE_BLOCK'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      if (!block.isInFlyout && block.isMovable() && block.workspace.options.collapse) {
+        return 'enabled';
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      scope.block.setCollapsed(!scope.block.isCollapsed());
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.BLOCK,
+    id: 'blockCollapseExpand',
+    weight: 4,
+  };
+  Blockly.ContextMenuRegistry.registry.register(collapseExpandOption);
+};
+
+/** Option to disable or enable a block. */
+Blockly.ContextMenuItems.registerDisable = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var disableOption = {
+    displayText: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      return (scope.block.isEnabled()) ?
+          Blockly.Msg['DISABLE_BLOCK'] : Blockly.Msg['ENABLE_BLOCK'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      if (!block.isInFlyout && block.workspace.options.disable && block.isEditable()) {
+        if (block.getInheritedDisabled()) {
+          return 'disabled';
+        }
+        return 'enabled';
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      var group = Blockly.Events.getGroup();
+      if (!group) {
+        Blockly.Events.setGroup(true);
+      }
+      block.setEnabled(!block.isEnabled());
+      if (!group) {
+        Blockly.Events.setGroup(false);
+      }
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.BLOCK,
+    id: 'blockDisable',
+    weight: 5,
+  };
+  Blockly.ContextMenuRegistry.registry.register(disableOption);
+};
+
+/** Option to delete a block. */
+Blockly.ContextMenuItems.registerDelete = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var deleteOption = {
+    displayText: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      // Count the number of blocks that are nested in this block.
+      var descendantCount = block.getDescendants(false).length;
+      var nextBlock = block.getNextBlock();
+      if (nextBlock) {
+        // Blocks in the current stack would survive this block's deletion.
+        descendantCount -= nextBlock.getDescendants(false).length;
+      }
+      return (descendantCount == 1) ? Blockly.Msg['DELETE_BLOCK'] :
+          Blockly.Msg['DELETE_X_BLOCKS'].replace('%1', String(descendantCount));
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      if (!scope.block.isInFlyout && scope.block.isDeletable()) {
+        return 'enabled';
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      Blockly.Events.setGroup(true);
+      if (scope.block) {
+        Blockly.deleteBlock(scope.block);
+      }
+      Blockly.Events.setGroup(false);
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.BLOCK,
+    id: 'blockDelete',
+    weight: 6,
+  };
+  Blockly.ContextMenuRegistry.registry.register(deleteOption);
+};
+
+/** Option to open help for a block. */
+Blockly.ContextMenuItems.registerHelp = function() {
+  /** @type {!Blockly.ContextMenuRegistry.RegistryItem} */
+  var helpOption = {
+    displayText: function() {
+      return Blockly.Msg['HELP'];
+    },
+    preconditionFn: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      var block = scope.block;
+      var url = (typeof block.helpUrl == 'function') ?
+          block.helpUrl() : block.helpUrl;
+      if (url) {
+        return 'enabled';
+      }
+      return 'hidden';
+    },
+    callback: function(/** @type {!Blockly.ContextMenuRegistry.Scope} */ scope) {
+      scope.block.showHelp();
+    },
+    scopeType: Blockly.ContextMenuRegistry.ScopeType.BLOCK,
+    id: 'blockHelp',
+    weight: 7,
+  };
+  Blockly.ContextMenuRegistry.registry.register(helpOption);
+};
+
+/**
+ * Registers all block-scoped context menu items.
+ * @private
+ */
+Blockly.ContextMenuItems.registerBlockOptions_ = function() {
+  Blockly.ContextMenuItems.registerDuplicate();
+  Blockly.ContextMenuItems.registerComment();
+  Blockly.ContextMenuItems.registerInline();
+  Blockly.ContextMenuItems.registerCollapseExpandBlock();
+  Blockly.ContextMenuItems.registerDisable();
+  Blockly.ContextMenuItems.registerDelete();
+  Blockly.ContextMenuItems.registerHelp();
+};
+
+/**
+ * Registers all default context menu items. This should be called once per instance of
+ * ContextMenuRegistry.
+ * @package
+ */
+Blockly.ContextMenuItems.registerDefaultOptions = function() {
+  Blockly.ContextMenuItems.registerWorkspaceOptions_();
+  Blockly.ContextMenuItems.registerBlockOptions_();
+};
+
+Blockly.ContextMenuItems.registerDefaultOptions();

blockly/core/contextmenu_registry.js

@@ -0,0 +1,163 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Registry for context menu option items.
+ * @author maribethb@google.com (Maribeth Bottorff)
+ */
+'use strict';
+
+/**
+ * @name Blockly.ContextMenuRegistry
+ * @namespace
+ */
+goog.provide('Blockly.ContextMenuRegistry');
+
+goog.requireType('Blockly.BlockSvg');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Class for the registry of context menu items. This is intended to be a
+ * singleton. You should not create a new instance, and only access this class
+ * from Blockly.ContextMenuRegistry.registry.
+ * @constructor
+ */
+Blockly.ContextMenuRegistry = function() {
+  // Singleton instance should be registered once.
+  Blockly.ContextMenuRegistry.registry = this;
+
+  /**
+   * Registry of all registered RegistryItems, keyed by ID.
+   * @type {!Object<string, !Blockly.ContextMenuRegistry.RegistryItem>}
+   * @private
+   */
+  this.registry_ = Object.create(null);
+};
+
+/**
+ * Where this menu item should be rendered. If the menu item should be rendered in multiple
+ * scopes, e.g. on both a block and a workspace, it should be registered for each scope.
+ * @enum {string}
+ */
+Blockly.ContextMenuRegistry.ScopeType = {
+  BLOCK: 'block',
+  WORKSPACE: 'workspace',
+};
+
+/**
+ * The actual workspace/block where the menu is being rendered. This is passed to callback and
+ * displayText functions that depend on this information.
+ * @typedef {{
+ *    block: (Blockly.BlockSvg|undefined),
+ *    workspace: (Blockly.WorkspaceSvg|undefined)
+ * }}
+ */
+Blockly.ContextMenuRegistry.Scope;
+
+/**
+ * A menu item as entered in the registry.
+ * @typedef {{
+ *    callback: function(!Blockly.ContextMenuRegistry.Scope),
+ *    scopeType: !Blockly.ContextMenuRegistry.ScopeType,
+ *    displayText: ((function(!Blockly.ContextMenuRegistry.Scope):string)|string),
+ *    preconditionFn: function(!Blockly.ContextMenuRegistry.Scope):string,
+ *    weight: number,
+ *    id: string
+ * }}
+*/
+Blockly.ContextMenuRegistry.RegistryItem;
+
+/**
+ * A menu item as presented to contextmenu.js.
+ * @typedef {{
+ *    text: string,
+ *    enabled: boolean,
+ *    callback: function(!Blockly.ContextMenuRegistry.Scope),
+ *    scope: !Blockly.ContextMenuRegistry.Scope,
+ *    weight: number
+ * }}
+ */
+Blockly.ContextMenuRegistry.ContextMenuOption;
+
+/**
+ * Singleton instance of this class. All interactions with this class should be
+ * done on this object.
+ * @type {?Blockly.ContextMenuRegistry}
+ */
+Blockly.ContextMenuRegistry.registry = null;
+
+/**
+ * Registers a RegistryItem.
+ * @param {!Blockly.ContextMenuRegistry.RegistryItem} item Context menu item to register.
+ * @throws {Error} if an item with the given ID already exists.
+ */
+Blockly.ContextMenuRegistry.prototype.register = function(item) {
+  if (this.registry_[item.id]) {
+    throw Error('Menu item with ID "' + item.id + '" is already registered.');
+  }
+  this.registry_[item.id] = item;
+};
+
+/**
+ * Unregisters a RegistryItem with the given ID.
+ * @param {string} id The ID of the RegistryItem to remove.
+ * @throws {Error} if an item with the given ID does not exist.
+ */
+Blockly.ContextMenuRegistry.prototype.unregister = function(id) {
+  if (!this.registry_[id]) {
+    throw new Error('Menu item with ID "' + id + '" not found.');
+  }
+  delete this.registry_[id];
+};
+
+/**
+ * @param {string} id The ID of the RegistryItem to get.
+ * @return {?Blockly.ContextMenuRegistry.RegistryItem} RegistryItem or null if not found
+ */
+Blockly.ContextMenuRegistry.prototype.getItem = function(id) {
+  return this.registry_[id] || null;
+};
+
+/**
+ * Gets the valid context menu options for the given scope type (e.g. block or workspace) and scope.
+ * Blocks are only shown if the preconditionFn shows they should not be hidden.
+ * @param {!Blockly.ContextMenuRegistry.ScopeType} scopeType Type of scope where menu should be
+ *     shown (e.g. on a block or on a workspace)
+ * @param {!Blockly.ContextMenuRegistry.Scope} scope Current scope of context menu
+ *     (i.e., the exact workspace or block being clicked on)
+ * @return {!Array<!Blockly.ContextMenuRegistry.ContextMenuOption>} the list of ContextMenuOptions
+ */
+Blockly.ContextMenuRegistry.prototype.getContextMenuOptions = function(scopeType, scope) {
+  var menuOptions = [];
+  var registry = this.registry_;
+  Object.keys(registry).forEach(function(id) {
+    var item = registry[id];
+    if (scopeType == item.scopeType) {
+      var precondition = item.preconditionFn(scope);
+      if (precondition != 'hidden') {
+        var displayText = typeof item.displayText == 'function' ?
+                            item.displayText(scope) : item.displayText;
+        /** @type {!Blockly.ContextMenuRegistry.ContextMenuOption} */
+        var menuOption = {
+          text: displayText,
+          enabled: (precondition == 'enabled'),
+          callback: item.callback,
+          scope: scope,
+          weight: item.weight,
+        };
+        menuOptions.push(menuOption);
+      }
+    }
+  });
+  menuOptions.sort(function(a, b) {
+    return a.weight - b.weight;
+  });
+  return menuOptions;
+};
+
+// Creates and assigns the singleton instance.
+new Blockly.ContextMenuRegistry();

blockly/core/css.js

@@ -0,0 +1,552 @@
+/**
+ * @license
+ * Copyright 2013 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Inject Blockly's CSS synchronously.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+/**
+ * @name Blockly.Css
+ * @namespace
+ */
+goog.provide('Blockly.Css');
+
+
+/**
+ * Has CSS already been injected?
+ * @type {boolean}
+ * @private
+ */
+Blockly.Css.injected_ = false;
+
+/**
+ * Add some CSS to the blob that will be injected later.  Allows optional
+ * components such as fields and the toolbox to store separate CSS.
+ * The provided array of CSS will be destroyed by this function.
+ * @param {!Array<string>} cssArray Array of CSS strings.
+ */
+Blockly.Css.register = function(cssArray) {
+  if (Blockly.Css.injected_) {
+    throw Error('CSS already injected');
+  }
+  // Concatenate cssArray onto Blockly.Css.CONTENT.
+  Array.prototype.push.apply(Blockly.Css.CONTENT, cssArray);
+  cssArray.length = 0;  // Garbage collect provided CSS content.
+};
+
+/**
+ * Inject the CSS into the DOM.  This is preferable over using a regular CSS
+ * file since:
+ * a) It loads synchronously and doesn't force a redraw later.
+ * b) It speeds up loading by not blocking on a separate HTTP transfer.
+ * c) The CSS content may be made dynamic depending on init options.
+ * @param {boolean} hasCss If false, don't inject CSS
+ *     (providing CSS becomes the document's responsibility).
+ * @param {string} pathToMedia Path from page to the Blockly media directory.
+ */
+Blockly.Css.inject = function(hasCss, pathToMedia) {
+  // Only inject the CSS once.
+  if (Blockly.Css.injected_) {
+    return;
+  }
+  Blockly.Css.injected_ = true;
+  var text = Blockly.Css.CONTENT.join('\n');
+  Blockly.Css.CONTENT.length = 0;  // Garbage collect CSS content.
+  if (!hasCss) {
+    return;
+  }
+  // Strip off any trailing slash (either Unix or Windows).
+  var mediaPath = pathToMedia.replace(/[\\/]$/, '');
+  text = text.replace(/<<<PATH>>>/g, mediaPath);
+
+  // Inject CSS tag at start of head.
+  var cssNode = document.createElement('style');
+  cssNode.id = 'blockly-common-style';
+  var cssTextNode = document.createTextNode(text);
+  cssNode.appendChild(cssTextNode);
+  document.head.insertBefore(cssNode, document.head.firstChild);
+};
+
+/**
+ * Array making up the CSS content for Blockly.
+ */
+Blockly.Css.CONTENT = [
+  /* eslint-disable indent */
+  '.blocklySvg {',
+    'background-color: #fff;',
+    'outline: none;',
+    'overflow: hidden;',  /* IE overflows by default. */
+    'position: absolute;',
+    'display: block;',
+  '}',
+
+  '.blocklyWidgetDiv {',
+    'display: none;',
+    'position: absolute;',
+    'z-index: 99999;',  /* big value for bootstrap3 compatibility */
+  '}',
+
+  '.injectionDiv {',
+    'height: 100%;',
+    'position: relative;',
+    'overflow: hidden;',  /* So blocks in drag surface disappear at edges */
+    'touch-action: none;',
+  '}',
+
+  '.blocklyNonSelectable {',
+    'user-select: none;',
+    '-ms-user-select: none;',
+    '-webkit-user-select: none;',
+  '}',
+
+  '.blocklyWsDragSurface {',
+    'display: none;',
+    'position: absolute;',
+    'top: 0;',
+    'left: 0;',
+  '}',
+  /* Added as a separate rule with multiple classes to make it more specific
+     than a bootstrap rule that selects svg:root. See issue #1275 for context.
+  */
+  '.blocklyWsDragSurface.blocklyOverflowVisible {',
+    'overflow: visible;',
+  '}',
+
+  '.blocklyBlockDragSurface {',
+    'display: none;',
+    'position: absolute;',
+    'top: 0;',
+    'left: 0;',
+    'right: 0;',
+    'bottom: 0;',
+    'overflow: visible !important;',
+    'z-index: 50;',  /* Display below toolbox, but above everything else. */
+  '}',
+
+  '.blocklyBlockCanvas.blocklyCanvasTransitioning,',
+  '.blocklyBubbleCanvas.blocklyCanvasTransitioning {',
+    'transition: transform .5s;',
+  '}',
+
+  '.blocklyTooltipDiv {',
+    'background-color: #ffffc7;',
+    'border: 1px solid #ddc;',
+    'box-shadow: 4px 4px 20px 1px rgba(0,0,0,.15);',
+    'color: #000;',
+    'display: none;',
+    'font: 9pt sans-serif;',
+    'opacity: .9;',
+    'padding: 2px;',
+    'position: absolute;',
+    'z-index: 100000;',  /* big value for bootstrap3 compatibility */
+  '}',
+
+  '.blocklyDropDownDiv {',
+    'position: absolute;',
+    'left: 0;',
+    'top: 0;',
+    'z-index: 1000;',
+    'display: none;',
+    'border: 1px solid;',
+    'border-color: #dadce0;',
+    'background-color: #fff;',
+    'border-radius: 2px;',
+    'padding: 4px;',
+    'box-shadow: 0 0 3px 1px rgba(0,0,0,.3);',
+  '}',
+
+  '.blocklyDropDownDiv.blocklyFocused {',
+    'box-shadow: 0 0 6px 1px rgba(0,0,0,.3);',
+  '}',
+
+  '.blocklyDropDownContent {',
+    'max-height: 300px;',  // @todo: spec for maximum height.
+    'overflow: auto;',
+    'overflow-x: hidden;',
+    'position: relative;',
+  '}',
+
+  '.blocklyDropDownArrow {',
+    'position: absolute;',
+    'left: 0;',
+    'top: 0;',
+    'width: 16px;',
+    'height: 16px;',
+    'z-index: -1;',
+    'background-color: inherit;',
+    'border-color: inherit;',
+  '}',
+
+  '.blocklyDropDownButton {',
+    'display: inline-block;',
+    'float: left;',
+    'padding: 0;',
+    'margin: 4px;',
+    'border-radius: 4px;',
+    'outline: none;',
+    'border: 1px solid;',
+    'transition: box-shadow .1s;',
+    'cursor: pointer;',
+  '}',
+
+  '.blocklyArrowTop {',
+    'border-top: 1px solid;',
+    'border-left: 1px solid;',
+    'border-top-left-radius: 4px;',
+    'border-color: inherit;',
+  '}',
+
+  '.blocklyArrowBottom {',
+    'border-bottom: 1px solid;',
+    'border-right: 1px solid;',
+    'border-bottom-right-radius: 4px;',
+    'border-color: inherit;',
+  '}',
+
+  '.blocklyResizeSE {',
+    'cursor: se-resize;',
+    'fill: #aaa;',
+  '}',
+
+  '.blocklyResizeSW {',
+    'cursor: sw-resize;',
+    'fill: #aaa;',
+  '}',
+
+  '.blocklyResizeLine {',
+    'stroke: #515A5A;',
+    'stroke-width: 1;',
+  '}',
+
+  '.blocklyHighlightedConnectionPath {',
+    'fill: none;',
+    'stroke: #fc3;',
+    'stroke-width: 4px;',
+  '}',
+
+  '.blocklyPathLight {',
+    'fill: none;',
+    'stroke-linecap: round;',
+    'stroke-width: 1;',
+  '}',
+
+  '.blocklySelected>.blocklyPathLight {',
+    'display: none;',
+  '}',
+
+  '.blocklyDraggable {',
+    /* backup for browsers (e.g. IE11) that don't support grab */
+    'cursor: url("<<<PATH>>>/handopen.cur"), auto;',
+    'cursor: grab;',
+    'cursor: -webkit-grab;',
+  '}',
+
+  '.blocklyDragging {',
+    /* backup for browsers (e.g. IE11) that don't support grabbing */
+    'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',
+    'cursor: grabbing;',
+    'cursor: -webkit-grabbing;',
+  '}',
+  /* Changes cursor on mouse down. Not effective in Firefox because of
+    https://bugzilla.mozilla.org/show_bug.cgi?id=771241 */
+  '.blocklyDraggable:active {',
+    /* backup for browsers (e.g. IE11) that don't support grabbing */
+    'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',
+    'cursor: grabbing;',
+    'cursor: -webkit-grabbing;',
+  '}',
+  /* Change the cursor on the whole drag surface in case the mouse gets
+     ahead of block during a drag. This way the cursor is still a closed hand.
+   */
+  '.blocklyBlockDragSurface .blocklyDraggable {',
+    /* backup for browsers (e.g. IE11) that don't support grabbing */
+    'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',
+    'cursor: grabbing;',
+    'cursor: -webkit-grabbing;',
+  '}',
+
+  '.blocklyDragging.blocklyDraggingDelete {',
+    'cursor: url("<<<PATH>>>/handdelete.cur"), auto;',
+  '}',
+
+  '.blocklyDragging>.blocklyPath,',
+  '.blocklyDragging>.blocklyPathLight {',
+    'fill-opacity: .8;',
+    'stroke-opacity: .8;',
+  '}',
+
+  '.blocklyDragging>.blocklyPathDark {',
+    'display: none;',
+  '}',
+
+  '.blocklyDisabled>.blocklyPath {',
+    'fill-opacity: .5;',
+    'stroke-opacity: .5;',
+  '}',
+
+  '.blocklyDisabled>.blocklyPathLight,',
+  '.blocklyDisabled>.blocklyPathDark {',
+    'display: none;',
+  '}',
+
+  '.blocklyInsertionMarker>.blocklyPath,',
+  '.blocklyInsertionMarker>.blocklyPathLight,',
+  '.blocklyInsertionMarker>.blocklyPathDark {',
+    'fill-opacity: .2;',
+    'stroke: none;',
+  '}',
+
+  '.blocklyMultilineText {',
+    'font-family: monospace;',
+  '}',
+
+  '.blocklyNonEditableText>text {',
+    'pointer-events: none;',
+  '}',
+
+  '.blocklyFlyout {',
+    'position: absolute;',
+    'z-index: 20;',
+  '}',
+
+  '.blocklyText text {',
+    'cursor: default;',
+  '}',
+
+  /*
+    Don't allow users to select text.  It gets annoying when trying to
+    drag a block and selected text moves instead.
+  */
+  '.blocklySvg text,',
+  '.blocklyBlockDragSurface text {',
+    'user-select: none;',
+    '-ms-user-select: none;',
+    '-webkit-user-select: none;',
+    'cursor: inherit;',
+  '}',
+
+  '.blocklyHidden {',
+    'display: none;',
+  '}',
+
+  '.blocklyFieldDropdown:not(.blocklyHidden) {',
+    'display: block;',
+  '}',
+
+  '.blocklyIconGroup {',
+    'cursor: default;',
+  '}',
+
+  '.blocklyIconGroup:not(:hover),',
+  '.blocklyIconGroupReadonly {',
+    'opacity: .6;',
+  '}',
+
+  '.blocklyIconShape {',
+    'fill: #00f;',
+    'stroke: #fff;',
+    'stroke-width: 1px;',
+  '}',
+
+  '.blocklyIconSymbol {',
+    'fill: #fff;',
+  '}',
+
+  '.blocklyMinimalBody {',
+    'margin: 0;',
+    'padding: 0;',
+  '}',
+
+  '.blocklyHtmlInput {',
+    'border: none;',
+    'border-radius: 4px;',
+    'height: 100%;',
+    'margin: 0;',
+    'outline: none;',
+    'padding: 0;',
+    'width: 100%;',
+    'text-align: center;',
+    'display: block;',
+    'box-sizing: border-box;',
+  '}',
+
+  /* Edge and IE introduce a close icon when the input value is longer than a
+     certain length. This affects our sizing calculations of the text input.
+     Hiding the close icon to avoid that. */
+  '.blocklyHtmlInput::-ms-clear {',
+    'display: none;',
+  '}',
+
+  '.blocklyMainBackground {',
+    'stroke-width: 1;',
+    'stroke: #c6c6c6;',  /* Equates to #ddd due to border being off-pixel. */
+  '}',
+
+  '.blocklyMutatorBackground {',
+    'fill: #fff;',
+    'stroke: #ddd;',
+    'stroke-width: 1;',
+  '}',
+
+  '.blocklyFlyoutBackground {',
+    'fill: #ddd;',
+    'fill-opacity: .8;',
+  '}',
+
+  '.blocklyMainWorkspaceScrollbar {',
+    'z-index: 20;',
+  '}',
+
+  '.blocklyFlyoutScrollbar {',
+    'z-index: 30;',
+  '}',
+
+  '.blocklyScrollbarHorizontal,',
+  '.blocklyScrollbarVertical {',
+    'position: absolute;',
+    'outline: none;',
+  '}',
+
+  '.blocklyScrollbarBackground {',
+    'opacity: 0;',
+  '}',
+
+  '.blocklyScrollbarHandle {',
+    'fill: #ccc;',
+  '}',
+
+  '.blocklyScrollbarBackground:hover+.blocklyScrollbarHandle,',
+  '.blocklyScrollbarHandle:hover {',
+    'fill: #bbb;',
+  '}',
+
+  /* Darken flyout scrollbars due to being on a grey background. */
+  /* By contrast, workspace scrollbars are on a white background. */
+  '.blocklyFlyout .blocklyScrollbarHandle {',
+    'fill: #bbb;',
+  '}',
+
+  '.blocklyFlyout .blocklyScrollbarBackground:hover+.blocklyScrollbarHandle,',
+  '.blocklyFlyout .blocklyScrollbarHandle:hover {',
+    'fill: #aaa;',
+  '}',
+
+  '.blocklyInvalidInput {',
+    'background: #faa;',
+  '}',
+
+  '.blocklyVerticalMarker {',
+    'stroke-width: 3px;',
+    'fill: rgba(255,255,255,.5);',
+    'pointer-events: none;',
+  '}',
+
+  '.blocklyComputeCanvas {',
+    'position: absolute;',
+    'width: 0;',
+    'height: 0;',
+  '}',
+
+  '.blocklyNoPointerEvents {',
+    'pointer-events: none;',
+  '}',
+
+  '.blocklyContextMenu {',
+    'border-radius: 4px;',
+    'max-height: 100%;',
+  '}',
+
+  '.blocklyDropdownMenu {',
+    'border-radius: 2px;',
+    'padding: 0 !important;',
+  '}',
+
+  '.blocklyDropdownMenu .blocklyMenuItem {',
+    /* 28px on the left for icon or checkbox. */
+    'padding-left: 28px;',
+  '}',
+
+  /* BiDi override for the resting state. */
+  '.blocklyDropdownMenu .blocklyMenuItemRtl {',
+     /* Flip left/right padding for BiDi. */
+    'padding-left: 5px;',
+    'padding-right: 28px;',
+  '}',
+
+  '.blocklyWidgetDiv .blocklyMenu {',
+    'background: #fff;',
+    'border: 1px solid transparent;',
+    'box-shadow: 0 0 3px 1px rgba(0,0,0,.3);',
+    'font: normal 13px Arial, sans-serif;',
+    'margin: 0;',
+    'outline: none;',
+    'padding: 4px 0;',
+    'position: absolute;',
+    'overflow-y: auto;',
+    'overflow-x: hidden;',
+    'max-height: 100%;',
+    'z-index: 20000;',  /* Arbitrary, but some apps depend on it... */
+  '}',
+
+  '.blocklyWidgetDiv .blocklyMenu.blocklyFocused {',
+    'box-shadow: 0 0 6px 1px rgba(0,0,0,.3);',
+  '}',
+
+  '.blocklyDropDownDiv .blocklyMenu {',
+    'background: inherit;',  /* Compatibility with gapi, reset from goog-menu */
+    'border: inherit;',  /* Compatibility with gapi, reset from goog-menu */
+    'font: normal 13px "Helvetica Neue", Helvetica, sans-serif;',
+    'outline: none;',
+    'position: relative;',  /* Compatibility with gapi, reset from goog-menu */
+    'z-index: 20000;',  /* Arbitrary, but some apps depend on it... */
+  '}',
+
+  /* State: resting. */
+  '.blocklyMenuItem {',
+    'border: none;',
+    'color: #000;',
+    'cursor: pointer;',
+    'list-style: none;',
+    'margin: 0;',
+     /* 7em on the right for shortcut. */
+    'min-width: 7em;',
+    'padding: 6px 15px;',
+    'white-space: nowrap;',
+  '}',
+
+  /* State: disabled. */
+  '.blocklyMenuItemDisabled {',
+    'color: #ccc;',
+    'cursor: inherit;',
+  '}',
+
+  /* State: hover. */
+  '.blocklyMenuItemHighlight {',
+    'background-color: rgba(0,0,0,.1);',
+  '}',
+
+  /* State: selected/checked. */
+  '.blocklyMenuItemCheckbox {',
+    'height: 16px;',
+    'position: absolute;',
+    'width: 16px;',
+  '}',
+
+  '.blocklyMenuItemSelected .blocklyMenuItemCheckbox {',
+    'background: url(<<<PATH>>>/sprites.png) no-repeat -48px -16px;',
+    'float: left;',
+    'margin-left: -24px;',
+    'position: static;',  /* Scroll with the menu. */
+  '}',
+
+  '.blocklyMenuItemRtl .blocklyMenuItemCheckbox {',
+    'float: right;',
+    'margin-right: -24px;',
+  '}',
+  /* eslint-enable indent */
+];

blockly/core/delete_area.js

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The abstract class for a component that can delete a block or
+ * bubble that is dropped on top of it.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.DeleteArea');
+
+goog.require('Blockly.BlockSvg');
+goog.require('Blockly.DragTarget');
+goog.require('Blockly.IDeleteArea');
+
+goog.requireType('Blockly.IDraggable');
+
+/**
+ * Abstract class for a component that can delete a block or bubble that is
+ * dropped on top of it.
+ * @extends {Blockly.DragTarget}
+ * @implements {Blockly.IDeleteArea}
+ * @constructor
+ */
+Blockly.DeleteArea = function() {
+  Blockly.DeleteArea.superClass_.constructor.call(this);
+
+  /**
+   * Whether the last block or bubble dragged over this delete area would be
+   * deleted if dropped on this component.
+   * This property is not updated after the block or bubble is deleted.
+   * @type {boolean}
+   * @protected
+   */
+  this.wouldDelete_ = false;
+};
+Blockly.utils.object.inherits(Blockly.DeleteArea, Blockly.DragTarget);
+
+/**
+ * Returns whether the provided block or bubble would be deleted if dropped on
+ * this area.
+ * This method should check if the element is deletable and is always called
+ * before onDragEnter/onDragOver/onDragExit.
+ * @param {!Blockly.IDraggable} element The block or bubble currently being
+ *   dragged.
+ * @param {boolean} couldConnect Whether the element could could connect to
+ *     another.
+ * @return {boolean} Whether the element provided would be deleted if dropped on
+ *     this area.
+ */
+Blockly.DeleteArea.prototype.wouldDelete = function(element, couldConnect) {
+  if (element instanceof Blockly.BlockSvg) {
+    var block = /** @type {Blockly.BlockSvg} */ (element);
+    var couldDeleteBlock = !block.getParent() && block.isDeletable();
+    this.updateWouldDelete_(couldDeleteBlock && !couldConnect);
+  } else {
+    this.updateWouldDelete_(element.isDeletable());
+  }
+  return this.wouldDelete_;
+};
+
+/**
+ * Updates the internal wouldDelete_ state.
+ * @param {boolean} wouldDelete The new value for the wouldDelete state.
+ * @protected
+ */
+Blockly.DeleteArea.prototype.updateWouldDelete_ = function(wouldDelete) {
+  this.wouldDelete_ = wouldDelete;
+};

blockly/core/drag_target.js

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The abstract class for a component with custom behaviour when a
+ * block or bubble is dragged over or dropped on top of it.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.DragTarget');
+
+goog.require('Blockly.IDragTarget');
+
+goog.requireType('Blockly.IDraggable');
+goog.requireType('Blockly.utils.Rect');
+
+
+/**
+ * Abstract class for a component with custom behaviour when a block or bubble
+ * is dragged over or dropped on top of it.
+ * @implements {Blockly.IDragTarget}
+ * @constructor
+ */
+Blockly.DragTarget = function() {};
+
+/**
+ * Returns the bounding rectangle of the drag target area in pixel units
+ * relative to the Blockly injection div.
+ * @return {?Blockly.utils.Rect} The component's bounding box. Null if drag
+ *   target area should be ignored.
+ */
+Blockly.DragTarget.prototype.getClientRect;
+
+/**
+ * Handles when a cursor with a block or bubble enters this drag target.
+ * @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
+ *   dragged.
+ */
+Blockly.DragTarget.prototype.onDragEnter = function(_dragElement) {
+  // no-op
+};
+
+/**
+ * Handles when a cursor with a block or bubble is dragged over this drag
+ * target.
+ * @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
+ *   dragged.
+ */
+Blockly.DragTarget.prototype.onDragOver = function(_dragElement) {
+  // no-op
+};
+
+/**
+ * Handles when a cursor with a block or bubble exits this drag target.
+ * @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
+ *   dragged.
+ */
+Blockly.DragTarget.prototype.onDragExit = function(_dragElement) {
+  // no-op
+};
+
+/**
+ * Handles when a block or bubble is dropped on this component.
+ * Should not handle delete here.
+ * @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
+ *   dragged.
+ */
+Blockly.DragTarget.prototype.onDrop = function(_dragElement) {
+  // no-op
+};
+
+/**
+ * Returns whether the provided block or bubble should not be moved after being
+ * dropped on this component. If true, the element will return to where it was
+ * when the drag started.
+ * @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
+ *   dragged.
+ * @return {boolean} Whether the block or bubble provided should be returned to
+ *     drag start.
+ */
+Blockly.DragTarget.prototype.shouldPreventMove = function(_dragElement) {
+  return false;
+};

blockly/core/dropdowndiv.js

@@ -0,0 +1,779 @@
+/**
+ * @license
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview A div that floats on top of the workspace, for drop-down menus.
+ * The drop-down can be kept inside the workspace, animate in/out, etc.
+ * @author tmickel@mit.edu (Tim Mickel)
+ */
+
+'use strict';
+
+goog.provide('Blockly.DropDownDiv');
+
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.math');
+goog.require('Blockly.utils.Rect');
+goog.require('Blockly.utils.style');
+
+goog.requireType('Blockly.BlockSvg');
+goog.requireType('Blockly.Field');
+goog.requireType('Blockly.utils.Size');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Class for drop-down div.
+ * @constructor
+ * @package
+ */
+Blockly.DropDownDiv = function() {
+};
+
+/**
+ * Drop-downs will appear within the bounds of this element if possible.
+ * Set in Blockly.DropDownDiv.setBoundsElement.
+ * @type {Element}
+ * @private
+ */
+Blockly.DropDownDiv.boundsElement_ = null;
+
+/**
+ * The object currently using the drop-down.
+ * @type {Object}
+ * @private
+ */
+Blockly.DropDownDiv.owner_ = null;
+
+/**
+ * Whether the dropdown was positioned to a field or the source block.
+ * @type {?boolean}
+ * @private
+ */
+Blockly.DropDownDiv.positionToField_ = null;
+
+/**
+ * Arrow size in px. Should match the value in CSS
+ * (need to position pre-render).
+ * @type {number}
+ * @const
+ */
+Blockly.DropDownDiv.ARROW_SIZE = 16;
+
+/**
+ * Drop-down border size in px. Should match the value in CSS (need to position
+ * the arrow).
+ * @type {number}
+ * @const
+ */
+Blockly.DropDownDiv.BORDER_SIZE = 1;
+
+/**
+ * Amount the arrow must be kept away from the edges of the main drop-down div,
+ * in px.
+ * @type {number}
+ * @const
+ */
+Blockly.DropDownDiv.ARROW_HORIZONTAL_PADDING = 12;
+
+/**
+ * Amount drop-downs should be padded away from the source, in px.
+ * @type {number}
+ * @const
+ */
+Blockly.DropDownDiv.PADDING_Y = 16;
+
+/**
+ * Length of animations in seconds.
+ * @type {number}
+ * @const
+ */
+Blockly.DropDownDiv.ANIMATION_TIME = 0.25;
+
+/**
+ * Timer for animation out, to be cleared if we need to immediately hide
+ * without disrupting new shows.
+ * @type {?number}
+ * @private
+ */
+Blockly.DropDownDiv.animateOutTimer_ = null;
+
+/**
+ * Callback for when the drop-down is hidden.
+ * @type {?Function}
+ * @private
+ */
+Blockly.DropDownDiv.onHide_ = null;
+
+/**
+ * A class name representing the current owner's workspace renderer.
+ * @type {string}
+ * @private
+ */
+Blockly.DropDownDiv.rendererClassName_ = '';
+
+/**
+ * A class name representing the current owner's workspace theme.
+ * @type {string}
+ * @private
+ */
+Blockly.DropDownDiv.themeClassName_ = '';
+
+/**
+ * Dropdown bounds info object used to encapsulate sizing information about a
+ * bounding element (bounding box and width/height).
+ * @typedef {{
+ *        top:number,
+ *        left:number,
+ *        bottom:number,
+ *        right:number,
+ *        width:number,
+ *        height:number
+ * }}
+ */
+Blockly.DropDownDiv.BoundsInfo;
+
+/**
+ * Dropdown position metrics.
+ * @typedef {{
+ *        initialX:number,
+ *        initialY:number,
+ *        finalX:number,
+ *        finalY:number,
+ *        arrowX:?number,
+ *        arrowY:?number,
+ *        arrowAtTop:?boolean,
+ *        arrowVisible:boolean
+ * }}
+ */
+Blockly.DropDownDiv.PositionMetrics;
+
+/**
+ * Create and insert the DOM element for this div.
+ * @package
+ */
+Blockly.DropDownDiv.createDom = function() {
+  if (Blockly.DropDownDiv.DIV_) {
+    return;  // Already created.
+  }
+  var div = document.createElement('div');
+  div.className = 'blocklyDropDownDiv';
+  var container = Blockly.parentContainer || document.body;
+  container.appendChild(div);
+  /**
+   * The div element.
+   * @type {!Element}
+   * @private
+   */
+  Blockly.DropDownDiv.DIV_ = div;
+
+  var content = document.createElement('div');
+  content.className = 'blocklyDropDownContent';
+  div.appendChild(content);
+  /**
+   * The content element.
+   * @type {!Element}
+   * @private
+   */
+  Blockly.DropDownDiv.content_ = content;
+
+  var arrow = document.createElement('div');
+  arrow.className = 'blocklyDropDownArrow';
+  div.appendChild(arrow);
+  /**
+   * The arrow element.
+   * @type {!Element}
+   * @private
+   */
+  Blockly.DropDownDiv.arrow_ = arrow;
+
+  Blockly.DropDownDiv.DIV_.style.opacity = 0;
+
+  // Transition animation for transform: translate() and opacity.
+  Blockly.DropDownDiv.DIV_.style.transition = 'transform ' +
+    Blockly.DropDownDiv.ANIMATION_TIME + 's, ' +
+    'opacity ' + Blockly.DropDownDiv.ANIMATION_TIME + 's';
+
+  // Handle focusin/out events to add a visual indicator when
+  // a child is focused or blurred.
+  div.addEventListener('focusin', function() {
+    Blockly.utils.dom.addClass(div, 'blocklyFocused');
+  });
+  div.addEventListener('focusout', function() {
+    Blockly.utils.dom.removeClass(div, 'blocklyFocused');
+  });
+};
+
+/**
+ * Set an element to maintain bounds within. Drop-downs will appear
+ * within the box of this element if possible.
+ * @param {Element} boundsElement Element to bind drop-down to.
+ */
+Blockly.DropDownDiv.setBoundsElement = function(boundsElement) {
+  Blockly.DropDownDiv.boundsElement_ = boundsElement;
+};
+
+/**
+ * Provide the div for inserting content into the drop-down.
+ * @return {!Element} Div to populate with content.
+ */
+Blockly.DropDownDiv.getContentDiv = function() {
+  return Blockly.DropDownDiv.content_;
+};
+
+/**
+ * Clear the content of the drop-down.
+ */
+Blockly.DropDownDiv.clearContent = function() {
+  Blockly.DropDownDiv.content_.textContent = '';
+  Blockly.DropDownDiv.content_.style.width = '';
+};
+
+/**
+ * Set the colour for the drop-down.
+ * @param {string} backgroundColour Any CSS colour for the background.
+ * @param {string} borderColour Any CSS colour for the border.
+ */
+Blockly.DropDownDiv.setColour = function(backgroundColour, borderColour) {
+  Blockly.DropDownDiv.DIV_.style.backgroundColor = backgroundColour;
+  Blockly.DropDownDiv.DIV_.style.borderColor = borderColour;
+};
+
+/**
+ * Shortcut to show and place the drop-down with positioning determined
+ * by a particular block. The primary position will be below the block,
+ * and the secondary position above the block. Drop-down will be
+ * constrained to the block's workspace.
+ * @param {!Blockly.Field} field The field showing the drop-down.
+ * @param {!Blockly.BlockSvg} block Block to position the drop-down around.
+ * @param {Function=} opt_onHide Optional callback for when the drop-down is
+ *   hidden.
+ * @param {number=} opt_secondaryYOffset Optional Y offset for above-block
+ *   positioning.
+ * @return {boolean} True if the menu rendered below block; false if above.
+ */
+Blockly.DropDownDiv.showPositionedByBlock = function(field, block,
+    opt_onHide, opt_secondaryYOffset) {
+  return Blockly.DropDownDiv.showPositionedByRect_(
+      Blockly.DropDownDiv.getScaledBboxOfBlock_(block),
+      field, opt_onHide, opt_secondaryYOffset);
+};
+
+/**
+ * Shortcut to show and place the drop-down with positioning determined
+ * by a particular field. The primary position will be below the field,
+ * and the secondary position above the field. Drop-down will be
+ * constrained to the block's workspace.
+ * @param {!Blockly.Field} field The field to position the dropdown against.
+ * @param {Function=} opt_onHide Optional callback for when the drop-down is
+ *   hidden.
+ * @param {number=} opt_secondaryYOffset Optional Y offset for above-block
+ *   positioning.
+ * @return {boolean} True if the menu rendered below block; false if above.
+ */
+Blockly.DropDownDiv.showPositionedByField = function(field,
+    opt_onHide, opt_secondaryYOffset) {
+  Blockly.DropDownDiv.positionToField_ = true;
+  return Blockly.DropDownDiv.showPositionedByRect_(
+      Blockly.DropDownDiv.getScaledBboxOfField_(field),
+      field, opt_onHide, opt_secondaryYOffset);
+};
+
+/**
+ * Get the scaled bounding box of a block.
+ * @param {!Blockly.BlockSvg} block The block.
+ * @return {!Blockly.utils.Rect} The scaled bounding box of the block.
+ * @private
+ */
+Blockly.DropDownDiv.getScaledBboxOfBlock_ = function(block) {
+  var blockSvg = block.getSvgRoot();
+  var bBox = blockSvg.getBBox();
+  var scale = block.workspace.scale;
+  var scaledHeight = bBox.height * scale;
+  var scaledWidth = bBox.width * scale;
+  var xy = Blockly.utils.style.getPageOffset(blockSvg);
+  return new Blockly.utils.Rect(
+      xy.y, xy.y + scaledHeight, xy.x, xy.x + scaledWidth);
+};
+
+/**
+ * Get the scaled bounding box of a field.
+ * @param {!Blockly.Field} field The field.
+ * @return {!Blockly.utils.Rect} The scaled bounding box of the field.
+ * @private
+ */
+Blockly.DropDownDiv.getScaledBboxOfField_ = function(field) {
+  var bBox = field.getScaledBBox();
+  return new Blockly.utils.Rect(
+      bBox.top, bBox.bottom, bBox.left, bBox.right);
+};
+
+/**
+ * Helper method to show and place the drop-down with positioning determined
+ * by a scaled bounding box.  The primary position will be below the rect,
+ * and the secondary position above the rect. Drop-down will be constrained to
+ * the block's workspace.
+ * @param {!Blockly.utils.Rect} bBox The scaled bounding box.
+ * @param {!Blockly.Field} field The field to position the dropdown against.
+ * @param {Function=} opt_onHide Optional callback for when the drop-down is
+ *   hidden.
+ * @param {number=} opt_secondaryYOffset Optional Y offset for above-block
+ *   positioning.
+ * @return {boolean} True if the menu rendered below block; false if above.
+ * @private
+ */
+Blockly.DropDownDiv.showPositionedByRect_ = function(bBox, field,
+    opt_onHide, opt_secondaryYOffset) {
+  // If we can fit it, render below the block.
+  var primaryX = bBox.left + (bBox.right - bBox.left) / 2;
+  var primaryY = bBox.bottom;
+  // If we can't fit it, render above the entire parent block.
+  var secondaryX = primaryX;
+  var secondaryY = bBox.top;
+  if (opt_secondaryYOffset) {
+    secondaryY += opt_secondaryYOffset;
+  }
+  var sourceBlock = /** @type {!Blockly.BlockSvg} */ (field.getSourceBlock());
+  // Set bounds to main workspace; show the drop-down.
+  var workspace = sourceBlock.workspace;
+  while (workspace.options.parentWorkspace) {
+    workspace = /** @type {!Blockly.WorkspaceSvg} */ (
+      workspace.options.parentWorkspace);
+  }
+  Blockly.DropDownDiv.setBoundsElement(
+      /** @type {Element} */ (workspace.getParentSvg().parentNode));
+  return Blockly.DropDownDiv.show(
+      field, sourceBlock.RTL,
+      primaryX, primaryY, secondaryX, secondaryY, opt_onHide);
+};
+
+/**
+ * Show and place the drop-down.
+ * The drop-down is placed with an absolute "origin point" (x, y) - i.e.,
+ * the arrow will point at this origin and box will positioned below or above
+ * it.  If we can maintain the container bounds at the primary point, the arrow
+ * will point there, and the container will be positioned below it.
+ * If we can't maintain the container bounds at the primary point, fall-back to
+ * the secondary point and position above.
+ * @param {Object} owner The object showing the drop-down
+ * @param {boolean} rtl Right-to-left (true) or left-to-right (false).
+ * @param {number} primaryX Desired origin point x, in absolute px.
+ * @param {number} primaryY Desired origin point y, in absolute px.
+ * @param {number} secondaryX Secondary/alternative origin point x, in absolute
+ *     px.
+ * @param {number} secondaryY Secondary/alternative origin point y, in absolute
+ *     px.
+ * @param {Function=} opt_onHide Optional callback for when the drop-down is
+ *     hidden.
+ * @return {boolean} True if the menu rendered at the primary origin point.
+ * @package
+ */
+Blockly.DropDownDiv.show = function(owner, rtl, primaryX, primaryY,
+    secondaryX, secondaryY, opt_onHide) {
+  Blockly.DropDownDiv.owner_ = owner;
+  Blockly.DropDownDiv.onHide_ = opt_onHide || null;
+  // Set direction.
+  var div = Blockly.DropDownDiv.DIV_;
+  div.style.direction = rtl ? 'rtl' : 'ltr';
+
+  var mainWorkspace =
+    /** @type {!Blockly.WorkspaceSvg} */ (Blockly.getMainWorkspace());
+  Blockly.DropDownDiv.rendererClassName_ =
+      mainWorkspace.getRenderer().getClassName();
+  Blockly.DropDownDiv.themeClassName_ = mainWorkspace.getTheme().getClassName();
+  Blockly.utils.dom.addClass(div, Blockly.DropDownDiv.rendererClassName_);
+  Blockly.utils.dom.addClass(div, Blockly.DropDownDiv.themeClassName_);
+
+  // When we change `translate` multiple times in close succession,
+  // Chrome may choose to wait and apply them all at once.
+  // Since we want the translation to initial X, Y to be immediate,
+  // and the translation to final X, Y to be animated,
+  // we saw problems where both would be applied after animation was turned on,
+  // making the dropdown appear to fly in from (0, 0).
+  // Using both `left`, `top` for the initial translation and then `translate`
+  // for the animated transition to final X, Y is a workaround.
+
+  return Blockly.DropDownDiv.positionInternal_(
+      primaryX, primaryY, secondaryX, secondaryY);
+};
+
+/**
+ * Get sizing info about the bounding element.
+ * @return {!Blockly.DropDownDiv.BoundsInfo} An object containing size
+ *     information about the bounding element (bounding box and width/height).
+ * @private
+ */
+Blockly.DropDownDiv.getBoundsInfo_ = function() {
+  var boundPosition = Blockly.utils.style.getPageOffset(
+      /** @type {!Element} */ (Blockly.DropDownDiv.boundsElement_));
+  var boundSize = Blockly.utils.style.getSize(
+      /** @type {!Element} */ (Blockly.DropDownDiv.boundsElement_));
+
+  return {
+    left: boundPosition.x,
+    right: boundPosition.x + boundSize.width,
+    top: boundPosition.y,
+    bottom: boundPosition.y + boundSize.height,
+    width: boundSize.width,
+    height: boundSize.height
+  };
+};
+
+/**
+ * Helper to position the drop-down and the arrow, maintaining bounds.
+ * See explanation of origin points in Blockly.DropDownDiv.show.
+ * @param {number} primaryX Desired origin point x, in absolute px.
+ * @param {number} primaryY Desired origin point y, in absolute px.
+ * @param {number} secondaryX Secondary/alternative origin point x,
+ *     in absolute px.
+ * @param {number} secondaryY Secondary/alternative origin point y,
+ *     in absolute px.
+ * @return {!Blockly.DropDownDiv.PositionMetrics} Various final metrics,
+ *     including rendered positions for drop-down and arrow.
+ * @private
+ */
+Blockly.DropDownDiv.getPositionMetrics_ = function(primaryX, primaryY,
+    secondaryX, secondaryY) {
+  var boundsInfo = Blockly.DropDownDiv.getBoundsInfo_();
+  var divSize = Blockly.utils.style.getSize(
+      /** @type {!Element} */ (Blockly.DropDownDiv.DIV_));
+
+  // Can we fit in-bounds below the target?
+  if (primaryY + divSize.height < boundsInfo.bottom) {
+    return Blockly.DropDownDiv.getPositionBelowMetrics_(
+        primaryX, primaryY, boundsInfo, divSize);
+  }
+  // Can we fit in-bounds above the target?
+  if (secondaryY - divSize.height > boundsInfo.top) {
+    return Blockly.DropDownDiv.getPositionAboveMetrics_(
+        secondaryX, secondaryY, boundsInfo, divSize);
+  }
+  // Can we fit outside the workspace bounds (but inside the window) below?
+  if (primaryY + divSize.height < document.documentElement.clientHeight) {
+    return Blockly.DropDownDiv.getPositionBelowMetrics_(
+        primaryX, primaryY, boundsInfo, divSize);
+  }
+  // Can we fit outside the workspace bounds (but inside the window) above?
+  if (secondaryY - divSize.height > document.documentElement.clientTop) {
+    return Blockly.DropDownDiv.getPositionAboveMetrics_(
+        secondaryX, secondaryY, boundsInfo, divSize);
+  }
+
+  // Last resort, render at top of page.
+  return Blockly.DropDownDiv.getPositionTopOfPageMetrics_(
+      primaryX, boundsInfo, divSize);
+};
+
+/**
+ * Get the metrics for positioning the div below the source.
+ * @param {number} primaryX Desired origin point x, in absolute px.
+ * @param {number} primaryY Desired origin point y, in absolute px.
+ * @param {!Blockly.DropDownDiv.BoundsInfo} boundsInfo An object containing size
+ *     information about the bounding element (bounding box and width/height).
+ * @param {!Blockly.utils.Size} divSize An object containing information about
+ *     the size of the DropDownDiv (width & height).
+ * @return {!Blockly.DropDownDiv.PositionMetrics} Various final metrics,
+ *     including rendered positions for drop-down and arrow.
+ * @private
+ */
+Blockly.DropDownDiv.getPositionBelowMetrics_ = function(
+    primaryX, primaryY, boundsInfo, divSize) {
+
+  var xCoords = Blockly.DropDownDiv.getPositionX(
+      primaryX, boundsInfo.left, boundsInfo.right, divSize.width);
+
+  var arrowY = -(Blockly.DropDownDiv.ARROW_SIZE / 2 +
+      Blockly.DropDownDiv.BORDER_SIZE);
+  var finalY = primaryY + Blockly.DropDownDiv.PADDING_Y;
+
+  return {
+    initialX: xCoords.divX,
+    initialY : primaryY,
+    finalX: xCoords.divX,  // X position remains constant during animation.
+    finalY: finalY,
+    arrowX: xCoords.arrowX,
+    arrowY: arrowY,
+    arrowAtTop: true,
+    arrowVisible: true
+  };
+};
+
+/**
+ * Get the metrics for positioning the div above the source.
+ * @param {number} secondaryX Secondary/alternative origin point x,
+ *     in absolute px.
+ * @param {number} secondaryY Secondary/alternative origin point y,
+ *     in absolute px.
+ * @param {!Blockly.DropDownDiv.BoundsInfo} boundsInfo An object containing size
+ *     information about the bounding element (bounding box and width/height).
+ * @param {!Blockly.utils.Size} divSize An object containing information about
+ *     the size of the DropDownDiv (width & height).
+ * @return {!Blockly.DropDownDiv.PositionMetrics} Various final metrics,
+ *     including rendered positions for drop-down and arrow.
+ * @private
+ */
+Blockly.DropDownDiv.getPositionAboveMetrics_ = function(
+    secondaryX, secondaryY, boundsInfo, divSize) {
+
+  var xCoords = Blockly.DropDownDiv.getPositionX(
+      secondaryX, boundsInfo.left, boundsInfo.right, divSize.width);
+
+  var arrowY = divSize.height - (Blockly.DropDownDiv.BORDER_SIZE * 2) -
+      (Blockly.DropDownDiv.ARROW_SIZE / 2);
+  var finalY = secondaryY - divSize.height - Blockly.DropDownDiv.PADDING_Y;
+  var initialY = secondaryY - divSize.height;  // No padding on Y.
+
+  return {
+    initialX: xCoords.divX,
+    initialY : initialY,
+    finalX: xCoords.divX,  // X position remains constant during animation.
+    finalY: finalY,
+    arrowX: xCoords.arrowX,
+    arrowY: arrowY,
+    arrowAtTop: false,
+    arrowVisible: true
+  };
+};
+
+/**
+ * Get the metrics for positioning the div at the top of the page.
+ * @param {number} sourceX Desired origin point x, in absolute px.
+ * @param {!Blockly.DropDownDiv.BoundsInfo} boundsInfo An object containing size
+ *     information about the bounding element (bounding box and width/height).
+ * @param {!Blockly.utils.Size} divSize An object containing information about
+ *     the size of the DropDownDiv (width & height).
+ * @return {!Blockly.DropDownDiv.PositionMetrics} Various final metrics,
+ *     including rendered positions for drop-down and arrow.
+ * @private
+ */
+Blockly.DropDownDiv.getPositionTopOfPageMetrics_ = function(
+    sourceX, boundsInfo, divSize) {
+
+  var xCoords = Blockly.DropDownDiv.getPositionX(
+      sourceX, boundsInfo.left, boundsInfo.right, divSize.width);
+
+  // No need to provide arrow-specific information because it won't be visible.
+  return {
+    initialX: xCoords.divX,
+    initialY : 0,
+    finalX: xCoords.divX,  // X position remains constant during animation.
+    finalY: 0,             // Y position remains constant during animation.
+    arrowAtTop: null,
+    arrowX: null,
+    arrowY: null,
+    arrowVisible: false
+  };
+};
+
+/**
+ * Get the x positions for the left side of the DropDownDiv and the arrow,
+ * accounting for the bounds of the workspace.
+ * @param {number} sourceX Desired origin point x, in absolute px.
+ * @param {number} boundsLeft The left edge of the bounding element, in
+ *    absolute px.
+ * @param {number} boundsRight The right edge of the bounding element, in
+ *    absolute px.
+ * @param {number} divWidth The width of the div in px.
+ * @return {{divX: number, arrowX: number}} An object containing metrics for
+ *    the x positions of the left side of the DropDownDiv and the arrow.
+ * @package
+ */
+Blockly.DropDownDiv.getPositionX = function(
+    sourceX, boundsLeft, boundsRight, divWidth) {
+  var arrowX, divX;
+  arrowX = divX = sourceX;
+
+  // Offset the topLeft coord so that the dropdowndiv is centered.
+  divX -= divWidth / 2;
+  // Fit the dropdowndiv within the bounds of the workspace.
+  divX = Blockly.utils.math.clamp(boundsLeft, divX, boundsRight - divWidth);
+
+  // Offset the arrow coord so that the arrow is centered.
+  arrowX -= Blockly.DropDownDiv.ARROW_SIZE / 2;
+  // Convert the arrow position to be relative to the top left of the div.
+  var relativeArrowX = arrowX - divX;
+  var horizPadding = Blockly.DropDownDiv.ARROW_HORIZONTAL_PADDING;
+  // Clamp the arrow position so that it stays attached to the dropdowndiv.
+  relativeArrowX = Blockly.utils.math.clamp(
+      horizPadding,
+      relativeArrowX,
+      divWidth - horizPadding - Blockly.DropDownDiv.ARROW_SIZE);
+
+  return {
+    arrowX: relativeArrowX,
+    divX: divX
+  };
+};
+
+/**
+ * Is the container visible?
+ * @return {boolean} True if visible.
+ */
+Blockly.DropDownDiv.isVisible = function() {
+  return !!Blockly.DropDownDiv.owner_;
+};
+
+/**
+ * Hide the menu only if it is owned by the provided object.
+ * @param {Object} owner Object which must be owning the drop-down to hide.
+ * @param {boolean=} opt_withoutAnimation True if we should hide the dropdown
+ *     without animating.
+ * @return {boolean} True if hidden.
+ */
+Blockly.DropDownDiv.hideIfOwner = function(owner, opt_withoutAnimation) {
+  if (Blockly.DropDownDiv.owner_ === owner) {
+    if (opt_withoutAnimation) {
+      Blockly.DropDownDiv.hideWithoutAnimation();
+    } else {
+      Blockly.DropDownDiv.hide();
+    }
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Hide the menu, triggering animation.
+ */
+Blockly.DropDownDiv.hide = function() {
+  // Start the animation by setting the translation and fading out.
+  var div = Blockly.DropDownDiv.DIV_;
+  // Reset to (initialX, initialY) - i.e., no translation.
+  div.style.transform = 'translate(0, 0)';
+  div.style.opacity = 0;
+  // Finish animation - reset all values to default.
+  Blockly.DropDownDiv.animateOutTimer_ =
+      setTimeout(function() {
+        Blockly.DropDownDiv.hideWithoutAnimation();
+      }, Blockly.DropDownDiv.ANIMATION_TIME * 1000);
+  if (Blockly.DropDownDiv.onHide_) {
+    Blockly.DropDownDiv.onHide_();
+    Blockly.DropDownDiv.onHide_ = null;
+  }
+};
+
+/**
+ * Hide the menu, without animation.
+ */
+Blockly.DropDownDiv.hideWithoutAnimation = function() {
+  if (!Blockly.DropDownDiv.isVisible()) {
+    return;
+  }
+  if (Blockly.DropDownDiv.animateOutTimer_) {
+    clearTimeout(Blockly.DropDownDiv.animateOutTimer_);
+  }
+
+  // Reset style properties in case this gets called directly
+  // instead of hide() - see discussion on #2551.
+  var div = Blockly.DropDownDiv.DIV_;
+  div.style.transform = '';
+  div.style.left = '';
+  div.style.top = '';
+  div.style.opacity = 0;
+  div.style.display = 'none';
+  div.style.backgroundColor = '';
+  div.style.borderColor = '';
+
+  if (Blockly.DropDownDiv.onHide_) {
+    Blockly.DropDownDiv.onHide_();
+    Blockly.DropDownDiv.onHide_ = null;
+  }
+  Blockly.DropDownDiv.clearContent();
+  Blockly.DropDownDiv.owner_ = null;
+
+  if (Blockly.DropDownDiv.rendererClassName_) {
+    Blockly.utils.dom.removeClass(div, Blockly.DropDownDiv.rendererClassName_);
+    Blockly.DropDownDiv.rendererClassName_ = '';
+  }
+  if (Blockly.DropDownDiv.themeClassName_) {
+    Blockly.utils.dom.removeClass(div, Blockly.DropDownDiv.themeClassName_);
+    Blockly.DropDownDiv.themeClassName_ = '';
+  }
+  (/** @type {!Blockly.WorkspaceSvg} */ (
+    Blockly.getMainWorkspace())).markFocused();
+};
+
+/**
+ * Set the dropdown div's position.
+ * @param {number} primaryX Desired origin point x, in absolute px.
+ * @param {number} primaryY Desired origin point y, in absolute px.
+ * @param {number} secondaryX Secondary/alternative origin point x,
+ *    in absolute px.
+ * @param {number} secondaryY Secondary/alternative origin point y,
+ *    in absolute px.
+ * @return {boolean} True if the menu rendered at the primary origin point.
+ * @private
+ */
+Blockly.DropDownDiv.positionInternal_ = function(
+    primaryX, primaryY, secondaryX, secondaryY) {
+  var metrics = Blockly.DropDownDiv.getPositionMetrics_(primaryX, primaryY,
+      secondaryX, secondaryY);
+
+  // Update arrow CSS.
+  if (metrics.arrowVisible) {
+    Blockly.DropDownDiv.arrow_.style.display = '';
+    Blockly.DropDownDiv.arrow_.style.transform = 'translate(' +
+        metrics.arrowX + 'px,' + metrics.arrowY + 'px) rotate(45deg)';
+    Blockly.DropDownDiv.arrow_.setAttribute('class', metrics.arrowAtTop ?
+        'blocklyDropDownArrow blocklyArrowTop' :
+        'blocklyDropDownArrow blocklyArrowBottom');
+  } else {
+    Blockly.DropDownDiv.arrow_.style.display = 'none';
+  }
+
+  var initialX = Math.floor(metrics.initialX);
+  var initialY = Math.floor(metrics.initialY);
+  var finalX = Math.floor(metrics.finalX);
+  var finalY = Math.floor(metrics.finalY);
+
+  var div = Blockly.DropDownDiv.DIV_;
+  // First apply initial translation.
+  div.style.left = initialX + 'px';
+  div.style.top = initialY + 'px';
+
+  // Show the div.
+  div.style.display = 'block';
+  div.style.opacity = 1;
+  // Add final translate, animated through `transition`.
+  // Coordinates are relative to (initialX, initialY),
+  // where the drop-down is absolutely positioned.
+  var dx = finalX - initialX;
+  var dy = finalY - initialY;
+  div.style.transform = 'translate(' + dx + 'px,' + dy + 'px)';
+
+  return !!metrics.arrowAtTop;
+};
+
+/**
+ * Repositions the dropdownDiv on window resize. If it doesn't know how to
+ * calculate the new position, it will just hide it instead.
+ * @package
+ */
+Blockly.DropDownDiv.repositionForWindowResize = function() {
+  // This condition mainly catches the dropdown div when it is being used as a
+  // dropdown.  It is important not to close it in this case because on Android,
+  // when a field is focused, the soft keyboard opens triggering a window resize
+  // event and we want the dropdown div to stick around so users can type into
+  // it.
+  if (Blockly.DropDownDiv.owner_) {
+    var field = /** @type {!Blockly.Field} */ (Blockly.DropDownDiv.owner_);
+    var block = /** @type {!Blockly.BlockSvg} */ (field.getSourceBlock());
+    var bBox = Blockly.DropDownDiv.positionToField_ ?
+        Blockly.DropDownDiv.getScaledBboxOfField_(field) :
+        Blockly.DropDownDiv.getScaledBboxOfBlock_(block);
+    // If we can fit it, render below the block.
+    var primaryX = bBox.left + (bBox.right - bBox.left) / 2;
+    var primaryY = bBox.bottom;
+    // If we can't fit it, render above the entire parent block.
+    var secondaryX = primaryX;
+    var secondaryY = bBox.top;
+    Blockly.DropDownDiv.positionInternal_(
+        primaryX, primaryY, secondaryX, secondaryY);
+  } else {
+    Blockly.DropDownDiv.hide();
+  }
+};

blockly/core/events/block_events.js

@@ -0,0 +1,573 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Classes for all types of block events.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.BlockBase');
+goog.provide('Blockly.Events.BlockChange');
+goog.provide('Blockly.Events.BlockCreate');
+goog.provide('Blockly.Events.BlockDelete');
+goog.provide('Blockly.Events.BlockMove');
+goog.provide('Blockly.Events.Change');  // Deprecated.
+goog.provide('Blockly.Events.Create');  // Deprecated.
+goog.provide('Blockly.Events.Delete');  // Deprecated.
+goog.provide('Blockly.Events.Move');  // Deprecated.
+
+goog.require('Blockly.connectionTypes');
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.Abstract');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.Coordinate');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.xml');
+goog.require('Blockly.Xml');
+
+goog.requireType('Blockly.Block');
+
+
+/**
+ * Abstract class for a block event.
+ * @param {!Blockly.Block=} opt_block The block this event corresponds to.
+ *     Undefined for a blank event.
+ * @extends {Blockly.Events.Abstract}
+ * @constructor
+ */
+Blockly.Events.BlockBase = function(opt_block) {
+  Blockly.Events.BlockBase.superClass_.constructor.call(this);
+  this.isBlank = typeof opt_block == 'undefined';
+
+  /**
+   * The block ID for the block this event pertains to
+   * @type {string}
+   */
+  this.blockId = this.isBlank ? '' : opt_block.id;
+
+  /**
+   * The workspace identifier for this event.
+   * @type {string}
+   */
+  this.workspaceId = this.isBlank ? '' : opt_block.workspace.id;
+};
+Blockly.utils.object.inherits(Blockly.Events.BlockBase,
+    Blockly.Events.Abstract);
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.BlockBase.prototype.toJson = function() {
+  var json = Blockly.Events.BlockBase.superClass_.toJson.call(this);
+  json['blockId'] = this.blockId;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.BlockBase.prototype.fromJson = function(json) {
+  Blockly.Events.BlockBase.superClass_.fromJson.call(this, json);
+  this.blockId = json['blockId'];
+};
+
+/**
+ * Class for a block change event.
+ * @param {!Blockly.Block=} opt_block The changed block.  Undefined for a blank
+ *     event.
+ * @param {string=} opt_element One of 'field', 'comment', 'disabled', etc.
+ * @param {?string=} opt_name Name of input or field affected, or null.
+ * @param {*=} opt_oldValue Previous value of element.
+ * @param {*=} opt_newValue New value of element.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.BlockChange = function(opt_block, opt_element, opt_name, opt_oldValue,
+    opt_newValue) {
+  Blockly.Events.Change.superClass_.constructor.call(this, opt_block);
+  if (!opt_block) {
+    return;  // Blank event to be populated by fromJson.
+  }
+  this.element = typeof opt_element == 'undefined' ? '' : opt_element;
+  this.name = typeof opt_name == 'undefined' ? '' : opt_name;
+  this.oldValue = typeof opt_oldValue == 'undefined' ? '' : opt_oldValue;
+  this.newValue = typeof opt_newValue == 'undefined' ? '' : opt_newValue;
+};
+Blockly.utils.object.inherits(Blockly.Events.BlockChange, Blockly.Events.BlockBase);
+
+/**
+ * Class for a block change event.
+ * @param {!Blockly.Block=} opt_block The changed block.  Undefined for a blank
+ *     event.
+ * @param {string=} opt_element One of 'field', 'comment', 'disabled', etc.
+ * @param {?string=} opt_name Name of input or field affected, or null.
+ * @param {*=} opt_oldValue Previous value of element.
+ * @param {*=} opt_newValue New value of element.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.Change = Blockly.Events.BlockChange;
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.BlockChange.prototype.type = Blockly.Events.CHANGE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.BlockChange.prototype.toJson = function() {
+  var json = Blockly.Events.BlockChange.superClass_.toJson.call(this);
+  json['element'] = this.element;
+  if (this.name) {
+    json['name'] = this.name;
+  }
+  json['oldValue'] = this.oldValue;
+  json['newValue'] = this.newValue;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.BlockChange.prototype.fromJson = function(json) {
+  Blockly.Events.BlockChange.superClass_.fromJson.call(this, json);
+  this.element = json['element'];
+  this.name = json['name'];
+  this.oldValue = json['oldValue'];
+  this.newValue = json['newValue'];
+};
+
+/**
+ * Does this event record any change of state?
+ * @return {boolean} False if something changed.
+ */
+Blockly.Events.BlockChange.prototype.isNull = function() {
+  return this.oldValue == this.newValue;
+};
+
+/**
+ * Run a change event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.BlockChange.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  var block = workspace.getBlockById(this.blockId);
+  if (!block) {
+    console.warn("Can't change non-existent block: " + this.blockId);
+    return;
+  }
+  if (block.mutator) {
+    // Close the mutator (if open) since we don't want to update it.
+    block.mutator.setVisible(false);
+  }
+  var value = forward ? this.newValue : this.oldValue;
+  switch (this.element) {
+    case 'field':
+      var field = block.getField(this.name);
+      if (field) {
+        field.setValue(value);
+      } else {
+        console.warn("Can't set non-existent field: " + this.name);
+      }
+      break;
+    case 'comment':
+      block.setCommentText(/** @type {string} */ (value) || null);
+      break;
+    case 'collapsed':
+      block.setCollapsed(!!value);
+      break;
+    case 'disabled':
+      block.setEnabled(!value);
+      break;
+    case 'inline':
+      block.setInputsInline(!!value);
+      break;
+    case 'mutation':
+      var oldMutation = '';
+      if (block.mutationToDom) {
+        var oldMutationDom = block.mutationToDom();
+        oldMutation = oldMutationDom && Blockly.Xml.domToText(oldMutationDom);
+      }
+      if (block.domToMutation) {
+        var dom = Blockly.Xml.textToDom(/** @type {string} */ (value) || '<mutation/>');
+        block.domToMutation(dom);
+      }
+      Blockly.Events.fire(new Blockly.Events.BlockChange(
+          block, 'mutation', null, oldMutation, value));
+      break;
+    default:
+      console.warn('Unknown change type: ' + this.element);
+  }
+};
+
+/**
+ * Class for a block creation event.
+ * @param {!Blockly.Block=} opt_block The created block.  Undefined for a blank
+ *     event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.Create = function(opt_block) {
+  Blockly.Events.Create.superClass_.constructor.call(this, opt_block);
+  if (!opt_block) {
+    return;  // Blank event to be populated by fromJson.
+  }
+  if (opt_block.isShadow()) {
+    // Moving shadow blocks is handled via disconnection.
+    this.recordUndo = false;
+  }
+
+  if (opt_block.workspace.rendered) {
+    this.xml = Blockly.Xml.blockToDomWithXY(opt_block);
+  } else {
+    this.xml = Blockly.Xml.blockToDom(opt_block);
+  }
+  this.ids = Blockly.Events.getDescendantIds(opt_block);
+};
+Blockly.utils.object.inherits(Blockly.Events.Create, Blockly.Events.BlockBase);
+
+/**
+ * Class for a block creation event.
+ * @param {!Blockly.Block=} block The created block. Undefined for a blank
+ *     event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.BlockCreate = Blockly.Events.Create;
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Create.prototype.type = Blockly.Events.CREATE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Create.prototype.toJson = function() {
+  var json = Blockly.Events.Create.superClass_.toJson.call(this);
+  json['xml'] = Blockly.Xml.domToText(this.xml);
+  json['ids'] = this.ids;
+  if (!this.recordUndo) {
+    json['recordUndo'] = this.recordUndo;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Create.prototype.fromJson = function(json) {
+  Blockly.Events.Create.superClass_.fromJson.call(this, json);
+  this.xml = Blockly.Xml.textToDom(json['xml']);
+  this.ids = json['ids'];
+  if (json['recordUndo'] !== undefined) {
+    this.recordUndo = json['recordUndo'];
+  }
+};
+
+/**
+ * Run a creation event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.Create.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  if (forward) {
+    var xml = Blockly.utils.xml.createElement('xml');
+    xml.appendChild(this.xml);
+    Blockly.Xml.domToWorkspace(xml, workspace);
+  } else {
+    for (var i = 0, id; (id = this.ids[i]); i++) {
+      var block = workspace.getBlockById(id);
+      if (block) {
+        block.dispose(false);
+      } else if (id == this.blockId) {
+        // Only complain about root-level block.
+        console.warn("Can't uncreate non-existent block: " + id);
+      }
+    }
+  }
+};
+
+/**
+ * Class for a block deletion event.
+ * @param {!Blockly.Block=} opt_block The deleted block.  Undefined for a blank
+ *     event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.Delete = function(opt_block) {
+  Blockly.Events.Delete.superClass_.constructor.call(this, opt_block);
+  if (!opt_block) {
+    return;  // Blank event to be populated by fromJson.
+  }
+  if (opt_block.getParent()) {
+    throw Error('Connected blocks cannot be deleted.');
+  }
+  if (opt_block.isShadow()) {
+    // Respawning shadow blocks is handled via disconnection.
+    this.recordUndo = false;
+  }
+
+  if (opt_block.workspace.rendered) {
+    this.oldXml = Blockly.Xml.blockToDomWithXY(opt_block);
+  } else {
+    this.oldXml = Blockly.Xml.blockToDom(opt_block);
+  }
+  this.ids = Blockly.Events.getDescendantIds(opt_block);
+};
+Blockly.utils.object.inherits(Blockly.Events.Delete, Blockly.Events.BlockBase);
+
+/**
+ * Class for a block deletion event.
+ * @param {?Blockly.Block} block The deleted block.  Null for a blank event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.BlockDelete = Blockly.Events.Delete;
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Delete.prototype.type = Blockly.Events.DELETE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Delete.prototype.toJson = function() {
+  var json = Blockly.Events.Delete.superClass_.toJson.call(this);
+  json['oldXml'] = Blockly.Xml.domToText(this.oldXml);
+  json['ids'] = this.ids;
+  if (!this.recordUndo) {
+    json['recordUndo'] = this.recordUndo;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Delete.prototype.fromJson = function(json) {
+  Blockly.Events.Delete.superClass_.fromJson.call(this, json);
+  this.oldXml = Blockly.Xml.textToDom(json['oldXml']);
+  this.ids = json['ids'];
+  if (json['recordUndo'] !== undefined) {
+    this.recordUndo = json['recordUndo'];
+  }
+};
+
+/**
+ * Run a deletion event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.Delete.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  if (forward) {
+    for (var i = 0, id; (id = this.ids[i]); i++) {
+      var block = workspace.getBlockById(id);
+      if (block) {
+        block.dispose(false);
+      } else if (id == this.blockId) {
+        // Only complain about root-level block.
+        console.warn("Can't delete non-existent block: " + id);
+      }
+    }
+  } else {
+    var xml = Blockly.utils.xml.createElement('xml');
+    xml.appendChild(this.oldXml);
+    Blockly.Xml.domToWorkspace(xml, workspace);
+  }
+};
+
+/**
+ * Class for a block move event.  Created before the move.
+ * @param {!Blockly.Block=} opt_block The moved block.  Undefined for a blank
+ *     event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.Move = function(opt_block) {
+  Blockly.Events.Move.superClass_.constructor.call(this, opt_block);
+  if (!opt_block) {
+    return;  // Blank event to be populated by fromJson.
+  }
+  if (opt_block.isShadow()) {
+    // Moving shadow blocks is handled via disconnection.
+    this.recordUndo = false;
+  }
+
+  var location = this.currentLocation_();
+  this.oldParentId = location.parentId;
+  this.oldInputName = location.inputName;
+  this.oldCoordinate = location.coordinate;
+};
+Blockly.utils.object.inherits(Blockly.Events.Move, Blockly.Events.BlockBase);
+
+/**
+ * Class for a block move event.  Created before the move.
+ * @param {?Blockly.Block} block The moved block.  Null for a blank event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.BlockMove = Blockly.Events.Move;
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Move.prototype.type = Blockly.Events.MOVE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Move.prototype.toJson = function() {
+  var json = Blockly.Events.Move.superClass_.toJson.call(this);
+  if (this.newParentId) {
+    json['newParentId'] = this.newParentId;
+  }
+  if (this.newInputName) {
+    json['newInputName'] = this.newInputName;
+  }
+  if (this.newCoordinate) {
+    json['newCoordinate'] = Math.round(this.newCoordinate.x) + ',' +
+        Math.round(this.newCoordinate.y);
+  }
+  if (!this.recordUndo) {
+    json['recordUndo'] = this.recordUndo;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Move.prototype.fromJson = function(json) {
+  Blockly.Events.Move.superClass_.fromJson.call(this, json);
+  this.newParentId = json['newParentId'];
+  this.newInputName = json['newInputName'];
+  if (json['newCoordinate']) {
+    var xy = json['newCoordinate'].split(',');
+    this.newCoordinate =
+        new Blockly.utils.Coordinate(Number(xy[0]), Number(xy[1]));
+  }
+  if (json['recordUndo'] !== undefined) {
+    this.recordUndo = json['recordUndo'];
+  }
+};
+
+/**
+ * Record the block's new location.  Called after the move.
+ */
+Blockly.Events.Move.prototype.recordNew = function() {
+  var location = this.currentLocation_();
+  this.newParentId = location.parentId;
+  this.newInputName = location.inputName;
+  this.newCoordinate = location.coordinate;
+};
+
+/**
+ * Returns the parentId and input if the block is connected,
+ *   or the XY location if disconnected.
+ * @return {!Object} Collection of location info.
+ * @private
+ */
+Blockly.Events.Move.prototype.currentLocation_ = function() {
+  var workspace = this.getEventWorkspace_();
+  var block = workspace.getBlockById(this.blockId);
+  var location = {};
+  var parent = block.getParent();
+  if (parent) {
+    location.parentId = parent.id;
+    var input = parent.getInputWithBlock(block);
+    if (input) {
+      location.inputName = input.name;
+    }
+  } else {
+    location.coordinate = block.getRelativeToSurfaceXY();
+  }
+  return location;
+};
+
+/**
+ * Does this event record any change of state?
+ * @return {boolean} False if something changed.
+ */
+Blockly.Events.Move.prototype.isNull = function() {
+  return this.oldParentId == this.newParentId &&
+      this.oldInputName == this.newInputName &&
+      Blockly.utils.Coordinate.equals(this.oldCoordinate, this.newCoordinate);
+};
+
+/**
+ * Run a move event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.Move.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  var block = workspace.getBlockById(this.blockId);
+  if (!block) {
+    console.warn("Can't move non-existent block: " + this.blockId);
+    return;
+  }
+  var parentId = forward ? this.newParentId : this.oldParentId;
+  var inputName = forward ? this.newInputName : this.oldInputName;
+  var coordinate = forward ? this.newCoordinate : this.oldCoordinate;
+  var parentBlock = null;
+  if (parentId) {
+    parentBlock = workspace.getBlockById(parentId);
+    if (!parentBlock) {
+      console.warn("Can't connect to non-existent block: " + parentId);
+      return;
+    }
+  }
+  if (block.getParent()) {
+    block.unplug();
+  }
+  if (coordinate) {
+    var xy = block.getRelativeToSurfaceXY();
+    block.moveBy(coordinate.x - xy.x, coordinate.y - xy.y);
+  } else {
+    var blockConnection = block.outputConnection || block.previousConnection;
+    var parentConnection;
+    var connectionType = blockConnection.type;
+    if (inputName) {
+      var input = parentBlock.getInput(inputName);
+      if (input) {
+        parentConnection = input.connection;
+      }
+    } else if (connectionType == Blockly.connectionTypes.PREVIOUS_STATEMENT) {
+      parentConnection = parentBlock.nextConnection;
+    }
+    if (parentConnection) {
+      blockConnection.connect(parentConnection);
+    } else {
+      console.warn("Can't connect to non-existent input: " + inputName);
+    }
+  }
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.CREATE,
+    Blockly.Events.Create);
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.DELETE,
+    Blockly.Events.Delete);
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.CHANGE,
+    Blockly.Events.BlockChange);
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.MOVE,
+    Blockly.Events.Move);

blockly/core/events/events.js

@@ -0,0 +1,477 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of actions in Blockly's editor.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+/**
+ * Events fired as a result of actions in Blockly's editor.
+ * @namespace Blockly.Events
+ */
+goog.provide('Blockly.Events');
+
+goog.require('Blockly.registry');
+goog.require('Blockly.utils');
+
+goog.requireType('Blockly.Block');
+goog.requireType('Blockly.Events.Abstract');
+goog.requireType('Blockly.Workspace');
+
+
+/**
+ * Group ID for new events.  Grouped events are indivisible.
+ * @type {string}
+ * @private
+ */
+Blockly.Events.group_ = '';
+
+/**
+ * Sets whether the next event should be added to the undo stack.
+ * @type {boolean}
+ */
+Blockly.Events.recordUndo = true;
+
+/**
+ * Allow change events to be created and fired.
+ * @type {number}
+ * @private
+ */
+Blockly.Events.disabled_ = 0;
+
+/**
+ * Name of event that creates a block. Will be deprecated for BLOCK_CREATE.
+ * @const
+ */
+Blockly.Events.CREATE = 'create';
+
+/**
+ * Name of event that creates a block.
+ * @const
+ */
+Blockly.Events.BLOCK_CREATE = Blockly.Events.CREATE;
+
+/**
+ * Name of event that deletes a block. Will be deprecated for BLOCK_DELETE.
+ * @const
+ */
+Blockly.Events.DELETE = 'delete';
+
+/**
+ * Name of event that deletes a block.
+ * @const
+ */
+Blockly.Events.BLOCK_DELETE = Blockly.Events.DELETE;
+
+/**
+ * Name of event that changes a block. Will be deprecated for BLOCK_CHANGE.
+ * @const
+ */
+Blockly.Events.CHANGE = 'change';
+
+/**
+ * Name of event that changes a block.
+ * @const
+ */
+Blockly.Events.BLOCK_CHANGE = Blockly.Events.CHANGE;
+
+/**
+ * Name of event that moves a block. Will be deprecated for BLOCK_MOVE.
+ * @const
+ */
+Blockly.Events.MOVE = 'move';
+
+/**
+ * Name of event that moves a block.
+ * @const
+ */
+Blockly.Events.BLOCK_MOVE = Blockly.Events.MOVE;
+
+/**
+ * Name of event that creates a variable.
+ * @const
+ */
+Blockly.Events.VAR_CREATE = 'var_create';
+
+/**
+ * Name of event that deletes a variable.
+ * @const
+ */
+Blockly.Events.VAR_DELETE = 'var_delete';
+
+/**
+ * Name of event that renames a variable.
+ * @const
+ */
+Blockly.Events.VAR_RENAME = 'var_rename';
+
+/**
+ * Name of generic event that records a UI change.
+ * @const
+ */
+Blockly.Events.UI = 'ui';
+
+/**
+ * Name of event that record a block drags a block.
+ * @const
+ */
+Blockly.Events.BLOCK_DRAG = 'drag';
+
+/**
+ * Name of event that records a change in selected element.
+ * @const
+ */
+Blockly.Events.SELECTED = 'selected';
+
+/**
+ * Name of event that records a click.
+ * @const
+ */
+Blockly.Events.CLICK = 'click';
+
+/**
+ * Name of event that records a marker move.
+ * @const
+ */
+Blockly.Events.MARKER_MOVE = 'marker_move';
+
+/**
+ * Name of event that records a bubble open.
+ * @const
+ */
+Blockly.Events.BUBBLE_OPEN = 'bubble_open';
+
+/**
+ * Name of event that records a trashcan open.
+ * @const
+ */
+Blockly.Events.TRASHCAN_OPEN = 'trashcan_open';
+
+/**
+ * Name of event that records a toolbox item select.
+ * @const
+ */
+Blockly.Events.TOOLBOX_ITEM_SELECT = 'toolbox_item_select';
+
+/**
+ * Name of event that records a theme change.
+ * @const
+ */
+Blockly.Events.THEME_CHANGE = 'theme_change';
+
+/**
+ * Name of event that records a viewport change.
+ * @const
+ */
+Blockly.Events.VIEWPORT_CHANGE = 'viewport_change';
+
+/**
+ * Name of event that creates a comment.
+ * @const
+ */
+Blockly.Events.COMMENT_CREATE = 'comment_create';
+
+/**
+ * Name of event that deletes a comment.
+ * @const
+ */
+Blockly.Events.COMMENT_DELETE = 'comment_delete';
+
+/**
+ * Name of event that changes a comment.
+ * @const
+ */
+Blockly.Events.COMMENT_CHANGE = 'comment_change';
+
+/**
+ * Name of event that moves a comment.
+ * @const
+ */
+Blockly.Events.COMMENT_MOVE = 'comment_move';
+
+/**
+ * Name of event that records a workspace load.
+ */
+Blockly.Events.FINISHED_LOADING = 'finished_loading';
+
+/**
+ * Type of events that cause objects to be bumped back into the visible
+ * portion of the workspace.
+ *
+ * Not to be confused with bumping so that disconnected connections do not
+ * appear connected.
+ * @typedef {!Blockly.Events.BlockCreate|!Blockly.Events.BlockMove|
+ * !Blockly.Events.CommentCreate|!Blockly.Events.CommentMove}
+ */
+Blockly.Events.BumpEvent;
+
+/**
+ * List of events that cause objects to be bumped back into the visible
+ * portion of the workspace.
+ *
+ * Not to be confused with bumping so that disconnected connections do not
+ * appear connected.
+ * @const
+ */
+Blockly.Events.BUMP_EVENTS = [
+  Blockly.Events.BLOCK_CREATE,
+  Blockly.Events.BLOCK_MOVE,
+  Blockly.Events.COMMENT_CREATE,
+  Blockly.Events.COMMENT_MOVE
+];
+
+/**
+ * List of events queued for firing.
+ * @private
+ */
+Blockly.Events.FIRE_QUEUE_ = [];
+
+/**
+ * Create a custom event and fire it.
+ * @param {!Blockly.Events.Abstract} event Custom data for event.
+ */
+Blockly.Events.fire = function(event) {
+  if (!Blockly.Events.isEnabled()) {
+    return;
+  }
+  if (!Blockly.Events.FIRE_QUEUE_.length) {
+    // First event added; schedule a firing of the event queue.
+    setTimeout(Blockly.Events.fireNow_, 0);
+  }
+  Blockly.Events.FIRE_QUEUE_.push(event);
+};
+
+/**
+ * Fire all queued events.
+ * @private
+ */
+Blockly.Events.fireNow_ = function() {
+  var queue = Blockly.Events.filter(Blockly.Events.FIRE_QUEUE_, true);
+  Blockly.Events.FIRE_QUEUE_.length = 0;
+  for (var i = 0, event; (event = queue[i]); i++) {
+    if (!event.workspaceId) {
+      continue;
+    }
+    var workspace = Blockly.Workspace.getById(event.workspaceId);
+    if (workspace) {
+      workspace.fireChangeListener(event);
+    }
+  }
+};
+
+/**
+ * Filter the queued events and merge duplicates.
+ * @param {!Array<!Blockly.Events.Abstract>} queueIn Array of events.
+ * @param {boolean} forward True if forward (redo), false if backward (undo).
+ * @return {!Array<!Blockly.Events.Abstract>} Array of filtered events.
+ */
+Blockly.Events.filter = function(queueIn, forward) {
+  var queue = queueIn.slice();  // Shallow copy of queue.
+  if (!forward) {
+    // Undo is merged in reverse order.
+    queue.reverse();
+  }
+  var mergedQueue = [];
+  var hash = Object.create(null);
+  // Merge duplicates.
+  for (var i = 0, event; (event = queue[i]); i++) {
+    if (!event.isNull()) {
+      // Treat all UI events as the same type in hash table.
+      var eventType = event.isUiEvent ? Blockly.Events.UI : event.type;
+      var key = [eventType, event.blockId, event.workspaceId].join(' ');
+
+      var lastEntry = hash[key];
+      var lastEvent = lastEntry ? lastEntry.event : null;
+      if (!lastEntry) {
+        // Each item in the hash table has the event and the index of that event
+        // in the input array.  This lets us make sure we only merge adjacent
+        // move events.
+        hash[key] = { event: event, index: i};
+        mergedQueue.push(event);
+      } else if (event.type == Blockly.Events.MOVE &&
+          lastEntry.index == i - 1) {
+        // Merge move events.
+        lastEvent.newParentId = event.newParentId;
+        lastEvent.newInputName = event.newInputName;
+        lastEvent.newCoordinate = event.newCoordinate;
+        lastEntry.index = i;
+      } else if (event.type == Blockly.Events.CHANGE &&
+          event.element == lastEvent.element &&
+          event.name == lastEvent.name) {
+        // Merge change events.
+        lastEvent.newValue = event.newValue;
+      } else if (event.type == Blockly.Events.VIEWPORT_CHANGE) {
+        // Merge viewport change events.
+        lastEvent.viewTop = event.viewTop;
+        lastEvent.viewLeft = event.viewLeft;
+        lastEvent.scale = event.scale;
+        lastEvent.oldScale = event.oldScale;
+      } else if (event.type == Blockly.Events.CLICK &&
+          lastEvent.type == Blockly.Events.BUBBLE_OPEN) {
+        // Drop click events caused by opening/closing bubbles.
+      } else {
+        // Collision: newer events should merge into this event to maintain
+        // order.
+        hash[key] = {event: event, index: i};
+        mergedQueue.push(event);
+      }
+    }
+  }
+  // Filter out any events that have become null due to merging.
+  queue = mergedQueue.filter(function(e) { return !e.isNull(); });
+  if (!forward) {
+    // Restore undo order.
+    queue.reverse();
+  }
+  // Move mutation events to the top of the queue.
+  // Intentionally skip first event.
+  for (var i = 1, event; (event = queue[i]); i++) {
+    if (event.type == Blockly.Events.CHANGE &&
+        event.element == 'mutation') {
+      queue.unshift(queue.splice(i, 1)[0]);
+    }
+  }
+  return queue;
+};
+
+/**
+ * Modify pending undo events so that when they are fired they don't land
+ * in the undo stack.  Called by Blockly.Workspace.clearUndo.
+ */
+Blockly.Events.clearPendingUndo = function() {
+  for (var i = 0, event; (event = Blockly.Events.FIRE_QUEUE_[i]); i++) {
+    event.recordUndo = false;
+  }
+};
+
+/**
+ * Stop sending events.  Every call to this function MUST also call enable.
+ */
+Blockly.Events.disable = function() {
+  Blockly.Events.disabled_++;
+};
+
+/**
+ * Start sending events.  Unless events were already disabled when the
+ * corresponding call to disable was made.
+ */
+Blockly.Events.enable = function() {
+  Blockly.Events.disabled_--;
+};
+
+/**
+ * Returns whether events may be fired or not.
+ * @return {boolean} True if enabled.
+ */
+Blockly.Events.isEnabled = function() {
+  return Blockly.Events.disabled_ == 0;
+};
+
+/**
+ * Current group.
+ * @return {string} ID string.
+ */
+Blockly.Events.getGroup = function() {
+  return Blockly.Events.group_;
+};
+
+/**
+ * Start or stop a group.
+ * @param {boolean|string} state True to start new group, false to end group.
+ *   String to set group explicitly.
+ */
+Blockly.Events.setGroup = function(state) {
+  if (typeof state == 'boolean') {
+    Blockly.Events.group_ = state ? Blockly.utils.genUid() : '';
+  } else {
+    Blockly.Events.group_ = state;
+  }
+};
+
+/**
+ * Compute a list of the IDs of the specified block and all its descendants.
+ * @param {!Blockly.Block} block The root block.
+ * @return {!Array<string>} List of block IDs.
+ * @package
+ */
+Blockly.Events.getDescendantIds = function(block) {
+  var ids = [];
+  var descendants = block.getDescendants(false);
+  for (var i = 0, descendant; (descendant = descendants[i]); i++) {
+    ids[i] = descendant.id;
+  }
+  return ids;
+};
+
+/**
+ * Decode the JSON into an event.
+ * @param {!Object} json JSON representation.
+ * @param {!Blockly.Workspace} workspace Target workspace for event.
+ * @return {!Blockly.Events.Abstract} The event represented by the JSON.
+ * @throws {Error} if an event type is not found in the registry.
+ */
+Blockly.Events.fromJson = function(json, workspace) {
+  var eventClass = Blockly.Events.get(json.type);
+  if (!eventClass) {
+    throw Error('Unknown event type.');
+  }
+  var event = new eventClass();
+  event.fromJson(json);
+  event.workspaceId = workspace.id;
+  return event;
+};
+
+/**
+ * Gets the class for a specific event type from the registry.
+ * @param {string} eventType The type of the event to get.
+ * @return {?function(new:Blockly.Events.Abstract, ...?)} The event class with
+ *     the given type or null if none exists.
+ */
+Blockly.Events.get = function(eventType) {
+  return Blockly.registry.getClass(Blockly.registry.Type.EVENT, eventType);
+};
+
+/**
+ * Enable/disable a block depending on whether it is properly connected.
+ * Use this on applications where all blocks should be connected to a top block.
+ * Recommend setting the 'disable' option to 'false' in the config so that
+ * users don't try to re-enable disabled orphan blocks.
+ * @param {!Blockly.Events.Abstract} event Custom data for event.
+ */
+Blockly.Events.disableOrphans = function(event) {
+  if (event.type == Blockly.Events.MOVE ||
+      event.type == Blockly.Events.CREATE) {
+    if (!event.workspaceId) {
+      return;
+    }
+    var workspace = Blockly.Workspace.getById(event.workspaceId);
+    var block = workspace.getBlockById(event.blockId);
+    if (block) {
+      // Changing blocks as part of this event shouldn't be undoable.
+      var initialUndoFlag = Blockly.Events.recordUndo;
+      try {
+        Blockly.Events.recordUndo = false;
+        var parent = block.getParent();
+        if (parent && parent.isEnabled()) {
+          var children = block.getDescendants(false);
+          for (var i = 0, child; (child = children[i]); i++) {
+            child.setEnabled(true);
+          }
+        } else if ((block.outputConnection || block.previousConnection) &&
+                  !workspace.isDragging()) {
+          do {
+            block.setEnabled(false);
+            block = block.getNextBlock();
+          } while (block);
+        }
+      } finally {
+        Blockly.Events.recordUndo = initialUndoFlag;
+      }
+    }
+  }
+};

blockly/core/events/events_abstract.js

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Abstract class for events fired as a result of actions in
+ *     Blockly's editor.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.Abstract');
+
+goog.require('Blockly.Events');
+
+goog.requireType('Blockly.Workspace');
+
+
+/**
+ * Abstract class for an event.
+ * @constructor
+ */
+Blockly.Events.Abstract = function() {
+
+  /**
+   * Whether or not the event is blank (to be populated by fromJson).
+   * @type {?boolean}
+   */
+  this.isBlank = null;
+
+  /**
+   * The workspace identifier for this event.
+   * @type {string|undefined}
+   */
+  this.workspaceId = undefined;
+
+  /**
+   * The event group id for the group this event belongs to. Groups define
+   * events that should be treated as an single action from the user's
+   * perspective, and should be undone together.
+   * @type {string}
+   */
+  this.group = Blockly.Events.getGroup();
+
+  /**
+   * Sets whether the event should be added to the undo stack.
+   * @type {boolean}
+   */
+  this.recordUndo = Blockly.Events.recordUndo;
+};
+
+/**
+ * Whether or not the event is a UI event.
+ * @type {boolean}
+ */
+Blockly.Events.Abstract.prototype.isUiEvent = false;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Abstract.prototype.toJson = function() {
+  var json = {
+    'type': this.type
+  };
+  if (this.group) {
+    json['group'] = this.group;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Abstract.prototype.fromJson = function(json) {
+  this.isBlank = false;
+  this.group = json['group'];
+};
+
+/**
+ * Does this event record any change of state?
+ * @return {boolean} True if null, false if something changed.
+ */
+Blockly.Events.Abstract.prototype.isNull = function() {
+  return false;
+};
+
+/**
+ * Run an event.
+ * @param {boolean} _forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.Abstract.prototype.run = function(_forward) {
+  // Defined by subclasses.
+};
+
+/**
+ * Get workspace the event belongs to.
+ * @return {!Blockly.Workspace} The workspace the event belongs to.
+ * @throws {Error} if workspace is null.
+ * @protected
+ */
+Blockly.Events.Abstract.prototype.getEventWorkspace_ = function() {
+  if (this.workspaceId) {
+    var workspace = Blockly.Workspace.getById(this.workspaceId);
+  }
+  if (!workspace) {
+    throw Error('Workspace is null. Event must have been generated from real' +
+        ' Blockly events.');
+  }
+  return workspace;
+};

blockly/core/events/events_block_drag.js

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a block drag.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.BlockDrag');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+goog.requireType('Blockly.Block');
+
+
+/**
+ * Class for a block drag event.
+ * @param {!Blockly.Block=} opt_block The top block in the stack that is being
+ *    dragged. Undefined for a blank event.
+ * @param {boolean=} opt_isStart Whether this is the start of a block drag.
+ *    Undefined for a blank event.
+ * @param {!Array<!Blockly.Block>=} opt_blocks The blocks affected by this
+ *    drag. Undefined for a blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.BlockDrag = function(opt_block, opt_isStart, opt_blocks) {
+  var workspaceId = opt_block ? opt_block.workspace.id : undefined;
+  Blockly.Events.BlockDrag.superClass_.constructor.call(this, workspaceId);
+  this.blockId = opt_block ? opt_block.id : null;
+
+  /**
+   * Whether this is the start of a block drag.
+   * @type {boolean|undefined}
+   */
+  this.isStart = opt_isStart;
+
+  /**
+   * The blocks affected by this drag event.
+   * @type {!Array<!Blockly.Block>|undefined}
+   */
+  this.blocks = opt_blocks;
+};
+Blockly.utils.object.inherits(Blockly.Events.BlockDrag, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.BlockDrag.prototype.type = Blockly.Events.BLOCK_DRAG;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.BlockDrag.prototype.toJson = function() {
+  var json = Blockly.Events.BlockDrag.superClass_.toJson.call(this);
+  json['isStart'] = this.isStart;
+  json['blockId'] = this.blockId;
+  json['blocks'] = this.blocks;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.BlockDrag.prototype.fromJson = function(json) {
+  Blockly.Events.BlockDrag.superClass_.fromJson.call(this, json);
+  this.isStart = json['isStart'];
+  this.blockId = json['blockId'];
+  this.blocks = json['blocks'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.BLOCK_DRAG, Blockly.Events.BlockDrag);

blockly/core/events/events_bubble_open.js

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of bubble open.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.BubbleOpen');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+goog.requireType('Blockly.BlockSvg');
+
+
+/**
+ * Class for a bubble open event.
+ * @param {Blockly.BlockSvg} opt_block The associated block. Undefined for a
+ *    blank event.
+ * @param {boolean=} opt_isOpen Whether the bubble is opening (false if
+ *    closing). Undefined for a blank event.
+ * @param {string=} opt_bubbleType The type of bubble. One of 'mutator', 'comment'
+ *    or 'warning'. Undefined for a blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.BubbleOpen = function(opt_block, opt_isOpen, opt_bubbleType) {
+  var workspaceId = opt_block ? opt_block.workspace.id : undefined;
+  Blockly.Events.BubbleOpen.superClass_.constructor.call(this, workspaceId);
+  this.blockId = opt_block ? opt_block.id : null;
+
+  /**
+   * Whether the bubble is opening (false if closing).
+   * @type {boolean|undefined}
+   */
+  this.isOpen = opt_isOpen;
+
+  /**
+   * The type of bubble. One of 'mutator', 'comment', or 'warning'.
+   * @type {string|undefined}
+   */
+  this.bubbleType = opt_bubbleType;
+};
+Blockly.utils.object.inherits(Blockly.Events.BubbleOpen, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.BubbleOpen.prototype.type = Blockly.Events.BUBBLE_OPEN;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.BubbleOpen.prototype.toJson = function() {
+  var json = Blockly.Events.BubbleOpen.superClass_.toJson.call(this);
+  json['isOpen'] = this.isOpen;
+  json['bubbleType'] = this.bubbleType;
+  json['blockId'] = this.blockId;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.BubbleOpen.prototype.fromJson = function(json) {
+  Blockly.Events.BubbleOpen.superClass_.fromJson.call(this, json);
+  this.isOpen = json['isOpen'];
+  this.bubbleType = json['bubbleType'];
+  this.blockId = json['blockId'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.BUBBLE_OPEN, Blockly.Events.BubbleOpen);

blockly/core/events/events_click.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of UI click in Blockly's editor.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.Click');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+goog.requireType('Blockly.Block');
+
+
+/**
+ * Class for a click event.
+ * @param {?Blockly.Block=} opt_block The affected block. Null for click events
+ *    that do not have an associated block (i.e. workspace click). Undefined
+ *    for a blank event.
+ * @param {?string=} opt_workspaceId The workspace identifier for this event.
+ *    Not used if block is passed. Undefined for a blank event.
+ * @param {string=} opt_targetType The type of element targeted by this click
+ *    event. Undefined for a blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.Click = function(opt_block, opt_workspaceId, opt_targetType) {
+  var workspaceId = opt_block ? opt_block.workspace.id : opt_workspaceId;
+  Blockly.Events.Click.superClass_.constructor.call(this, workspaceId);
+  this.blockId = opt_block ? opt_block.id : null;
+
+  /**
+   * The type of element targeted by this click event.
+   * @type {string|undefined}
+   */
+  this.targetType = opt_targetType;
+};
+Blockly.utils.object.inherits(Blockly.Events.Click, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Click.prototype.type = Blockly.Events.CLICK;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Click.prototype.toJson = function() {
+  var json = Blockly.Events.Click.superClass_.toJson.call(this);
+  json['targetType'] = this.targetType;
+  if (this.blockId) {
+    json['blockId'] = this.blockId;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Click.prototype.fromJson = function(json) {
+  Blockly.Events.Click.superClass_.fromJson.call(this, json);
+  this.targetType = json['targetType'];
+  this.blockId = json['blockId'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.CLICK,
+    Blockly.Events.Click);

blockly/core/events/events_marker_move.js

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of a marker move.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.MarkerMove');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+goog.requireType('Blockly.ASTNode');
+goog.requireType('Blockly.Block');
+goog.requireType('Blockly.Workspace');
+
+
+/**
+ * Class for a marker move event.
+ * @param {?Blockly.Block=} opt_block The affected block. Null if current node
+ *    is of type workspace. Undefined for a blank event.
+ * @param {boolean=} isCursor Whether this is a cursor event. Undefined for a
+ *    blank event.
+ * @param {?Blockly.ASTNode=} opt_oldNode The old node the marker used to be on.
+ *    Undefined for a blank event.
+ * @param {!Blockly.ASTNode=} opt_newNode The new node the marker is now on.
+ *    Undefined for a blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.MarkerMove = function(opt_block, isCursor, opt_oldNode,
+    opt_newNode) {
+  var workspaceId = opt_block ? opt_block.workspace.id : undefined;
+  if (opt_newNode && opt_newNode.getType() == Blockly.ASTNode.types.WORKSPACE) {
+    workspaceId =
+        (/** @type {!Blockly.Workspace} */ (opt_newNode.getLocation())).id;
+  }
+  Blockly.Events.MarkerMove.superClass_.constructor.call(this, workspaceId);
+
+  /**
+   * The workspace identifier for this event.
+   * @type {?string}
+   */
+  this.blockId = opt_block ? opt_block.id : null;
+
+  /**
+   * The old node the marker used to be on.
+   * @type {?Blockly.ASTNode|undefined}
+   */
+  this.oldNode = opt_oldNode;
+
+  /**
+   * The new node the  marker is now on.
+   * @type {Blockly.ASTNode|undefined}
+   */
+  this.newNode = opt_newNode;
+
+  /**
+   * Whether this is a cursor event.
+   * @type {boolean|undefined}
+   */
+  this.isCursor = isCursor;
+};
+Blockly.utils.object.inherits(Blockly.Events.MarkerMove, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.MarkerMove.prototype.type = Blockly.Events.MARKER_MOVE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.MarkerMove.prototype.toJson = function() {
+  var json = Blockly.Events.MarkerMove.superClass_.toJson.call(this);
+  json['isCursor'] = this.isCursor;
+  json['blockId'] = this.blockId;
+  json['oldNode'] = this.oldNode;
+  json['newNode'] = this.newNode;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.MarkerMove.prototype.fromJson = function(json) {
+  Blockly.Events.MarkerMove.superClass_.fromJson.call(this, json);
+  this.isCursor = json['isCursor'];
+  this.blockId = json['blockId'];
+  this.oldNode = json['oldNode'];
+  this.newNode = json['newNode'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.MARKER_MOVE, Blockly.Events.MarkerMove);

blockly/core/events/events_selected.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of element select action.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.Selected');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a selected event.
+ * @param {?string=} opt_oldElementId The ID of the previously selected
+ *    element. Null if no element last selected. Undefined for a blank event.
+ * @param {?string=} opt_newElementId The ID of the selected element. Null if no
+ *    element currently selected (deselect). Undefined for a blank event.
+ * @param {string=} opt_workspaceId The workspace identifier for this event.
+ *    Null if no element previously selected. Undefined for a blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.Selected = function(opt_oldElementId, opt_newElementId,
+    opt_workspaceId) {
+  Blockly.Events.Selected.superClass_.constructor.call(this, opt_workspaceId);
+
+  /**
+   * The id of the last selected element.
+   * @type {?string|undefined}
+   */
+  this.oldElementId = opt_oldElementId;
+
+  /**
+   * The id of the selected element.
+   * @type {?string|undefined}
+   */
+  this.newElementId = opt_newElementId;
+};
+Blockly.utils.object.inherits(Blockly.Events.Selected, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Selected.prototype.type = Blockly.Events.SELECTED;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Selected.prototype.toJson = function() {
+  var json = Blockly.Events.Selected.superClass_.toJson.call(this);
+  json['oldElementId'] = this.oldElementId;
+  json['newElementId'] = this.newElementId;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Selected.prototype.fromJson = function(json) {
+  Blockly.Events.Selected.superClass_.fromJson.call(this, json);
+  this.oldElementId = json['oldElementId'];
+  this.newElementId = json['newElementId'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.SELECTED,
+    Blockly.Events.Selected);

blockly/core/events/events_theme_change.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of a theme update.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.ThemeChange');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a theme change event.
+ * @param {string=} opt_themeName The theme name. Undefined for a blank event.
+ * @param {string=} opt_workspaceId The workspace identifier for this event.
+ *    event. Undefined for a blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.ThemeChange = function(opt_themeName, opt_workspaceId) {
+  Blockly.Events.ThemeChange.superClass_.constructor.call(this, opt_workspaceId);
+
+  /**
+   * The theme name.
+   * @type {string|undefined}
+   */
+  this.themeName = opt_themeName;
+};
+Blockly.utils.object.inherits(Blockly.Events.ThemeChange, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.ThemeChange.prototype.type = Blockly.Events.THEME_CHANGE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.ThemeChange.prototype.toJson = function() {
+  var json = Blockly.Events.ThemeChange.superClass_.toJson.call(this);
+  json['themeName'] = this.themeName;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.ThemeChange.prototype.fromJson = function(json) {
+  Blockly.Events.ThemeChange.superClass_.fromJson.call(this, json);
+  this.themeName = json['themeName'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.THEME_CHANGE, Blockly.Events.ThemeChange);

blockly/core/events/events_toolbox_item_select.js

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of selecting an item on the toolbox.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.ToolboxItemSelect');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a toolbox item select event.
+ * @param {?string=} opt_oldItem The previously selected toolbox item. Undefined
+ *    for a blank event.
+ * @param {?string=} opt_newItem The newly selected toolbox item. Undefined for
+ *    a blank event.
+ * @param {string=} opt_workspaceId The workspace identifier for this event.
+ *    Undefined for a blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.ToolboxItemSelect = function(opt_oldItem, opt_newItem,
+    opt_workspaceId) {
+  Blockly.Events.ToolboxItemSelect.superClass_.constructor.call(
+      this, opt_workspaceId);
+
+  /**
+   * The previously selected toolbox item.
+   * @type {?string|undefined}
+   */
+  this.oldItem = opt_oldItem;
+
+  /**
+   * The newly selected toolbox item.
+   * @type {?string|undefined}
+   */
+  this.newItem = opt_newItem;
+};
+Blockly.utils.object.inherits(Blockly.Events.ToolboxItemSelect, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.ToolboxItemSelect.prototype.type = Blockly.Events.TOOLBOX_ITEM_SELECT;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.ToolboxItemSelect.prototype.toJson = function() {
+  var json = Blockly.Events.ToolboxItemSelect.superClass_.toJson.call(this);
+  json['oldItem'] = this.oldItem;
+  json['newItem'] = this.newItem;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.ToolboxItemSelect.prototype.fromJson = function(json) {
+  Blockly.Events.ToolboxItemSelect.superClass_.fromJson.call(this, json);
+  this.oldItem = json['oldItem'];
+  this.newItem = json['newItem'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.TOOLBOX_ITEM_SELECT, Blockly.Events.ToolboxItemSelect);

blockly/core/events/events_trashcan_open.js

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of trashcan flyout open and close.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.TrashcanOpen');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a trashcan open event.
+ * @param {boolean=} opt_isOpen Whether the trashcan flyout is opening (false if
+ *    opening). Undefined for a blank event.
+ * @param {string=} opt_workspaceId The workspace identifier for this event.
+ *    Undefined for a blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.TrashcanOpen = function(opt_isOpen, opt_workspaceId) {
+  Blockly.Events.TrashcanOpen.superClass_.constructor.call(this, opt_workspaceId);
+
+  /**
+   * Whether the trashcan flyout is opening (false if closing).
+   * @type {boolean|undefined}
+   */
+  this.isOpen = opt_isOpen;
+};
+Blockly.utils.object.inherits(Blockly.Events.TrashcanOpen, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.TrashcanOpen.prototype.type = Blockly.Events.TRASHCAN_OPEN;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.TrashcanOpen.prototype.toJson = function() {
+  var json = Blockly.Events.TrashcanOpen.superClass_.toJson.call(this);
+  json['isOpen'] = this.isOpen;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.TrashcanOpen.prototype.fromJson = function(json) {
+  Blockly.Events.TrashcanOpen.superClass_.fromJson.call(this, json);
+  this.isOpen = json['isOpen'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.TRASHCAN_OPEN, Blockly.Events.TrashcanOpen);

blockly/core/events/events_viewport.js

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of a viewport change.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.ViewportChange');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.UiBase');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a viewport change event.
+ * @param {number=} opt_top Top-edge of the visible portion of the workspace,
+ *    relative to the workspace origin. Undefined for a blank event.
+ * @param {number=} opt_left Left-edge of the visible portion of the workspace,
+ *    relative to the workspace origin. Undefined for a blank event.
+ * @param {number=} opt_scale The scale of the workspace. Undefined for a blank
+ *    event.
+ * @param {string=} opt_workspaceId The workspace identifier for this event.
+ *    Undefined for a blank event.
+ * @param {number=} opt_oldScale The old scale of the workspace. Undefined for a
+ *    blank event.
+ * @extends {Blockly.Events.UiBase}
+ * @constructor
+ */
+Blockly.Events.ViewportChange = function(opt_top, opt_left, opt_scale,
+    opt_workspaceId, opt_oldScale) {
+  Blockly.Events.ViewportChange.superClass_.constructor.call(this, opt_workspaceId);
+
+  /**
+   * Top-edge of the visible portion of the workspace, relative to the workspace
+   * origin.
+   * @type {number|undefined}
+   */
+  this.viewTop = opt_top;
+
+  /**
+   * Left-edge of the visible portion of the workspace, relative to the
+   * workspace origin.
+   * @type {number|undefined}
+   */
+  this.viewLeft = opt_left;
+
+  /**
+   * The scale of the workspace.
+   * @type {number|undefined}
+   */
+  this.scale = opt_scale;
+
+  /**
+   * The old scale of the workspace.
+   * @type {number|undefined}
+   */
+  this.oldScale = opt_oldScale;
+};
+Blockly.utils.object.inherits(Blockly.Events.ViewportChange,
+    Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.ViewportChange.prototype.type = Blockly.Events.VIEWPORT_CHANGE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.ViewportChange.prototype.toJson = function() {
+  var json = Blockly.Events.ViewportChange.superClass_.toJson.call(this);
+  json['viewTop'] = this.viewTop;
+  json['viewLeft'] = this.viewLeft;
+  json['scale'] = this.scale;
+  json['oldScale'] = this.oldScale;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.ViewportChange.prototype.fromJson = function(json) {
+  Blockly.Events.ViewportChange.superClass_.fromJson.call(this, json);
+  this.viewTop = json['viewTop'];
+  this.viewLeft = json['viewLeft'];
+  this.scale = json['scale'];
+  this.oldScale = json['oldScale'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.VIEWPORT_CHANGE, Blockly.Events.ViewportChange);

blockly/core/events/ui_events.js

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of UI actions in Blockly's editor.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.Ui');
+goog.provide('Blockly.Events.UiBase');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.Abstract');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+goog.requireType('Blockly.Block');
+
+
+/**
+ * Base class for a UI event.
+ * UI events are events that don't need to be sent over the wire for multi-user
+ * editing to work (e.g. scrolling the workspace, zooming, opening toolbox
+ * categories).
+ * UI events do not undo or redo.
+ * @param {string=} opt_workspaceId The workspace identifier for this event.
+ *    Undefined for a blank event.
+ * @extends {Blockly.Events.Abstract}
+ * @constructor
+ */
+Blockly.Events.UiBase = function(opt_workspaceId) {
+  Blockly.Events.UiBase.superClass_.constructor.call(this);
+
+  /**
+   * Whether or not the event is blank (to be populated by fromJson).
+   * @type {boolean}
+   */
+  this.isBlank = typeof opt_workspaceId == 'undefined';
+
+  /**
+   * The workspace identifier for this event.
+   * @type {string}
+   */
+  this.workspaceId = opt_workspaceId ? opt_workspaceId : '';
+
+  // UI events do not undo or redo.
+  this.recordUndo = false;
+};
+Blockly.utils.object.inherits(Blockly.Events.UiBase, Blockly.Events.Abstract);
+
+/**
+ * Whether or not the event is a UI event.
+ * @type {boolean}
+ */
+Blockly.Events.UiBase.prototype.isUiEvent = true;
+
+/**
+ * Class for a UI event.
+ * @param {?Blockly.Block=} opt_block The affected block.  Null for UI events
+ *     that do not have an associated block.  Undefined for a blank event.
+ * @param {string=} opt_element One of 'selected', 'comment', 'mutatorOpen',
+ *     etc.
+ * @param {*=} opt_oldValue Previous value of element.
+ * @param {*=} opt_newValue New value of element.
+ * @extends {Blockly.Events.UiBase}
+ * @deprecated December 2020. Instead use a more specific UI event.
+ * @constructor
+ */
+Blockly.Events.Ui = function(opt_block, opt_element, opt_oldValue,
+    opt_newValue) {
+  var workspaceId = opt_block ? opt_block.workspace.id : undefined;
+  Blockly.Events.Ui.superClass_.constructor.call(this, workspaceId);
+
+  this.blockId = opt_block ? opt_block.id : null;
+  this.element = typeof opt_element == 'undefined' ? '' : opt_element;
+  this.oldValue = typeof opt_oldValue == 'undefined' ? '' : opt_oldValue;
+  this.newValue = typeof opt_newValue == 'undefined' ? '' : opt_newValue;
+};
+Blockly.utils.object.inherits(Blockly.Events.Ui, Blockly.Events.UiBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Ui.prototype.type = Blockly.Events.UI;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Ui.prototype.toJson = function() {
+  var json = Blockly.Events.Ui.superClass_.toJson.call(this);
+  json['element'] = this.element;
+  if (this.newValue !== undefined) {
+    json['newValue'] = this.newValue;
+  }
+  if (this.blockId) {
+    json['blockId'] = this.blockId;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Ui.prototype.fromJson = function(json) {
+  Blockly.Events.Ui.superClass_.fromJson.call(this, json);
+  this.element = json['element'];
+  this.newValue = json['newValue'];
+  this.blockId = json['blockId'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.UI,
+    Blockly.Events.Ui);

blockly/core/events/variable_events.js

@@ -0,0 +1,250 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Classes for all types of variable events.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.VarBase');
+goog.provide('Blockly.Events.VarCreate');
+goog.provide('Blockly.Events.VarDelete');
+goog.provide('Blockly.Events.VarRename');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.Abstract');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+goog.requireType('Blockly.VariableModel');
+
+
+/**
+ * Abstract class for a variable event.
+ * @param {!Blockly.VariableModel=} opt_variable The variable this event
+ *     corresponds to.  Undefined for a blank event.
+ * @extends {Blockly.Events.Abstract}
+ * @constructor
+ */
+Blockly.Events.VarBase = function(opt_variable) {
+  Blockly.Events.VarBase.superClass_.constructor.call(this);
+  this.isBlank = typeof opt_variable == 'undefined';
+
+  /**
+   * The variable id for the variable this event pertains to.
+   * @type {string}
+   */
+  this.varId = this.isBlank ? '' : opt_variable.getId();
+
+  /**
+   * The workspace identifier for this event.
+   * @type {string}
+   */
+  this.workspaceId = this.isBlank ? '' : opt_variable.workspace.id;
+};
+Blockly.utils.object.inherits(Blockly.Events.VarBase, Blockly.Events.Abstract);
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.VarBase.prototype.toJson = function() {
+  var json = Blockly.Events.VarBase.superClass_.toJson.call(this);
+  json['varId'] = this.varId;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.VarBase.prototype.fromJson = function(json) {
+  Blockly.Events.VarBase.superClass_.toJson.call(this);
+  this.varId = json['varId'];
+};
+
+/**
+ * Class for a variable creation event.
+ * @param {!Blockly.VariableModel=} opt_variable The created variable. Undefined
+ *     for a blank event.
+ * @extends {Blockly.Events.VarBase}
+ * @constructor
+ */
+Blockly.Events.VarCreate = function(opt_variable) {
+  Blockly.Events.VarCreate.superClass_.constructor.call(this, opt_variable);
+  if (!opt_variable) {
+    return;  // Blank event to be populated by fromJson.
+  }
+
+  this.varType = opt_variable.type;
+  this.varName = opt_variable.name;
+};
+Blockly.utils.object.inherits(Blockly.Events.VarCreate, Blockly.Events.VarBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.VarCreate.prototype.type = Blockly.Events.VAR_CREATE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.VarCreate.prototype.toJson = function() {
+  var json = Blockly.Events.VarCreate.superClass_.toJson.call(this);
+  json['varType'] = this.varType;
+  json['varName'] = this.varName;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.VarCreate.prototype.fromJson = function(json) {
+  Blockly.Events.VarCreate.superClass_.fromJson.call(this, json);
+  this.varType = json['varType'];
+  this.varName = json['varName'];
+};
+
+/**
+ * Run a variable creation event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.VarCreate.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  if (forward) {
+    workspace.createVariable(this.varName, this.varType, this.varId);
+  } else {
+    workspace.deleteVariableById(this.varId);
+  }
+};
+
+/**
+ * Class for a variable deletion event.
+ * @param {!Blockly.VariableModel=} opt_variable The deleted variable. Undefined
+ *     for a blank event.
+ * @extends {Blockly.Events.VarBase}
+ * @constructor
+ */
+Blockly.Events.VarDelete = function(opt_variable) {
+  Blockly.Events.VarDelete.superClass_.constructor.call(this, opt_variable);
+  if (!opt_variable) {
+    return;  // Blank event to be populated by fromJson.
+  }
+
+  this.varType = opt_variable.type;
+  this.varName = opt_variable.name;
+};
+Blockly.utils.object.inherits(Blockly.Events.VarDelete, Blockly.Events.VarBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.VarDelete.prototype.type = Blockly.Events.VAR_DELETE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.VarDelete.prototype.toJson = function() {
+  var json = Blockly.Events.VarDelete.superClass_.toJson.call(this);
+  json['varType'] = this.varType;
+  json['varName'] = this.varName;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.VarDelete.prototype.fromJson = function(json) {
+  Blockly.Events.VarDelete.superClass_.fromJson.call(this, json);
+  this.varType = json['varType'];
+  this.varName = json['varName'];
+};
+
+/**
+ * Run a variable deletion event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.VarDelete.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  if (forward) {
+    workspace.deleteVariableById(this.varId);
+  } else {
+    workspace.createVariable(this.varName, this.varType, this.varId);
+  }
+};
+
+/**
+ * Class for a variable rename event.
+ * @param {!Blockly.VariableModel=} opt_variable The renamed variable. Undefined
+ *     for a blank event.
+ * @param {string=} newName The new name the variable will be changed to.
+ * @extends {Blockly.Events.VarBase}
+ * @constructor
+ */
+Blockly.Events.VarRename = function(opt_variable, newName) {
+  Blockly.Events.VarRename.superClass_.constructor.call(this, opt_variable);
+  if (!opt_variable) {
+    return;  // Blank event to be populated by fromJson.
+  }
+
+  this.oldName = opt_variable.name;
+  this.newName = typeof newName == 'undefined' ? '' : newName;
+};
+Blockly.utils.object.inherits(Blockly.Events.VarRename, Blockly.Events.VarBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.VarRename.prototype.type = Blockly.Events.VAR_RENAME;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.VarRename.prototype.toJson = function() {
+  var json = Blockly.Events.VarRename.superClass_.toJson.call(this);
+  json['oldName'] = this.oldName;
+  json['newName'] = this.newName;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.VarRename.prototype.fromJson = function(json) {
+  Blockly.Events.VarRename.superClass_.fromJson.call(this, json);
+  this.oldName = json['oldName'];
+  this.newName = json['newName'];
+};
+
+/**
+ * Run a variable rename event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.VarRename.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  if (forward) {
+    workspace.renameVariableById(this.varId, this.newName);
+  } else {
+    workspace.renameVariableById(this.varId, this.oldName);
+  }
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.VAR_CREATE, Blockly.Events.VarCreate);
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.VAR_DELETE, Blockly.Events.VarDelete);
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.VAR_RENAME, Blockly.Events.VarRename);

blockly/core/events/workspace_events.js

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Class for a finished loading workspace event.
+ * @author BeksOmega
+ */
+'use strict';
+
+goog.provide('Blockly.Events.FinishedLoading');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.Abstract');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+goog.requireType('Blockly.Workspace');
+
+
+/**
+ * Class for a finished loading event.
+ * Used to notify the developer when the workspace has finished loading (i.e
+ * domToWorkspace).
+ * Finished loading events do not record undo or redo.
+ * @param {!Blockly.Workspace=} opt_workspace The workspace that has finished
+ *    loading.  Undefined for a blank event.
+ * @extends {Blockly.Events.Abstract}
+ * @constructor
+ */
+Blockly.Events.FinishedLoading = function(opt_workspace) {
+
+  /**
+   * Whether or not the event is blank (to be populated by fromJson).
+   * @type {boolean}
+   */
+  this.isBlank = typeof opt_workspace == 'undefined';
+
+  /**
+   * The workspace identifier for this event.
+   * @type {string}
+   */
+  this.workspaceId = opt_workspace ? opt_workspace.id : '';
+
+  /**
+   * The event group ID for the group this event belongs to. Groups define
+   * events that should be treated as an single action from the user's
+   * perspective, and should be undone together.
+   * @type {string}
+   */
+  this.group = Blockly.Events.getGroup();
+
+  // Workspace events do not undo or redo.
+  this.recordUndo = false;
+};
+Blockly.utils.object.inherits(Blockly.Events.FinishedLoading,
+    Blockly.Events.Abstract);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.FinishedLoading.prototype.type = Blockly.Events.FINISHED_LOADING;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.FinishedLoading.prototype.toJson = function() {
+  var json = {
+    'type': this.type,
+  };
+  if (this.group) {
+    json['group'] = this.group;
+  }
+  if (this.workspaceId) {
+    json['workspaceId'] = this.workspaceId;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.FinishedLoading.prototype.fromJson = function(json) {
+  this.isBlank = false;
+  this.workspaceId = json['workspaceId'];
+  this.group = json['group'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.FINISHED_LOADING, Blockly.Events.FinishedLoading);

blockly/core/events/ws_comment_events.js

@@ -0,0 +1,427 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Classes for all comment events.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.CommentBase');
+goog.provide('Blockly.Events.CommentChange');
+goog.provide('Blockly.Events.CommentCreate');
+goog.provide('Blockly.Events.CommentDelete');
+goog.provide('Blockly.Events.CommentMove');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.Abstract');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.Coordinate');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.xml');
+goog.require('Blockly.Xml');
+
+
+/**
+ * Abstract class for a comment event.
+ * @param {!Blockly.WorkspaceComment=} opt_comment The comment this event
+ *     corresponds to.  Undefined for a blank event.
+ * @extends {Blockly.Events.Abstract}
+ * @constructor
+ */
+Blockly.Events.CommentBase = function(opt_comment) {
+
+  /**
+   * Whether or not an event is blank.
+   * @type {boolean}
+   */
+  this.isBlank = typeof opt_comment == 'undefined';
+
+  /**
+   * The ID of the comment this event pertains to.
+   * @type {string}
+   */
+  this.commentId = this.isBlank ? '' : opt_comment.id;
+
+  /**
+   * The workspace identifier for this event.
+   * @type {string}
+   */
+  this.workspaceId = this.isBlank ? '' : opt_comment.workspace.id;
+
+  /**
+   * The event group id for the group this event belongs to. Groups define
+   * events that should be treated as an single action from the user's
+   * perspective, and should be undone together.
+   * @type {string}
+   */
+  this.group = Blockly.Events.getGroup();
+
+  /**
+   * Sets whether the event should be added to the undo stack.
+   * @type {boolean}
+   */
+  this.recordUndo = Blockly.Events.recordUndo;
+};
+Blockly.utils.object.inherits(Blockly.Events.CommentBase,
+    Blockly.Events.Abstract);
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.CommentBase.prototype.toJson = function() {
+  var json = Blockly.Events.CommentBase.superClass_.toJson.call(this);
+  if (this.commentId) {
+    json['commentId'] = this.commentId;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.CommentBase.prototype.fromJson = function(json) {
+  Blockly.Events.CommentBase.superClass_.fromJson.call(this, json);
+  this.commentId = json['commentId'];
+};
+
+/**
+ * Class for a comment change event.
+ * @param {!Blockly.WorkspaceComment=} opt_comment The comment that is being
+ *     changed.  Undefined for a blank event.
+ * @param {string=} opt_oldContents Previous contents of the comment.
+ * @param {string=} opt_newContents New contents of the comment.
+ * @extends {Blockly.Events.CommentBase}
+ * @constructor
+ */
+Blockly.Events.CommentChange = function(opt_comment, opt_oldContents,
+    opt_newContents) {
+  Blockly.Events.CommentChange.superClass_.constructor.call(this, opt_comment);
+  if (!opt_comment) {
+    return;  // Blank event to be populated by fromJson.
+  }
+
+  this.oldContents_ = typeof opt_oldContents == 'undefined' ? '' :
+      opt_oldContents;
+  this.newContents_ = typeof opt_newContents == 'undefined' ? '' :
+      opt_newContents;
+};
+Blockly.utils.object.inherits(Blockly.Events.CommentChange,
+    Blockly.Events.CommentBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.CommentChange.prototype.type = Blockly.Events.COMMENT_CHANGE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.CommentChange.prototype.toJson = function() {
+  var json = Blockly.Events.CommentChange.superClass_.toJson.call(this);
+  json['oldContents'] = this.oldContents_;
+  json['newContents'] = this.newContents_;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.CommentChange.prototype.fromJson = function(json) {
+  Blockly.Events.CommentChange.superClass_.fromJson.call(this, json);
+  this.oldContents_ = json['oldContents'];
+  this.newContents_ = json['newContents'];
+};
+
+/**
+ * Does this event record any change of state?
+ * @return {boolean} False if something changed.
+ */
+Blockly.Events.CommentChange.prototype.isNull = function() {
+  return this.oldContents_ == this.newContents_;
+};
+
+/**
+ * Run a change event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.CommentChange.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  var comment = workspace.getCommentById(this.commentId);
+  if (!comment) {
+    console.warn('Can\'t change non-existent comment: ' + this.commentId);
+    return;
+  }
+  var contents = forward ? this.newContents_ : this.oldContents_;
+
+  comment.setContent(contents);
+};
+
+/**
+ * Class for a comment creation event.
+ * @param {!Blockly.WorkspaceComment=} opt_comment The created comment.
+ *     Undefined for a blank event.
+ * @extends {Blockly.Events.CommentBase}
+ * @constructor
+ */
+Blockly.Events.CommentCreate = function(opt_comment) {
+  Blockly.Events.CommentCreate.superClass_.constructor.call(this, opt_comment);
+  if (!opt_comment) {
+    return;  // Blank event to be populated by fromJson.
+  }
+
+  this.xml = opt_comment.toXmlWithXY();
+};
+Blockly.utils.object.inherits(Blockly.Events.CommentCreate,
+    Blockly.Events.CommentBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.CommentCreate.prototype.type = Blockly.Events.COMMENT_CREATE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+// TODO (#1266): "Full" and "minimal" serialization.
+Blockly.Events.CommentCreate.prototype.toJson = function() {
+  var json = Blockly.Events.CommentCreate.superClass_.toJson.call(this);
+  json['xml'] = Blockly.Xml.domToText(this.xml);
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.CommentCreate.prototype.fromJson = function(json) {
+  Blockly.Events.CommentCreate.superClass_.fromJson.call(this, json);
+  this.xml = Blockly.Xml.textToDom(json['xml']);
+};
+
+/**
+ * Run a creation event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.CommentCreate.prototype.run = function(forward) {
+  Blockly.Events.CommentCreateDeleteHelper(this, forward);
+};
+
+/**
+ * Helper function for Comment[Create|Delete]
+ * @param {!Blockly.Events.CommentCreate|!Blockly.Events.CommentDelete} event
+ *     The event to run.
+ * @param {boolean} create if True then Create, if False then Delete
+ */
+Blockly.Events.CommentCreateDeleteHelper = function(event, create) {
+  var workspace = event.getEventWorkspace_();
+  if (create) {
+    var xml = Blockly.utils.xml.createElement('xml');
+    xml.appendChild(event.xml);
+    Blockly.Xml.domToWorkspace(xml, workspace);
+  } else {
+    var comment = workspace.getCommentById(event.commentId);
+    if (comment) {
+      comment.dispose(false, false);
+    } else {
+      // Only complain about root-level block.
+      console.warn("Can't uncreate non-existent comment: " + event.commentId);
+    }
+  }
+};
+/**
+ * Class for a comment deletion event.
+ * @param {!Blockly.WorkspaceComment=} opt_comment The deleted comment.
+ *     Undefined for a blank event.
+ * @extends {Blockly.Events.CommentBase}
+ * @constructor
+ */
+Blockly.Events.CommentDelete = function(opt_comment) {
+  Blockly.Events.CommentDelete.superClass_.constructor.call(this, opt_comment);
+  if (!opt_comment) {
+    return;  // Blank event to be populated by fromJson.
+  }
+
+  this.xml = opt_comment.toXmlWithXY();
+};
+Blockly.utils.object.inherits(Blockly.Events.CommentDelete,
+    Blockly.Events.CommentBase);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.CommentDelete.prototype.type = Blockly.Events.COMMENT_DELETE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+// TODO (#1266): "Full" and "minimal" serialization.
+Blockly.Events.CommentDelete.prototype.toJson = function() {
+  var json = Blockly.Events.CommentDelete.superClass_.toJson.call(this);
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.CommentDelete.prototype.fromJson = function(json) {
+  Blockly.Events.CommentDelete.superClass_.fromJson.call(this, json);
+};
+
+/**
+ * Run a creation event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.CommentDelete.prototype.run = function(forward) {
+  Blockly.Events.CommentCreateDeleteHelper(this, !forward);
+};
+
+/**
+ * Class for a comment move event.  Created before the move.
+ * @param {!Blockly.WorkspaceComment=} opt_comment The comment that is being
+ *     moved.  Undefined for a blank event.
+ * @extends {Blockly.Events.CommentBase}
+ * @constructor
+ */
+Blockly.Events.CommentMove = function(opt_comment) {
+  Blockly.Events.CommentMove.superClass_.constructor.call(this, opt_comment);
+  if (!opt_comment) {
+    return;  // Blank event to be populated by fromJson.
+  }
+
+  /**
+   * The comment that is being moved.  Will be cleared after recording the new
+   * location.
+   * @type {Blockly.WorkspaceComment}
+   */
+  this.comment_ = opt_comment;
+
+  /**
+   * The location before the move, in workspace coordinates.
+   * @type {!Blockly.utils.Coordinate}
+   */
+  this.oldCoordinate_ = opt_comment.getXY();
+
+  /**
+   * The location after the move, in workspace coordinates.
+   * @type {Blockly.utils.Coordinate}
+   */
+  this.newCoordinate_ = null;
+};
+Blockly.utils.object.inherits(Blockly.Events.CommentMove,
+    Blockly.Events.CommentBase);
+
+/**
+ * Record the comment's new location.  Called after the move.  Can only be
+ * called once.
+ */
+Blockly.Events.CommentMove.prototype.recordNew = function() {
+  if (!this.comment_) {
+    throw Error('Tried to record the new position of a comment on the ' +
+        'same event twice.');
+  }
+  this.newCoordinate_ = this.comment_.getXY();
+  this.comment_ = null;
+};
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.CommentMove.prototype.type = Blockly.Events.COMMENT_MOVE;
+
+/**
+ * Override the location before the move.  Use this if you don't create the
+ * event until the end of the move, but you know the original location.
+ * @param {!Blockly.utils.Coordinate} xy The location before the move,
+ *     in workspace coordinates.
+ */
+Blockly.Events.CommentMove.prototype.setOldCoordinate = function(xy) {
+  this.oldCoordinate_ = xy;
+};
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+// TODO (#1266): "Full" and "minimal" serialization.
+Blockly.Events.CommentMove.prototype.toJson = function() {
+  var json = Blockly.Events.CommentMove.superClass_.toJson.call(this);
+  if (this.oldCoordinate_) {
+    json['oldCoordinate'] = Math.round(this.oldCoordinate_.x) + ',' +
+        Math.round(this.oldCoordinate_.y);
+  }
+  if (this.newCoordinate_) {
+    json['newCoordinate'] = Math.round(this.newCoordinate_.x) + ',' +
+        Math.round(this.newCoordinate_.y);
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.CommentMove.prototype.fromJson = function(json) {
+  Blockly.Events.CommentMove.superClass_.fromJson.call(this, json);
+
+  if (json['oldCoordinate']) {
+    var xy = json['oldCoordinate'].split(',');
+    this.oldCoordinate_ =
+        new Blockly.utils.Coordinate(Number(xy[0]), Number(xy[1]));
+  }
+  if (json['newCoordinate']) {
+    var xy = json['newCoordinate'].split(',');
+    this.newCoordinate_ =
+        new Blockly.utils.Coordinate(Number(xy[0]), Number(xy[1]));
+  }
+};
+
+/**
+ * Does this event record any change of state?
+ * @return {boolean} False if something changed.
+ */
+Blockly.Events.CommentMove.prototype.isNull = function() {
+  return Blockly.utils.Coordinate.equals(this.oldCoordinate_,
+      this.newCoordinate_);
+};
+
+/**
+ * Run a move event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.CommentMove.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  var comment = workspace.getCommentById(this.commentId);
+  if (!comment) {
+    console.warn('Can\'t move non-existent comment: ' + this.commentId);
+    return;
+  }
+
+  var target = forward ? this.newCoordinate_ : this.oldCoordinate_;
+  // TODO: Check if the comment is being dragged, and give up if so.
+  var current = comment.getXY();
+  comment.moveBy(target.x - current.x, target.y - current.y);
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.COMMENT_CREATE, Blockly.Events.CommentCreate);
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.COMMENT_CHANGE, Blockly.Events.CommentChange);
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.COMMENT_MOVE, Blockly.Events.CommentMove);
+Blockly.registry.register(Blockly.registry.Type.EVENT,
+    Blockly.Events.COMMENT_DELETE, Blockly.Events.CommentDelete);

blockly/core/extensions.js

@@ -0,0 +1,451 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Extensions are functions that help initialize blocks, usually
+ *      adding dynamic behavior such as onchange handlers and mutators. These
+ *      are applied using Block.applyExtension(), or the JSON "extensions"
+ *      array attribute.
+ * @author Anm@anm.me (Andrew n marshall)
+ */
+'use strict';
+
+/**
+ * @name Blockly.Extensions
+ * @namespace
+ */
+goog.provide('Blockly.Extensions');
+
+goog.require('Blockly.utils');
+
+goog.requireType('Blockly.Block');
+
+
+/**
+ * The set of all registered extensions, keyed by extension name/id.
+ * @private
+ */
+Blockly.Extensions.ALL_ = Object.create(null);
+
+/**
+ * Registers a new extension function. Extensions are functions that help
+ * initialize blocks, usually adding dynamic behavior such as onchange
+ * handlers and mutators. These are applied using Block.applyExtension(), or
+ * the JSON "extensions" array attribute.
+ * @param {string} name The name of this extension.
+ * @param {Function} initFn The function to initialize an extended block.
+ * @throws {Error} if the extension name is empty, the extension is already
+ *     registered, or extensionFn is not a function.
+ */
+Blockly.Extensions.register = function(name, initFn) {
+  if ((typeof name != 'string') || (name.trim() == '')) {
+    throw Error('Error: Invalid extension name "' + name + '"');
+  }
+  if (Blockly.Extensions.ALL_[name]) {
+    throw Error('Error: Extension "' + name + '" is already registered.');
+  }
+  if (typeof initFn != 'function') {
+    throw Error('Error: Extension "' + name + '" must be a function');
+  }
+  Blockly.Extensions.ALL_[name] = initFn;
+};
+
+/**
+ * Registers a new extension function that adds all key/value of mixinObj.
+ * @param {string} name The name of this extension.
+ * @param {!Object} mixinObj The values to mix in.
+ * @throws {Error} if the extension name is empty or the extension is already
+ *     registered.
+ */
+Blockly.Extensions.registerMixin = function(name, mixinObj) {
+  if (!mixinObj || typeof mixinObj != 'object') {
+    throw Error('Error: Mixin "' + name + '" must be a object');
+  }
+  Blockly.Extensions.register(name, function() {
+    this.mixin(mixinObj);
+  });
+};
+
+/**
+ * Registers a new extension function that adds a mutator to the block.
+ * At register time this performs some basic sanity checks on the mutator.
+ * The wrapper may also add a mutator dialog to the block, if both compose and
+ * decompose are defined on the mixin.
+ * @param {string} name The name of this mutator extension.
+ * @param {!Object} mixinObj The values to mix in.
+ * @param {(function())=} opt_helperFn An optional function to apply after
+ *     mixing in the object.
+ * @param {!Array<string>=} opt_blockList A list of blocks to appear in the
+ *     flyout of the mutator dialog.
+ * @throws {Error} if the mutation is invalid or can't be applied to the block.
+ */
+Blockly.Extensions.registerMutator = function(name, mixinObj, opt_helperFn,
+    opt_blockList) {
+  var errorPrefix = 'Error when registering mutator "' + name + '": ';
+
+  // Sanity check the mixin object before registering it.
+  Blockly.Extensions.checkHasFunction_(
+      errorPrefix, mixinObj.domToMutation, 'domToMutation');
+  Blockly.Extensions.checkHasFunction_(
+      errorPrefix, mixinObj.mutationToDom, 'mutationToDom');
+
+  var hasMutatorDialog =
+      Blockly.Extensions.checkMutatorDialog_(mixinObj, errorPrefix);
+
+  if (opt_helperFn && (typeof opt_helperFn != 'function')) {
+    throw Error('Extension "' + name + '" is not a function');
+  }
+
+  // Sanity checks passed.
+  Blockly.Extensions.register(name, function() {
+    if (hasMutatorDialog) {
+      if (!Blockly.Mutator) {
+        throw Error(errorPrefix + 'Missing require for Blockly.Mutator');
+      }
+      this.setMutator(new Blockly.Mutator(opt_blockList || []));
+    }
+    // Mixin the object.
+    this.mixin(mixinObj);
+
+    if (opt_helperFn) {
+      opt_helperFn.apply(this);
+    }
+  });
+};
+
+/**
+ * Unregisters the extension registered with the given name.
+ * @param {string} name The name of the extension to unregister.
+ */
+Blockly.Extensions.unregister = function(name) {
+  if (Blockly.Extensions.ALL_[name]) {
+    delete Blockly.Extensions.ALL_[name];
+  } else {
+    console.warn('No extension mapping for name "' + name +
+        '" found to unregister');
+  }
+};
+
+/**
+ * Applies an extension method to a block. This should only be called during
+ * block construction.
+ * @param {string} name The name of the extension.
+ * @param {!Blockly.Block} block The block to apply the named extension to.
+ * @param {boolean} isMutator True if this extension defines a mutator.
+ * @throws {Error} if the extension is not found.
+ */
+Blockly.Extensions.apply = function(name, block, isMutator) {
+  var extensionFn = Blockly.Extensions.ALL_[name];
+  if (typeof extensionFn != 'function') {
+    throw Error('Error: Extension "' + name + '" not found.');
+  }
+  if (isMutator) {
+    // Fail early if the block already has mutation properties.
+    Blockly.Extensions.checkNoMutatorProperties_(name, block);
+  } else {
+    // Record the old properties so we can make sure they don't change after
+    // applying the extension.
+    var mutatorProperties = Blockly.Extensions.getMutatorProperties_(block);
+  }
+  extensionFn.apply(block);
+
+  if (isMutator) {
+    var errorPrefix = 'Error after applying mutator "' + name + '": ';
+    Blockly.Extensions.checkBlockHasMutatorProperties_(errorPrefix, block);
+  } else {
+    if (!Blockly.Extensions.mutatorPropertiesMatch_(
+        /** @type {!Array<Object>} */ (mutatorProperties), block)) {
+      throw Error('Error when applying extension "' + name + '": ' +
+          'mutation properties changed when applying a non-mutator extension.');
+    }
+  }
+};
+
+/**
+ * Check that the given value is a function.
+ * @param {string} errorPrefix The string to prepend to any error message.
+ * @param {*} func Function to check.
+ * @param {string} propertyName Which property to check.
+ * @throws {Error} if the property does not exist or is not a function.
+ * @private
+ */
+Blockly.Extensions.checkHasFunction_ = function(errorPrefix, func,
+    propertyName) {
+  if (!func) {
+    throw Error(errorPrefix +
+        'missing required property "' + propertyName + '"');
+  } else if (typeof func != 'function') {
+    throw Error(errorPrefix +
+        '" required property "' + propertyName + '" must be a function');
+  }
+};
+
+/**
+ * Check that the given block does not have any of the four mutator properties
+ * defined on it.  This function should be called before applying a mutator
+ * extension to a block, to make sure we are not overwriting properties.
+ * @param {string} mutationName The name of the mutation to reference in error
+ *     messages.
+ * @param {!Blockly.Block} block The block to check.
+ * @throws {Error} if any of the properties already exist on the block.
+ * @private
+ */
+Blockly.Extensions.checkNoMutatorProperties_ = function(mutationName, block) {
+  var properties = Blockly.Extensions.getMutatorProperties_(block);
+  if (properties.length) {
+    throw Error('Error: tried to apply mutation "' + mutationName +
+        '" to a block that already has mutator functions.' +
+        '  Block id: ' + block.id);
+  }
+};
+
+/**
+ * Check that the given object has both or neither of the functions required
+ * to have a mutator dialog.
+ * These functions are 'compose' and 'decompose'.  If a block has one, it must
+ * have both.
+ * @param {!Object} object The object to check.
+ * @param {string} errorPrefix The string to prepend to any error message.
+ * @return {boolean} True if the object has both functions.  False if it has
+ *     neither function.
+ * @throws {Error} if the object has only one of the functions.
+ * @private
+ */
+Blockly.Extensions.checkMutatorDialog_ = function(object, errorPrefix) {
+  var hasCompose = object.compose !== undefined;
+  var hasDecompose = object.decompose !== undefined;
+
+  if (hasCompose && hasDecompose) {
+    if (typeof object.compose != 'function') {
+      throw Error(errorPrefix + 'compose must be a function.');
+    } else if (typeof object.decompose != 'function') {
+      throw Error(errorPrefix + 'decompose must be a function.');
+    }
+    return true;
+  } else if (!hasCompose && !hasDecompose) {
+    return false;
+  }
+  throw Error(errorPrefix +
+      'Must have both or neither of "compose" and "decompose"');
+};
+
+/**
+ * Check that a block has required mutator properties.  This should be called
+ * after applying a mutation extension.
+ * @param {string} errorPrefix The string to prepend to any error message.
+ * @param {!Blockly.Block} block The block to inspect.
+ * @private
+ */
+Blockly.Extensions.checkBlockHasMutatorProperties_ = function(errorPrefix,
+    block) {
+  if (typeof block.domToMutation != 'function') {
+    throw Error(errorPrefix + 'Applying a mutator didn\'t add "domToMutation"');
+  }
+  if (typeof block.mutationToDom != 'function') {
+    throw Error(errorPrefix + 'Applying a mutator didn\'t add "mutationToDom"');
+  }
+
+  // A block with a mutator isn't required to have a mutation dialog, but
+  // it should still have both or neither of compose and decompose.
+  Blockly.Extensions.checkMutatorDialog_(block, errorPrefix);
+};
+
+/**
+ * Get a list of values of mutator properties on the given block.
+ * @param {!Blockly.Block} block The block to inspect.
+ * @return {!Array<Object>} A list with all of the defined properties, which
+ *     should be functions, but may be anything other than undefined.
+ * @private
+ */
+Blockly.Extensions.getMutatorProperties_ = function(block) {
+  var result = [];
+  // List each function explicitly by reference to allow for renaming
+  // during compilation.
+  if (block.domToMutation !== undefined) {
+    result.push(block.domToMutation);
+  }
+  if (block.mutationToDom !== undefined) {
+    result.push(block.mutationToDom);
+  }
+  if (block.compose !== undefined) {
+    result.push(block.compose);
+  }
+  if (block.decompose !== undefined) {
+    result.push(block.decompose);
+  }
+  return result;
+};
+
+/**
+ * Check that the current mutator properties match a list of old mutator
+ * properties.  This should be called after applying a non-mutator extension,
+ * to verify that the extension didn't change properties it shouldn't.
+ * @param {!Array<Object>} oldProperties The old values to compare to.
+ * @param {!Blockly.Block} block The block to inspect for new values.
+ * @return {boolean} True if the property lists match.
+ * @private
+ */
+Blockly.Extensions.mutatorPropertiesMatch_ = function(oldProperties, block) {
+  var newProperties = Blockly.Extensions.getMutatorProperties_(block);
+  if (newProperties.length != oldProperties.length) {
+    return false;
+  }
+  for (var i = 0; i < newProperties.length; i++) {
+    if (oldProperties[i] != newProperties[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Builds an extension function that will map a dropdown value to a tooltip
+ * string.
+ *
+ * This method includes multiple checks to ensure tooltips, dropdown options,
+ * and message references are aligned. This aims to catch errors as early as
+ * possible, without requiring developers to manually test tooltips under each
+ * option. After the page is loaded, each tooltip text string will be checked
+ * for matching message keys in the internationalized string table. Deferring
+ * this until the page is loaded decouples loading dependencies. Later, upon
+ * loading the first block of any given type, the extension will validate every
+ * dropdown option has a matching tooltip in the lookupTable.  Errors are
+ * reported as warnings in the console, and are never fatal.
+ * @param {string} dropdownName The name of the field whose value is the key
+ *     to the lookup table.
+ * @param {!Object<string, string>} lookupTable The table of field values to
+ *     tooltip text.
+ * @return {!Function} The extension function.
+ */
+Blockly.Extensions.buildTooltipForDropdown = function(dropdownName,
+    lookupTable) {
+  // List of block types already validated, to minimize duplicate warnings.
+  var blockTypesChecked = [];
+
+  // Check the tooltip string messages for invalid references.
+  // Wait for load, in case Blockly.Msg is not yet populated.
+  // runAfterPageLoad() does not run in a Node.js environment due to lack of
+  // document object, in which case skip the validation.
+  if (typeof document == 'object') {  // Relies on document.readyState
+    Blockly.utils.runAfterPageLoad(function() {
+      for (var key in lookupTable) {
+        // Will print warnings if reference is missing.
+        Blockly.utils.checkMessageReferences(lookupTable[key]);
+      }
+    });
+  }
+
+  /**
+   * The actual extension.
+   * @this {Blockly.Block}
+   */
+  var extensionFn = function() {
+    if (this.type && blockTypesChecked.indexOf(this.type) == -1) {
+      Blockly.Extensions.checkDropdownOptionsInTable_(
+          this, dropdownName, lookupTable);
+      blockTypesChecked.push(this.type);
+    }
+
+    this.setTooltip(function() {
+      var value = String(this.getFieldValue(dropdownName));
+      var tooltip = lookupTable[value];
+      if (tooltip == null) {
+        if (blockTypesChecked.indexOf(this.type) == -1) {
+          // Warn for missing values on generated tooltips.
+          var warning = 'No tooltip mapping for value ' + value +
+              ' of field ' + dropdownName;
+          if (this.type != null) {
+            warning += (' of block type ' + this.type);
+          }
+          console.warn(warning + '.');
+        }
+      } else {
+        tooltip = Blockly.utils.replaceMessageReferences(tooltip);
+      }
+      return tooltip;
+    }.bind(this));
+  };
+  return extensionFn;
+};
+
+/**
+ * Checks all options keys are present in the provided string lookup table.
+ * Emits console warnings when they are not.
+ * @param {!Blockly.Block} block The block containing the dropdown
+ * @param {string} dropdownName The name of the dropdown
+ * @param {!Object<string, string>} lookupTable The string lookup table
+ * @private
+ */
+Blockly.Extensions.checkDropdownOptionsInTable_ = function(block, dropdownName,
+    lookupTable) {
+  // Validate all dropdown options have values.
+  var dropdown = block.getField(dropdownName);
+  if (!dropdown.isOptionListDynamic()) {
+    var options = dropdown.getOptions();
+    for (var i = 0; i < options.length; ++i) {
+      var optionKey = options[i][1];  // label, then value
+      if (lookupTable[optionKey] == null) {
+        console.warn('No tooltip mapping for value ' + optionKey +
+           ' of field ' + dropdownName + ' of block type ' + block.type);
+      }
+    }
+  }
+};
+
+/**
+ * Builds an extension function that will install a dynamic tooltip. The
+ * tooltip message should include the string '%1' and that string will be
+ * replaced with the text of the named field.
+ * @param {string} msgTemplate The template form to of the message text, with
+ *     %1 placeholder.
+ * @param {string} fieldName The field with the replacement text.
+ * @return {!Function} The extension function.
+ */
+Blockly.Extensions.buildTooltipWithFieldText = function(msgTemplate,
+    fieldName) {
+  // Check the tooltip string messages for invalid references.
+  // Wait for load, in case Blockly.Msg is not yet populated.
+  // runAfterPageLoad() does not run in a Node.js environment due to lack of
+  // document object, in which case skip the validation.
+  if (typeof document == 'object') {  // Relies on document.readyState
+    Blockly.utils.runAfterPageLoad(function() {
+      // Will print warnings if reference is missing.
+      Blockly.utils.checkMessageReferences(msgTemplate);
+    });
+  }
+
+  /**
+   * The actual extension.
+   * @this {Blockly.Block}
+   */
+  var extensionFn = function() {
+    this.setTooltip(function() {
+      var field = this.getField(fieldName);
+      return Blockly.utils.replaceMessageReferences(msgTemplate)
+          .replace('%1', field ? field.getText() : '');
+    }.bind(this));
+  };
+  return extensionFn;
+};
+
+/**
+ * Configures the tooltip to mimic the parent block when connected. Otherwise,
+ * uses the tooltip text at the time this extension is initialized. This takes
+ * advantage of the fact that all other values from JSON are initialized before
+ * extensions.
+ * @this {Blockly.Block}
+ * @private
+ */
+Blockly.Extensions.extensionParentTooltip_ = function() {
+  this.tooltipWhenNotConnected_ = this.tooltip;
+  this.setTooltip(function() {
+    var parent = this.getParent();
+    return (parent && parent.getInputsInline() && parent.tooltip) ||
+        this.tooltipWhenNotConnected_;
+  }.bind(this));
+};
+Blockly.Extensions.register('parent_tooltip_when_inline',
+    Blockly.Extensions.extensionParentTooltip_);

blockly/core/field_angle.js

@@ -0,0 +1,570 @@
+/**
+ * @license
+ * Copyright 2013 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Angle input field.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldAngle');
+
+goog.require('Blockly.browserEvents');
+goog.require('Blockly.Css');
+goog.require('Blockly.DropDownDiv');
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.FieldTextInput');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.KeyCodes');
+goog.require('Blockly.utils.math');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.Svg');
+goog.require('Blockly.utils.userAgent');
+goog.require('Blockly.WidgetDiv');
+
+
+/**
+ * Class for an editable angle field.
+ * @param {string|number=} opt_value The initial value of the field. Should cast
+ *    to a number. Defaults to 0.
+ * @param {Function=} opt_validator A function that is called to validate
+ *    changes to the field's value. Takes in a number & returns a
+ *    validated number, or null to abort the change.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/angle#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.FieldTextInput}
+ * @constructor
+ */
+Blockly.FieldAngle = function(opt_value, opt_validator, opt_config) {
+
+  /**
+   * Should the angle increase as the angle picker is moved clockwise (true)
+   * or counterclockwise (false)
+   * @see Blockly.FieldAngle.CLOCKWISE
+   * @type {boolean}
+   * @private
+   */
+  this.clockwise_ = Blockly.FieldAngle.CLOCKWISE;
+
+  /**
+   * The offset of zero degrees (and all other angles).
+   * @see Blockly.FieldAngle.OFFSET
+   * @type {number}
+   * @private
+   */
+  this.offset_ = Blockly.FieldAngle.OFFSET;
+
+  /**
+   * The maximum angle to allow before wrapping.
+   * @see Blockly.FieldAngle.WRAP
+   * @type {number}
+   * @private
+   */
+  this.wrap_ = Blockly.FieldAngle.WRAP;
+
+  /**
+   * The amount to round angles to when using a mouse or keyboard nav input.
+   * @see Blockly.FieldAngle.ROUND
+   * @type {number}
+   * @private
+   */
+  this.round_ = Blockly.FieldAngle.ROUND;
+
+  Blockly.FieldAngle.superClass_.constructor.call(
+      this, opt_value, opt_validator, opt_config);
+
+  /**
+   * The angle picker's SVG element.
+   * @type {?SVGElement}
+   * @private
+   */
+  this.editor_ = null;
+
+  /**
+   * The angle picker's gauge path depending on the value.
+   * @type {?SVGElement}
+   */
+  this.gauge_ = null;
+
+  /**
+   * The angle picker's line drawn representing the value's angle.
+   * @type {?SVGElement}
+   */
+  this.line_ = null;
+
+  /**
+   * Wrapper click event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.clickWrapper_ = null;
+
+  /**
+   * Surface click event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.clickSurfaceWrapper_ = null;
+
+  /**
+   * Surface mouse move event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.moveSurfaceWrapper_ = null;
+};
+Blockly.utils.object.inherits(Blockly.FieldAngle, Blockly.FieldTextInput);
+
+
+/**
+ * The default value for this field.
+ * @type {*}
+ * @protected
+ */
+Blockly.FieldAngle.prototype.DEFAULT_VALUE = 0;
+
+/**
+ * Construct a FieldAngle from a JSON arg object.
+ * @param {!Object} options A JSON object with options (angle).
+ * @return {!Blockly.FieldAngle} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldAngle.fromJson = function(options) {
+  return new Blockly.FieldAngle(options['angle'], undefined, options);
+};
+
+/**
+ * Serializable fields are saved by the XML renderer, non-serializable fields
+ * are not. Editable fields should also be serializable.
+ * @type {boolean}
+ */
+Blockly.FieldAngle.prototype.SERIALIZABLE = true;
+
+/**
+ * The default amount to round angles to when using a mouse or keyboard nav
+ * input. Must be a positive integer to support keyboard navigation.
+ * @const {number}
+ */
+Blockly.FieldAngle.ROUND = 15;
+
+/**
+ * Half the width of protractor image.
+ * @const {number}
+ */
+Blockly.FieldAngle.HALF = 100 / 2;
+
+/**
+ * Default property describing which direction makes an angle field's value
+ * increase. Angle increases clockwise (true) or counterclockwise (false).
+ * @const {boolean}
+ */
+Blockly.FieldAngle.CLOCKWISE = false;
+
+/**
+ * The default offset of 0 degrees (and all angles). Always offsets in the
+ * counterclockwise direction, regardless of the field's clockwise property.
+ * Usually either 0 (0 = right) or 90 (0 = up).
+ * @const {number}
+ */
+Blockly.FieldAngle.OFFSET = 0;
+
+/**
+ * The default maximum angle to allow before wrapping.
+ * Usually either 360 (for 0 to 359.9) or 180 (for -179.9 to 180).
+ * @const {number}
+ */
+Blockly.FieldAngle.WRAP = 360;
+
+/**
+ * Radius of protractor circle.  Slightly smaller than protractor size since
+ * otherwise SVG crops off half the border at the edges.
+ * @const {number}
+ */
+Blockly.FieldAngle.RADIUS = Blockly.FieldAngle.HALF - 1;
+
+/**
+ * Configure the field based on the given map of options.
+ * @param {!Object} config A map of options to configure the field based on.
+ * @protected
+ * @override
+ */
+Blockly.FieldAngle.prototype.configure_ = function(config) {
+  Blockly.FieldAngle.superClass_.configure_.call(this, config);
+
+  switch (config['mode']) {
+    case 'compass':
+      this.clockwise_ = true;
+      this.offset_ = 90;
+      break;
+    case 'protractor':
+      // This is the default mode, so we could do nothing. But just to
+      // future-proof, we'll set it anyway.
+      this.clockwise_ = false;
+      this.offset_ = 0;
+      break;
+  }
+
+  // Allow individual settings to override the mode setting.
+  var clockwise = config['clockwise'];
+  if (typeof clockwise == 'boolean') {
+    this.clockwise_ = clockwise;
+  }
+
+  // If these are passed as null then we should leave them on the default.
+  var offset = config['offset'];
+  if (offset != null) {
+    offset = Number(offset);
+    if (!isNaN(offset)) {
+      this.offset_ = offset;
+    }
+  }
+  var wrap = config['wrap'];
+  if (wrap != null) {
+    wrap = Number(wrap);
+    if (!isNaN(wrap)) {
+      this.wrap_ = wrap;
+    }
+  }
+  var round = config['round'];
+  if (round != null) {
+    round = Number(round);
+    if (!isNaN(round)) {
+      this.round_ = round;
+    }
+  }
+};
+
+
+
+/**
+ * Create the block UI for this field.
+ * @package
+ */
+Blockly.FieldAngle.prototype.initView = function() {
+  Blockly.FieldAngle.superClass_.initView.call(this);
+  // Add the degree symbol to the left of the number, even in RTL (issue #2380)
+  this.symbol_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.TSPAN, {}, null);
+  this.symbol_.appendChild(document.createTextNode('\u00B0'));
+  this.textElement_.appendChild(this.symbol_);
+};
+
+/**
+ * Updates the graph when the field rerenders.
+ * @protected
+ * @override
+ */
+Blockly.FieldAngle.prototype.render_ = function() {
+  Blockly.FieldAngle.superClass_.render_.call(this);
+  this.updateGraph_();
+};
+
+/**
+ * Create and show the angle field's editor.
+ * @param {Event=} opt_e Optional mouse event that triggered the field to open,
+ *     or undefined if triggered programmatically.
+ * @protected
+ */
+Blockly.FieldAngle.prototype.showEditor_ = function(opt_e) {
+  // Mobile browsers have issues with in-line textareas (focus & keyboards).
+  var noFocus =
+      Blockly.utils.userAgent.MOBILE ||
+      Blockly.utils.userAgent.ANDROID ||
+      Blockly.utils.userAgent.IPAD;
+  Blockly.FieldAngle.superClass_.showEditor_.call(this, opt_e, noFocus);
+
+  this.dropdownCreate_();
+  Blockly.DropDownDiv.getContentDiv().appendChild(this.editor_);
+
+  Blockly.DropDownDiv.setColour(this.sourceBlock_.style.colourPrimary,
+      this.sourceBlock_.style.colourTertiary);
+
+  Blockly.DropDownDiv.showPositionedByField(
+      this, this.dropdownDispose_.bind(this));
+
+  this.updateGraph_();
+};
+
+/**
+ * Create the angle dropdown editor.
+ * @private
+ */
+Blockly.FieldAngle.prototype.dropdownCreate_ = function() {
+  var svg = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.SVG, {
+        'xmlns': Blockly.utils.dom.SVG_NS,
+        'xmlns:html': Blockly.utils.dom.HTML_NS,
+        'xmlns:xlink': Blockly.utils.dom.XLINK_NS,
+        'version': '1.1',
+        'height': (Blockly.FieldAngle.HALF * 2) + 'px',
+        'width': (Blockly.FieldAngle.HALF * 2) + 'px',
+        'style': 'touch-action: none'
+      }, null);
+  var circle = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.CIRCLE, {
+        'cx': Blockly.FieldAngle.HALF,
+        'cy': Blockly.FieldAngle.HALF,
+        'r': Blockly.FieldAngle.RADIUS,
+        'class': 'blocklyAngleCircle'
+      }, svg);
+  this.gauge_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.PATH, {
+        'class': 'blocklyAngleGauge'
+      }, svg);
+  this.line_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.LINE, {
+        'x1': Blockly.FieldAngle.HALF,
+        'y1': Blockly.FieldAngle.HALF,
+        'class': 'blocklyAngleLine'
+      }, svg);
+  // Draw markers around the edge.
+  for (var angle = 0; angle < 360; angle += 15) {
+    Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.LINE, {
+          'x1': Blockly.FieldAngle.HALF + Blockly.FieldAngle.RADIUS,
+          'y1': Blockly.FieldAngle.HALF,
+          'x2': Blockly.FieldAngle.HALF + Blockly.FieldAngle.RADIUS -
+              (angle % 45 == 0 ? 10 : 5),
+          'y2': Blockly.FieldAngle.HALF,
+          'class': 'blocklyAngleMarks',
+          'transform': 'rotate(' + angle + ',' +
+              Blockly.FieldAngle.HALF + ',' + Blockly.FieldAngle.HALF + ')'
+        }, svg);
+  }
+
+  // The angle picker is different from other fields in that it updates on
+  // mousemove even if it's not in the middle of a drag.  In future we may
+  // change this behaviour.
+  this.clickWrapper_ =
+      Blockly.browserEvents.conditionalBind(svg, 'click', this, this.hide_);
+  // On touch devices, the picker's value is only updated with a drag. Add
+  // a click handler on the drag surface to update the value if the surface
+  // is clicked.
+  this.clickSurfaceWrapper_ = Blockly.browserEvents.conditionalBind(
+      circle, 'click', this, this.onMouseMove_, true, true);
+  this.moveSurfaceWrapper_ = Blockly.browserEvents.conditionalBind(
+      circle, 'mousemove', this, this.onMouseMove_, true, true);
+  this.editor_ = svg;
+};
+
+/**
+ * Disposes of events and DOM-references belonging to the angle editor.
+ * @private
+ */
+Blockly.FieldAngle.prototype.dropdownDispose_ = function() {
+  if (this.clickWrapper_) {
+    Blockly.browserEvents.unbind(this.clickWrapper_);
+    this.clickWrapper_ = null;
+  }
+  if (this.clickSurfaceWrapper_) {
+    Blockly.browserEvents.unbind(this.clickSurfaceWrapper_);
+    this.clickSurfaceWrapper_ = null;
+  }
+  if (this.moveSurfaceWrapper_) {
+    Blockly.browserEvents.unbind(this.moveSurfaceWrapper_);
+    this.moveSurfaceWrapper_ = null;
+  }
+  this.gauge_ = null;
+  this.line_ = null;
+};
+
+/**
+ * Hide the editor.
+ * @private
+ */
+Blockly.FieldAngle.prototype.hide_ = function() {
+  Blockly.DropDownDiv.hideIfOwner(this);
+  Blockly.WidgetDiv.hide();
+};
+
+/**
+ * Set the angle to match the mouse's position.
+ * @param {!Event} e Mouse move event.
+ * @protected
+ */
+Blockly.FieldAngle.prototype.onMouseMove_ = function(e) {
+  // Calculate angle.
+  var bBox = this.gauge_.ownerSVGElement.getBoundingClientRect();
+  var dx = e.clientX - bBox.left - Blockly.FieldAngle.HALF;
+  var dy = e.clientY - bBox.top - Blockly.FieldAngle.HALF;
+  var angle = Math.atan(-dy / dx);
+  if (isNaN(angle)) {
+    // This shouldn't happen, but let's not let this error propagate further.
+    return;
+  }
+  angle = Blockly.utils.math.toDegrees(angle);
+  // 0: East, 90: North, 180: West, 270: South.
+  if (dx < 0) {
+    angle += 180;
+  } else if (dy > 0) {
+    angle += 360;
+  }
+
+  // Do offsetting.
+  if (this.clockwise_) {
+    angle = this.offset_ + 360 - angle;
+  } else {
+    angle = 360 - (this.offset_ - angle);
+  }
+
+  this.displayMouseOrKeyboardValue_(angle);
+};
+
+/**
+ * Handles and displays values that are input via mouse or arrow key input.
+ * These values need to be rounded and wrapped before being displayed so
+ * that the text input's value is appropriate.
+ * @param {number} angle New angle.
+ * @private
+ */
+Blockly.FieldAngle.prototype.displayMouseOrKeyboardValue_ = function(angle) {
+  if (this.round_) {
+    angle = Math.round(angle / this.round_) * this.round_;
+  }
+  angle = this.wrapValue_(angle);
+  if (angle != this.value_) {
+    this.setEditorValue_(angle);
+  }
+};
+
+/**
+ * Redraw the graph with the current angle.
+ * @private
+ */
+Blockly.FieldAngle.prototype.updateGraph_ = function() {
+  if (!this.gauge_) {
+    return;
+  }
+  // Always display the input (i.e. getText) even if it is invalid.
+  var angleDegrees = Number(this.getText()) + this.offset_;
+  angleDegrees %= 360;
+  var angleRadians = Blockly.utils.math.toRadians(angleDegrees);
+  var path = ['M ', Blockly.FieldAngle.HALF, ',', Blockly.FieldAngle.HALF];
+  var x2 = Blockly.FieldAngle.HALF;
+  var y2 = Blockly.FieldAngle.HALF;
+  if (!isNaN(angleRadians)) {
+    var clockwiseFlag = Number(this.clockwise_);
+    var angle1 = Blockly.utils.math.toRadians(this.offset_);
+    var x1 = Math.cos(angle1) * Blockly.FieldAngle.RADIUS;
+    var y1 = Math.sin(angle1) * -Blockly.FieldAngle.RADIUS;
+    if (clockwiseFlag) {
+      angleRadians = 2 * angle1 - angleRadians;
+    }
+    x2 += Math.cos(angleRadians) * Blockly.FieldAngle.RADIUS;
+    y2 -= Math.sin(angleRadians) * Blockly.FieldAngle.RADIUS;
+    // Don't ask how the flag calculations work.  They just do.
+    var largeFlag = Math.abs(Math.floor((angleRadians - angle1) / Math.PI) % 2);
+    if (clockwiseFlag) {
+      largeFlag = 1 - largeFlag;
+    }
+    path.push(' l ', x1, ',', y1,
+        ' A ', Blockly.FieldAngle.RADIUS, ',', Blockly.FieldAngle.RADIUS,
+        ' 0 ', largeFlag, ' ', clockwiseFlag, ' ', x2, ',', y2, ' z');
+  }
+  this.gauge_.setAttribute('d', path.join(''));
+  this.line_.setAttribute('x2', x2);
+  this.line_.setAttribute('y2', y2);
+};
+
+/**
+ * Handle key down to the editor.
+ * @param {!Event} e Keyboard event.
+ * @protected
+ * @override
+ */
+Blockly.FieldAngle.prototype.onHtmlInputKeyDown_ = function(e) {
+  Blockly.FieldAngle.superClass_.onHtmlInputKeyDown_.call(this, e);
+
+  var multiplier;
+  if (e.keyCode === Blockly.utils.KeyCodes.LEFT) {
+    // decrement (increment in RTL)
+    multiplier = this.sourceBlock_.RTL ? 1 : -1;
+  } else if (e.keyCode === Blockly.utils.KeyCodes.RIGHT) {
+    // increment (decrement in RTL)
+    multiplier = this.sourceBlock_.RTL ? -1 : 1;
+  } else if (e.keyCode === Blockly.utils.KeyCodes.DOWN) {
+    // decrement
+    multiplier = -1;
+  } else if (e.keyCode === Blockly.utils.KeyCodes.UP) {
+    // increment
+    multiplier = 1;
+  }
+  if (multiplier) {
+    var value = /** @type {number} */ (this.getValue());
+    this.displayMouseOrKeyboardValue_(
+        value + (multiplier * this.round_));
+    e.preventDefault();
+    e.stopPropagation();
+  }
+};
+
+/**
+ * Ensure that the input value is a valid angle.
+ * @param {*=} opt_newValue The input value.
+ * @return {?number} A valid angle, or null if invalid.
+ * @protected
+ * @override
+ */
+Blockly.FieldAngle.prototype.doClassValidation_ = function(opt_newValue) {
+  var value = Number(opt_newValue);
+  if (isNaN(value) || !isFinite(value)) {
+    return null;
+  }
+  return this.wrapValue_(value);
+};
+
+/**
+ * Wraps the value so that it is in the range (-360 + wrap, wrap).
+ * @param {number} value The value to wrap.
+ * @return {number} The wrapped value.
+ * @private
+ */
+Blockly.FieldAngle.prototype.wrapValue_ = function(value) {
+  value %= 360;
+  if (value < 0) {
+    value += 360;
+  }
+  if (value > this.wrap_) {
+    value -= 360;
+  }
+  return value;
+};
+
+/**
+ * CSS for angle field.  See css.js for use.
+ */
+Blockly.Css.register([
+  /* eslint-disable indent */
+  '.blocklyAngleCircle {',
+    'stroke: #444;',
+    'stroke-width: 1;',
+    'fill: #ddd;',
+    'fill-opacity: .8;',
+  '}',
+
+  '.blocklyAngleMarks {',
+    'stroke: #444;',
+    'stroke-width: 1;',
+  '}',
+
+  '.blocklyAngleGauge {',
+    'fill: #f88;',
+    'fill-opacity: .8;',
+    'pointer-events: none;',
+  '}',
+
+  '.blocklyAngleLine {',
+    'stroke: #f00;',
+    'stroke-width: 2;',
+    'stroke-linecap: round;',
+    'pointer-events: none;',
+  '}'
+  /* eslint-enable indent */
+]);
+
+Blockly.fieldRegistry.register('field_angle', Blockly.FieldAngle);

blockly/core/field_checkbox.js

@@ -0,0 +1,220 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Checkbox field.  Checked or not checked.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldCheckbox');
+
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BlockChange');
+goog.require('Blockly.Field');
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a checkbox field.
+ * @param {string|boolean=} opt_value The initial value of the field. Should
+ *    either be 'TRUE', 'FALSE' or a boolean. Defaults to 'FALSE'.
+ * @param {Function=} opt_validator  A function that is called to validate
+ *    changes to the field's value. Takes in a value ('TRUE' or 'FALSE') &
+ *    returns a validated value ('TRUE' or 'FALSE'), or null to abort the
+ *    change.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/checkbox#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.Field}
+ * @constructor
+ */
+Blockly.FieldCheckbox = function(opt_value, opt_validator, opt_config) {
+  /**
+   * Character for the check mark. Used to apply a different check mark
+   * character to individual fields.
+   * @type {?string}
+   * @private
+   */
+  this.checkChar_ = null;
+
+  Blockly.FieldCheckbox.superClass_.constructor.call(
+      this, opt_value, opt_validator, opt_config);
+};
+Blockly.utils.object.inherits(Blockly.FieldCheckbox, Blockly.Field);
+
+/**
+ * The default value for this field.
+ * @type {*}
+ * @protected
+ */
+Blockly.FieldCheckbox.prototype.DEFAULT_VALUE = false;
+
+/**
+ * Construct a FieldCheckbox from a JSON arg object.
+ * @param {!Object} options A JSON object with options (checked).
+ * @return {!Blockly.FieldCheckbox} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldCheckbox.fromJson = function(options) {
+  return new Blockly.FieldCheckbox(options['checked'], undefined, options);
+};
+
+/**
+ * Default character for the checkmark.
+ * @type {string}
+ * @const
+ */
+Blockly.FieldCheckbox.CHECK_CHAR = '\u2713';
+
+/**
+ * Serializable fields are saved by the XML renderer, non-serializable fields
+ * are not. Editable fields should also be serializable.
+ * @type {boolean}
+ */
+Blockly.FieldCheckbox.prototype.SERIALIZABLE = true;
+
+/**
+ * Mouse cursor style when over the hotspot that initiates editability.
+ */
+Blockly.FieldCheckbox.prototype.CURSOR = 'default';
+
+/**
+ * Configure the field based on the given map of options.
+ * @param {!Object} config A map of options to configure the field based on.
+ * @protected
+ * @override
+ */
+Blockly.FieldCheckbox.prototype.configure_ = function(config) {
+  Blockly.FieldCheckbox.superClass_.configure_.call(this, config);
+  if (config['checkCharacter']) {
+    this.checkChar_ = config['checkCharacter'];
+  }
+};
+
+/**
+ * Create the block UI for this checkbox.
+ * @package
+ */
+Blockly.FieldCheckbox.prototype.initView = function() {
+  Blockly.FieldCheckbox.superClass_.initView.call(this);
+
+  Blockly.utils.dom.addClass(
+      /** @type {!SVGTextElement} **/ (this.textElement_), 'blocklyCheckbox');
+  this.textElement_.style.display = this.value_ ? 'block' : 'none';
+};
+
+/**
+ * @override
+ */
+Blockly.FieldCheckbox.prototype.render_ = function() {
+  if (this.textContent_) {
+    this.textContent_.nodeValue = this.getDisplayText_();
+  }
+  this.updateSize_(this.getConstants().FIELD_CHECKBOX_X_OFFSET);
+};
+
+/**
+ * @override
+ */
+Blockly.FieldCheckbox.prototype.getDisplayText_ = function() {
+  return this.checkChar_ || Blockly.FieldCheckbox.CHECK_CHAR;
+};
+
+/**
+ * Set the character used for the check mark.
+ * @param {?string} character The character to use for the check mark, or
+ *    null to use the default.
+ */
+Blockly.FieldCheckbox.prototype.setCheckCharacter = function(character) {
+  this.checkChar_ = character;
+  this.forceRerender();
+};
+
+/**
+ * Toggle the state of the checkbox on click.
+ * @protected
+ */
+Blockly.FieldCheckbox.prototype.showEditor_ = function() {
+  this.setValue(!this.value_);
+};
+
+/**
+ * Ensure that the input value is valid ('TRUE' or 'FALSE').
+ * @param {*=} opt_newValue The input value.
+ * @return {?string} A valid value ('TRUE' or 'FALSE), or null if invalid.
+ * @protected
+ */
+Blockly.FieldCheckbox.prototype.doClassValidation_ = function(opt_newValue) {
+  if (opt_newValue === true || opt_newValue === 'TRUE') {
+    return 'TRUE';
+  }
+  if (opt_newValue === false || opt_newValue === 'FALSE') {
+    return 'FALSE';
+  }
+  return null;
+};
+
+/**
+ * Update the value of the field, and update the checkElement.
+ * @param {*} newValue The value to be saved. The default validator guarantees
+ * that this is a either 'TRUE' or 'FALSE'.
+ * @protected
+ */
+Blockly.FieldCheckbox.prototype.doValueUpdate_ = function(newValue) {
+  this.value_ = this.convertValueToBool_(newValue);
+  // Update visual.
+  if (this.textElement_) {
+    this.textElement_.style.display = this.value_ ? 'block' : 'none';
+  }
+};
+
+/**
+ * Get the value of this field, either 'TRUE' or 'FALSE'.
+ * @return {string} The value of this field.
+ */
+Blockly.FieldCheckbox.prototype.getValue = function() {
+  return this.value_ ? 'TRUE' : 'FALSE';
+};
+
+/**
+ * Get the boolean value of this field.
+ * @return {boolean} The boolean value of this field.
+ */
+Blockly.FieldCheckbox.prototype.getValueBoolean = function() {
+  return /** @type {boolean} */ (this.value_);
+};
+
+/**
+ * Get the text of this field. Used when the block is collapsed.
+ * @return {string} Text representing the value of this field
+ *    ('true' or 'false').
+ */
+Blockly.FieldCheckbox.prototype.getText = function() {
+  return String(this.convertValueToBool_(this.value_));
+};
+
+/**
+ * Convert a value into a pure boolean.
+ *
+ * Converts 'TRUE' to true and 'FALSE' to false correctly, everything else
+ * is cast to a boolean.
+ * @param {*} value The value to convert.
+ * @return {boolean} The converted value.
+ * @private
+ */
+Blockly.FieldCheckbox.prototype.convertValueToBool_ = function(value) {
+  if (typeof value == 'string') {
+    return value == 'TRUE';
+  } else {
+    return !!value;
+  }
+};
+
+Blockly.fieldRegistry.register('field_checkbox', Blockly.FieldCheckbox);

blockly/core/field_colour.js

@@ -0,0 +1,638 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Colour input field.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldColour');
+
+goog.require('Blockly.browserEvents');
+goog.require('Blockly.Css');
+goog.require('Blockly.DropDownDiv');
+/** @suppress {extraRequire} */
+goog.require('Blockly.Events.BlockChange');
+goog.require('Blockly.Field');
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.utils.aria');
+goog.require('Blockly.utils.colour');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.IdGenerator');
+goog.require('Blockly.utils.KeyCodes');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.Size');
+
+
+/**
+ * Class for a colour input field.
+ * @param {string=} opt_value The initial value of the field. Should be in
+ *    '#rrggbb' format. Defaults to the first value in the default colour array.
+ * @param {Function=} opt_validator A function that is called to validate
+ *    changes to the field's value. Takes in a colour string & returns a
+ *    validated colour string ('#rrggbb' format), or null to abort the change.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/colour}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.Field}
+ * @constructor
+ */
+Blockly.FieldColour = function(opt_value, opt_validator, opt_config) {
+  Blockly.FieldColour.superClass_.constructor.call(
+      this, opt_value, opt_validator, opt_config);
+
+  /**
+   * The field's colour picker element.
+   * @type {?Element}
+   * @private
+   */
+  this.picker_ = null;
+
+  /**
+   * Index of the currently highlighted element.
+   * @type {?number}
+   * @private
+   */
+  this.highlightedIndex_ = null;
+
+  /**
+   * Mouse click event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onClickWrapper_ = null;
+
+  /**
+   * Mouse move event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onMouseMoveWrapper_ = null;
+
+  /**
+   * Mouse enter event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onMouseEnterWrapper_ = null;
+
+  /**
+   * Mouse leave event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onMouseLeaveWrapper_ = null;
+
+  /**
+   * Key down event data.
+   * @type {?Blockly.browserEvents.Data}
+   * @private
+   */
+  this.onKeyDownWrapper_ = null;
+};
+Blockly.utils.object.inherits(Blockly.FieldColour, Blockly.Field);
+
+/**
+ * Construct a FieldColour from a JSON arg object.
+ * @param {!Object} options A JSON object with options (colour).
+ * @return {!Blockly.FieldColour} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldColour.fromJson = function(options) {
+  return new Blockly.FieldColour(options['colour'], undefined, options);
+};
+
+/**
+ * Serializable fields are saved by the XML renderer, non-serializable fields
+ * are not. Editable fields should also be serializable.
+ * @type {boolean}
+ */
+Blockly.FieldColour.prototype.SERIALIZABLE = true;
+
+/**
+ * Mouse cursor style when over the hotspot that initiates the editor.
+ */
+Blockly.FieldColour.prototype.CURSOR = 'default';
+
+/**
+ * Used to tell if the field needs to be rendered the next time the block is
+ * rendered. Colour fields are statically sized, and only need to be
+ * rendered at initialization.
+ * @type {boolean}
+ * @protected
+ */
+Blockly.FieldColour.prototype.isDirty_ = false;
+
+/**
+ * Array of colours used by this field.  If null, use the global list.
+ * @type {Array<string>}
+ * @private
+ */
+Blockly.FieldColour.prototype.colours_ = null;
+
+/**
+ * Array of colour tooltips used by this field.  If null, use the global list.
+ * @type {Array<string>}
+ * @private
+ */
+Blockly.FieldColour.prototype.titles_ = null;
+
+/**
+ * Number of colour columns used by this field.  If 0, use the global setting.
+ * By default use the global constants for columns.
+ * @type {number}
+ * @private
+ */
+Blockly.FieldColour.prototype.columns_ = 0;
+
+/**
+ * Configure the field based on the given map of options.
+ * @param {!Object} config A map of options to configure the field based on.
+ * @protected
+ * @override
+ */
+Blockly.FieldColour.prototype.configure_ = function(config) {
+  Blockly.FieldColour.superClass_.configure_.call(this, config);
+  if (config['colourOptions']) {
+    this.colours_ = config['colourOptions'];
+    this.titles_ = config['colourTitles'];
+  }
+  if (config['columns']) {
+    this.columns_ = config['columns'];
+  }
+};
+
+/**
+ * Create the block UI for this colour field.
+ * @package
+ */
+Blockly.FieldColour.prototype.initView = function() {
+  this.size_ = new Blockly.utils.Size(
+      this.getConstants().FIELD_COLOUR_DEFAULT_WIDTH,
+      this.getConstants().FIELD_COLOUR_DEFAULT_HEIGHT);
+  if (!this.getConstants().FIELD_COLOUR_FULL_BLOCK) {
+    this.createBorderRect_();
+    this.borderRect_.style['fillOpacity'] = '1';
+  } else {
+    this.clickTarget_ = this.sourceBlock_.getSvgRoot();
+  }
+};
+
+/**
+ * @override
+ */
+Blockly.FieldColour.prototype.applyColour = function() {
+  if (!this.getConstants().FIELD_COLOUR_FULL_BLOCK) {
+    if (this.borderRect_) {
+      this.borderRect_.style.fill = /** @type {string} */ (this.getValue());
+    }
+  } else {
+    this.sourceBlock_.pathObject.svgPath.setAttribute('fill', this.getValue());
+    this.sourceBlock_.pathObject.svgPath.setAttribute('stroke', '#fff');
+  }
+};
+
+/**
+ * Ensure that the input value is a valid colour.
+ * @param {*=} opt_newValue The input value.
+ * @return {?string} A valid colour, or null if invalid.
+ * @protected
+ */
+Blockly.FieldColour.prototype.doClassValidation_ = function(opt_newValue) {
+  if (typeof opt_newValue != 'string') {
+    return null;
+  }
+  return Blockly.utils.colour.parse(opt_newValue);
+};
+
+/**
+ * Update the value of this colour field, and update the displayed colour.
+ * @param {*} newValue The value to be saved. The default validator guarantees
+ * that this is a colour in '#rrggbb' format.
+ * @protected
+ */
+Blockly.FieldColour.prototype.doValueUpdate_ = function(newValue) {
+  this.value_ = newValue;
+  if (this.borderRect_) {
+    this.borderRect_.style.fill = /** @type {string} */ (newValue);
+  } else if (this.sourceBlock_ && this.sourceBlock_.rendered) {
+    this.sourceBlock_.pathObject.svgPath.setAttribute('fill', newValue);
+    this.sourceBlock_.pathObject.svgPath.setAttribute('stroke', '#fff');
+  }
+};
+
+/**
+ * Get the text for this field.  Used when the block is collapsed.
+ * @return {string} Text representing the value of this field.
+ */
+Blockly.FieldColour.prototype.getText = function() {
+  var colour = /** @type {string} */ (this.value_);
+  // Try to use #rgb format if possible, rather than #rrggbb.
+  if (/^#(.)\1(.)\2(.)\3$/.test(colour)) {
+    colour = '#' + colour[1] + colour[3] + colour[5];
+  }
+  return colour;
+};
+
+/**
+ * An array of colour strings for the palette.
+ * Copied from goog.ui.ColorPicker.SIMPLE_GRID_COLORS
+ * All colour pickers use this unless overridden with setColours.
+ * @type {!Array<string>}
+ */
+Blockly.FieldColour.COLOURS = [
+  // grays
+  '#ffffff', '#cccccc', '#c0c0c0', '#999999', '#666666', '#333333', '#000000',
+  // reds
+  '#ffcccc', '#ff6666', '#ff0000', '#cc0000', '#990000', '#660000', '#330000',
+  // oranges
+  '#ffcc99', '#ff9966', '#ff9900', '#ff6600', '#cc6600', '#993300', '#663300',
+  // yellows
+  '#ffff99', '#ffff66', '#ffcc66', '#ffcc33', '#cc9933', '#996633', '#663333',
+  // olives
+  '#ffffcc', '#ffff33', '#ffff00', '#ffcc00', '#999900', '#666600', '#333300',
+  // greens
+  '#99ff99', '#66ff99', '#33ff33', '#33cc00', '#009900', '#006600', '#003300',
+  // turquoises
+  '#99ffff', '#33ffff', '#66cccc', '#00cccc', '#339999', '#336666', '#003333',
+  // blues
+  '#ccffff', '#66ffff', '#33ccff', '#3366ff', '#3333ff', '#000099', '#000066',
+  // purples
+  '#ccccff', '#9999ff', '#6666cc', '#6633ff', '#6600cc', '#333399', '#330099',
+  // violets
+  '#ffccff', '#ff99ff', '#cc66cc', '#cc33cc', '#993399', '#663366', '#330033'
+];
+
+/**
+ * The default value for this field.
+ * @type {*}
+ * @protected
+ */
+Blockly.FieldColour.prototype.DEFAULT_VALUE = Blockly.FieldColour.COLOURS[0];
+
+/**
+ * An array of tooltip strings for the palette.  If not the same length as
+ * COLOURS, the colour's hex code will be used for any missing titles.
+ * All colour pickers use this unless overridden with setColours.
+ * @type {!Array<string>}
+ */
+Blockly.FieldColour.TITLES = [];
+
+/**
+ * Number of columns in the palette.
+ * All colour pickers use this unless overridden with setColumns.
+ */
+Blockly.FieldColour.COLUMNS = 7;
+
+/**
+ * Set a custom colour grid for this field.
+ * @param {Array<string>} colours Array of colours for this block,
+ *     or null to use default (Blockly.FieldColour.COLOURS).
+ * @param {Array<string>=} opt_titles Optional array of colour tooltips,
+ *     or null to use default (Blockly.FieldColour.TITLES).
+ * @return {!Blockly.FieldColour} Returns itself (for method chaining).
+ */
+Blockly.FieldColour.prototype.setColours = function(colours, opt_titles) {
+  this.colours_ = colours;
+  if (opt_titles) {
+    this.titles_ = opt_titles;
+  }
+  return this;
+};
+
+/**
+ * Set a custom grid size for this field.
+ * @param {number} columns Number of columns for this block,
+ *     or 0 to use default (Blockly.FieldColour.COLUMNS).
+ * @return {!Blockly.FieldColour} Returns itself (for method chaining).
+ */
+Blockly.FieldColour.prototype.setColumns = function(columns) {
+  this.columns_ = columns;
+  return this;
+};
+
+/**
+ * Create and show the colour field's editor.
+ * @protected
+ */
+Blockly.FieldColour.prototype.showEditor_ = function() {
+  this.dropdownCreate_();
+  Blockly.DropDownDiv.getContentDiv().appendChild(this.picker_);
+
+  Blockly.DropDownDiv.showPositionedByField(
+      this, this.dropdownDispose_.bind(this));
+
+  // Focus so we can start receiving keyboard events.
+  this.picker_.focus({preventScroll:true});
+};
+
+/**
+ * Handle a click on a colour cell.
+ * @param {!MouseEvent} e Mouse event.
+ * @private
+ */
+Blockly.FieldColour.prototype.onClick_ = function(e) {
+  var cell = /** @type {!Element} */ (e.target);
+  var colour = cell && cell.label;
+  if (colour !== null) {
+    this.setValue(colour);
+    Blockly.DropDownDiv.hideIfOwner(this);
+  }
+};
+
+/**
+ * Handle a key down event. Navigate around the grid with the
+ * arrow keys. Enter selects the highlighted colour.
+ * @param {!KeyboardEvent} e Keyboard event.
+ * @private
+ */
+Blockly.FieldColour.prototype.onKeyDown_ = function(e) {
+  var handled = false;
+  if (e.keyCode === Blockly.utils.KeyCodes.UP) {
+    this.moveHighlightBy_(0, -1);
+    handled = true;
+  } else if (e.keyCode === Blockly.utils.KeyCodes.DOWN) {
+    this.moveHighlightBy_(0, 1);
+    handled = true;
+  } else if (e.keyCode === Blockly.utils.KeyCodes.LEFT) {
+    this.moveHighlightBy_(-1, 0);
+    handled = true;
+  } else if (e.keyCode === Blockly.utils.KeyCodes.RIGHT) {
+    this.moveHighlightBy_(1, 0);
+    handled = true;
+  } else if (e.keyCode === Blockly.utils.KeyCodes.ENTER) {
+    // Select the highlighted colour.
+    var highlighted = this.getHighlighted_();
+    if (highlighted) {
+      var colour = highlighted && highlighted.label;
+      if (colour !== null) {
+        this.setValue(colour);
+      }
+    }
+    Blockly.DropDownDiv.hideWithoutAnimation();
+    handled = true;
+  }
+  if (handled) {
+    e.stopPropagation();
+  }
+};
+
+/**
+ * Move the currently highlighted position by dx and dy.
+ * @param {number} dx Change of x
+ * @param {number} dy Change of y
+ * @private
+ */
+Blockly.FieldColour.prototype.moveHighlightBy_ = function(dx, dy) {
+  var colours = this.colours_ || Blockly.FieldColour.COLOURS;
+  var columns = this.columns_ || Blockly.FieldColour.COLUMNS;
+
+  // Get the current x and y coordinates
+  var x = this.highlightedIndex_ % columns;
+  var y = Math.floor(this.highlightedIndex_ / columns);
+
+  // Add the offset
+  x += dx;
+  y += dy;
+
+  if (dx < 0) {
+    // Move left one grid cell, even in RTL.
+    // Loop back to the end of the previous row if we have room.
+    if (x < 0 && y > 0) {
+      x = columns - 1;
+      y--;
+    } else if (x < 0) {
+      x = 0;
+    }
+  } else if (dx > 0) {
+    // Move right one grid cell, even in RTL.
+    // Loop to the start of the next row, if there's room.
+    if (x > columns - 1 &&
+      y < Math.floor(colours.length / columns) - 1) {
+      x = 0;
+      y++;
+    } else if (x > columns - 1) {
+      x--;
+    }
+  } else if (dy < 0) {
+    // Move up one grid cell, stop at the top.
+    if (y < 0) {
+      y = 0;
+    }
+  } else if (dy > 0) {
+    // Move down one grid cell, stop at the bottom.
+    if (y > Math.floor(colours.length / columns) - 1) {
+      y = Math.floor(colours.length / columns) - 1;
+    }
+  }
+
+  // Move the highlight to the new coordinates.
+  var cell = /** @type {!Element} */ (this.picker_.childNodes[y].childNodes[x]);
+  var index = (y * columns) + x;
+  this.setHighlightedCell_(cell, index);
+};
+
+/**
+ * Handle a mouse move event. Highlight the hovered colour.
+ * @param {!MouseEvent} e Mouse event.
+ * @private
+ */
+Blockly.FieldColour.prototype.onMouseMove_ = function(e) {
+  var cell = /** @type {!Element} */ (e.target);
+  var index = cell && Number(cell.getAttribute('data-index'));
+  if (index !== null && index !== this.highlightedIndex_) {
+    this.setHighlightedCell_(cell, index);
+  }
+};
+
+/**
+ * Handle a mouse enter event. Focus the picker.
+ * @private
+ */
+Blockly.FieldColour.prototype.onMouseEnter_ = function() {
+  this.picker_.focus({preventScroll:true});
+};
+
+/**
+ * Handle a mouse leave event. Blur the picker and unhighlight
+ * the currently highlighted colour.
+ * @private
+ */
+Blockly.FieldColour.prototype.onMouseLeave_ = function() {
+  this.picker_.blur();
+  var highlighted = this.getHighlighted_();
+  if (highlighted) {
+    Blockly.utils.dom.removeClass(highlighted, 'blocklyColourHighlighted');
+  }
+};
+
+/**
+ * Returns the currently highlighted item (if any).
+ * @return {?HTMLElement} Highlighted item (null if none).
+ * @private
+ */
+Blockly.FieldColour.prototype.getHighlighted_ = function() {
+  var columns = this.columns_ || Blockly.FieldColour.COLUMNS;
+  var x = this.highlightedIndex_ % columns;
+  var y = Math.floor(this.highlightedIndex_ / columns);
+  var row = this.picker_.childNodes[y];
+  if (!row) {
+    return null;
+  }
+  var col = /** @type {HTMLElement} */ (row.childNodes[x]);
+  return col;
+};
+
+/**
+ * Update the currently highlighted cell.
+ * @param {!Element} cell the new cell to highlight
+ * @param {number} index the index of the new cell
+ * @private
+ */
+Blockly.FieldColour.prototype.setHighlightedCell_ = function(cell, index) {
+  // Unhighlight the current item.
+  var highlighted = this.getHighlighted_();
+  if (highlighted) {
+    Blockly.utils.dom.removeClass(highlighted, 'blocklyColourHighlighted');
+  }
+  // Highlight new item.
+  Blockly.utils.dom.addClass(cell, 'blocklyColourHighlighted');
+  // Set new highlighted index.
+  this.highlightedIndex_ = index;
+
+  // Update accessibility roles.
+  Blockly.utils.aria.setState(/** @type {!Element} */ (this.picker_),
+      Blockly.utils.aria.State.ACTIVEDESCENDANT, cell.getAttribute('id'));
+};
+
+/**
+ * Create a colour picker dropdown editor.
+ * @private
+ */
+Blockly.FieldColour.prototype.dropdownCreate_ = function() {
+  var columns = this.columns_ || Blockly.FieldColour.COLUMNS;
+  var colours = this.colours_ || Blockly.FieldColour.COLOURS;
+  var titles = this.titles_ || Blockly.FieldColour.TITLES;
+  var selectedColour = this.getValue();
+  // Create the palette.
+  var table = document.createElement('table');
+  table.className = 'blocklyColourTable';
+  table.tabIndex = 0;
+  table.dir = 'ltr';
+  Blockly.utils.aria.setRole(table, Blockly.utils.aria.Role.GRID);
+  Blockly.utils.aria.setState(table, Blockly.utils.aria.State.EXPANDED, true);
+  Blockly.utils.aria.setState(table, Blockly.utils.aria.State.ROWCOUNT,
+      Math.floor(colours.length / columns));
+  Blockly.utils.aria.setState(table, Blockly.utils.aria.State.COLCOUNT,
+      columns);
+  var row;
+  for (var i = 0; i < colours.length; i++) {
+    if (i % columns == 0) {
+      row = document.createElement('tr');
+      Blockly.utils.aria.setRole(row, Blockly.utils.aria.Role.ROW);
+      table.appendChild(row);
+    }
+    var cell = document.createElement('td');
+    row.appendChild(cell);
+    cell.label = colours[i];  // This becomes the value, if clicked.
+    cell.title = titles[i] || colours[i];
+    cell.id = Blockly.utils.IdGenerator.getNextUniqueId();
+    cell.setAttribute('data-index', i);
+    Blockly.utils.aria.setRole(cell, Blockly.utils.aria.Role.GRIDCELL);
+    Blockly.utils.aria.setState(cell,
+        Blockly.utils.aria.State.LABEL, colours[i]);
+    Blockly.utils.aria.setState(cell,
+        Blockly.utils.aria.State.SELECTED, colours[i] == selectedColour);
+    cell.style.backgroundColor = colours[i];
+    if (colours[i] == selectedColour) {
+      cell.className = 'blocklyColourSelected';
+      this.highlightedIndex_ = i;
+    }
+  }
+
+  // Configure event handler on the table to listen for any event in a cell.
+  this.onClickWrapper_ = Blockly.browserEvents.conditionalBind(
+      table, 'click', this, this.onClick_, true);
+  this.onMouseMoveWrapper_ = Blockly.browserEvents.conditionalBind(
+      table, 'mousemove', this, this.onMouseMove_, true);
+  this.onMouseEnterWrapper_ = Blockly.browserEvents.conditionalBind(
+      table, 'mouseenter', this, this.onMouseEnter_, true);
+  this.onMouseLeaveWrapper_ = Blockly.browserEvents.conditionalBind(
+      table, 'mouseleave', this, this.onMouseLeave_, true);
+  this.onKeyDownWrapper_ = Blockly.browserEvents.conditionalBind(
+      table, 'keydown', this, this.onKeyDown_);
+
+  this.picker_ = table;
+};
+
+/**
+ * Disposes of events and DOM-references belonging to the colour editor.
+ * @private
+ */
+Blockly.FieldColour.prototype.dropdownDispose_ = function() {
+  if (this.onClickWrapper_) {
+    Blockly.browserEvents.unbind(this.onClickWrapper_);
+    this.onClickWrapper_ = null;
+  }
+  if (this.onMouseMoveWrapper_) {
+    Blockly.browserEvents.unbind(this.onMouseMoveWrapper_);
+    this.onMouseMoveWrapper_ = null;
+  }
+  if (this.onMouseEnterWrapper_) {
+    Blockly.browserEvents.unbind(this.onMouseEnterWrapper_);
+    this.onMouseEnterWrapper_ = null;
+  }
+  if (this.onMouseLeaveWrapper_) {
+    Blockly.browserEvents.unbind(this.onMouseLeaveWrapper_);
+    this.onMouseLeaveWrapper_ = null;
+  }
+  if (this.onKeyDownWrapper_) {
+    Blockly.browserEvents.unbind(this.onKeyDownWrapper_);
+    this.onKeyDownWrapper_ = null;
+  }
+  this.picker_ = null;
+  this.highlightedIndex_ = null;
+};
+
+/**
+ * CSS for colour picker.  See css.js for use.
+ */
+Blockly.Css.register([
+  /* eslint-disable indent */
+  '.blocklyColourTable {',
+    'border-collapse: collapse;',
+    'display: block;',
+    'outline: none;',
+    'padding: 1px;',
+  '}',
+
+  '.blocklyColourTable>tr>td {',
+    'border: .5px solid #888;',
+    'box-sizing: border-box;',
+    'cursor: pointer;',
+    'display: inline-block;',
+    'height: 20px;',
+    'padding: 0;',
+    'width: 20px;',
+  '}',
+
+  '.blocklyColourTable>tr>td.blocklyColourHighlighted {',
+    'border-color: #eee;',
+    'box-shadow: 2px 2px 7px 2px rgba(0,0,0,.3);',
+    'position: relative;',
+  '}',
+
+  '.blocklyColourSelected, .blocklyColourSelected:hover {',
+    'border-color: #eee !important;',
+    'outline: 1px solid #333;',
+    'position: relative;',
+  '}'
+  /* eslint-enable indent */
+]);
+
+Blockly.fieldRegistry.register('field_colour', Blockly.FieldColour);

blockly/core/field_dropdown.js

@@ -0,0 +1,748 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Dropdown input field.  Used for editable titles and variables.
+ * In the interests of a consistent UI, the toolbox shares some functions and
+ * properties with the context menu.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldDropdown');
+
+goog.require('Blockly.DropDownDiv');
+goog.require('Blockly.Field');
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.Menu');
+goog.require('Blockly.MenuItem');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.aria');
+goog.require('Blockly.utils.Coordinate');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.string');
+goog.require('Blockly.utils.Svg');
+goog.require('Blockly.utils.userAgent');
+
+
+/**
+ * Class for an editable dropdown field.
+ * @param {(!Array<!Array>|!Function)} menuGenerator A non-empty array of
+ *     options for a dropdown list, or a function which generates these options.
+ * @param {Function=} opt_validator A function that is called to validate
+ *    changes to the field's value. Takes in a language-neutral dropdown
+ *    option & returns a validated language-neutral dropdown option, or null to
+ *    abort the change.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/dropdown#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.Field}
+ * @constructor
+ * @throws {TypeError} If `menuGenerator` options are incorrectly structured.
+ */
+Blockly.FieldDropdown = function(menuGenerator, opt_validator, opt_config) {
+  if (typeof menuGenerator != 'function') {
+    Blockly.FieldDropdown.validateOptions_(menuGenerator);
+  }
+
+  /**
+   * An array of options for a dropdown list,
+   * or a function which generates these options.
+   * @type {(!Array<!Array>|
+   *    !function(this:Blockly.FieldDropdown): !Array<!Array>)}
+   * @protected
+   */
+  this.menuGenerator_ = menuGenerator;
+
+  /**
+   * A cache of the most recently generated options.
+   * @type {Array<!Array<string>>}
+   * @private
+   */
+  this.generatedOptions_ = null;
+
+  /**
+   * The prefix field label, of common words set after options are trimmed.
+   * @type {?string}
+   * @package
+   */
+  this.prefixField = null;
+
+  /**
+   * The suffix field label, of common words set after options are trimmed.
+   * @type {?string}
+   * @package
+   */
+  this.suffixField = null;
+
+  this.trimOptions_();
+
+  /**
+   * The currently selected option. The field is initialized with the
+   * first option selected.
+   * @type {!Object}
+   * @private
+   */
+  this.selectedOption_ = this.getOptions(false)[0];
+
+  // Call parent's constructor.
+  Blockly.FieldDropdown.superClass_.constructor.call(
+      this, this.selectedOption_[1], opt_validator, opt_config);
+
+  /**
+   * A reference to the currently selected menu item.
+   * @type {?Blockly.MenuItem}
+   * @private
+   */
+  this.selectedMenuItem_ = null;
+
+  /**
+   * The dropdown menu.
+   * @type {?Blockly.Menu}
+   * @protected
+   */
+  this.menu_ = null;
+
+  /**
+   * SVG image element if currently selected option is an image, or null.
+   * @type {?SVGImageElement}
+   * @private
+   */
+  this.imageElement_ = null;
+
+  /**
+   * Tspan based arrow element.
+   * @type {?SVGTSpanElement}
+   * @private
+   */
+  this.arrow_ = null;
+
+  /**
+   * SVG based arrow element.
+   * @type {?SVGElement}
+   * @private
+   */
+  this.svgArrow_ = null;
+};
+Blockly.utils.object.inherits(Blockly.FieldDropdown, Blockly.Field);
+
+/**
+ * Dropdown image properties.
+ * @typedef {{
+  *            src:string,
+  *            alt:string,
+  *            width:number,
+  *            height:number
+  *          }}
+  */
+Blockly.FieldDropdown.ImageProperties;
+
+/**
+ * Construct a FieldDropdown from a JSON arg object.
+ * @param {!Object} options A JSON object with options (options).
+ * @return {!Blockly.FieldDropdown} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldDropdown.fromJson = function(options) {
+  return new Blockly.FieldDropdown(options['options'], undefined, options);
+};
+
+/**
+ * Sets the field's value based on the given XML element. Should only be
+ * called by Blockly.Xml.
+ * @param {!Element} fieldElement The element containing info about the
+ *    field's state.
+ * @package
+ */
+Blockly.FieldDropdown.prototype.fromXml = function(fieldElement) {
+  if (this.isOptionListDynamic()) {
+    this.getOptions(false);
+  }
+  this.setValue(fieldElement.textContent);
+};
+
+/**
+ * Serializable fields are saved by the XML renderer, non-serializable fields
+ * are not. Editable fields should also be serializable.
+ * @type {boolean}
+ */
+Blockly.FieldDropdown.prototype.SERIALIZABLE = true;
+
+/**
+ * Horizontal distance that a checkmark overhangs the dropdown.
+ */
+Blockly.FieldDropdown.CHECKMARK_OVERHANG = 25;
+
+/**
+ * Maximum height of the dropdown menu, as a percentage of the viewport height.
+ */
+Blockly.FieldDropdown.MAX_MENU_HEIGHT_VH = 0.45;
+
+/**
+ * The y offset from the top of the field to the top of the image, if an image
+ * is selected.
+ * @type {number}
+ * @const
+ * @private
+ */
+Blockly.FieldDropdown.IMAGE_Y_OFFSET = 5;
+
+/**
+ * The total vertical padding above and below an image.
+ * @type {number}
+ * @const
+ * @private
+ */
+Blockly.FieldDropdown.IMAGE_Y_PADDING =
+    Blockly.FieldDropdown.IMAGE_Y_OFFSET * 2;
+
+/**
+ * Android can't (in 2014) display "▾", so use "▼" instead.
+ */
+Blockly.FieldDropdown.ARROW_CHAR =
+    Blockly.utils.userAgent.ANDROID ? '\u25BC' : '\u25BE';
+
+/**
+ * Mouse cursor style when over the hotspot that initiates the editor.
+ */
+Blockly.FieldDropdown.prototype.CURSOR = 'default';
+
+/**
+ * Create the block UI for this dropdown.
+ * @package
+ */
+Blockly.FieldDropdown.prototype.initView = function() {
+  if (this.shouldAddBorderRect_()) {
+    this.createBorderRect_();
+  } else {
+    this.clickTarget_ = this.sourceBlock_.getSvgRoot();
+  }
+  this.createTextElement_();
+
+  this.imageElement_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.IMAGE, {}, this.fieldGroup_);
+
+  if (this.getConstants().FIELD_DROPDOWN_SVG_ARROW) {
+    this.createSVGArrow_();
+  } else {
+    this.createTextArrow_();
+  }
+
+  if (this.borderRect_) {
+    Blockly.utils.dom.addClass(this.borderRect_, 'blocklyDropdownRect');
+  }
+};
+
+/**
+ * Whether or not the dropdown should add a border rect.
+ * @return {boolean} True if the dropdown field should add a border rect.
+ * @protected
+ */
+Blockly.FieldDropdown.prototype.shouldAddBorderRect_ = function() {
+  return !this.getConstants().FIELD_DROPDOWN_NO_BORDER_RECT_SHADOW ||
+      (this.getConstants().FIELD_DROPDOWN_NO_BORDER_RECT_SHADOW &&
+          !this.sourceBlock_.isShadow());
+};
+
+/**
+ * Create a tspan based arrow.
+ * @protected
+ */
+Blockly.FieldDropdown.prototype.createTextArrow_ = function() {
+  this.arrow_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.TSPAN, {}, this.textElement_);
+  this.arrow_.appendChild(document.createTextNode(
+      this.sourceBlock_.RTL ?
+      Blockly.FieldDropdown.ARROW_CHAR + ' ' :
+      ' ' + Blockly.FieldDropdown.ARROW_CHAR));
+  if (this.sourceBlock_.RTL) {
+    this.textElement_.insertBefore(this.arrow_, this.textContent_);
+  } else {
+    this.textElement_.appendChild(this.arrow_);
+  }
+};
+
+/**
+ * Create an SVG based arrow.
+ * @protected
+ */
+Blockly.FieldDropdown.prototype.createSVGArrow_ = function() {
+  this.svgArrow_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.IMAGE, {
+        'height': this.getConstants().FIELD_DROPDOWN_SVG_ARROW_SIZE + 'px',
+        'width': this.getConstants().FIELD_DROPDOWN_SVG_ARROW_SIZE + 'px'
+      }, this.fieldGroup_);
+  this.svgArrow_.setAttributeNS(Blockly.utils.dom.XLINK_NS, 'xlink:href',
+      this.getConstants().FIELD_DROPDOWN_SVG_ARROW_DATAURI);
+};
+
+/**
+ * Create a dropdown menu under the text.
+ * @param {Event=} opt_e Optional mouse event that triggered the field to open,
+ *     or undefined if triggered programmatically.
+ * @protected
+ */
+Blockly.FieldDropdown.prototype.showEditor_ = function(opt_e) {
+  this.dropdownCreate_();
+  if (opt_e && typeof opt_e.clientX === 'number') {
+    this.menu_.openingCoords =
+        new Blockly.utils.Coordinate(opt_e.clientX, opt_e.clientY);
+  } else {
+    this.menu_.openingCoords = null;
+  }
+  // Element gets created in render.
+  this.menu_.render(Blockly.DropDownDiv.getContentDiv());
+  var menuElement = /** @type {!Element} */ (this.menu_.getElement());
+  Blockly.utils.dom.addClass(menuElement, 'blocklyDropdownMenu');
+
+  if (this.getConstants().FIELD_DROPDOWN_COLOURED_DIV) {
+    var primaryColour = (this.sourceBlock_.isShadow()) ?
+        this.sourceBlock_.getParent().getColour() :
+        this.sourceBlock_.getColour();
+    var borderColour = (this.sourceBlock_.isShadow()) ?
+        this.sourceBlock_.getParent().style.colourTertiary :
+        this.sourceBlock_.style.colourTertiary;
+    Blockly.DropDownDiv.setColour(primaryColour, borderColour);
+  }
+
+  Blockly.DropDownDiv.showPositionedByField(
+      this, this.dropdownDispose_.bind(this));
+
+  // Focusing needs to be handled after the menu is rendered and positioned.
+  // Otherwise it will cause a page scroll to get the misplaced menu in
+  // view. See issue #1329.
+  this.menu_.focus();
+
+  if (this.selectedMenuItem_) {
+    this.menu_.setHighlighted(this.selectedMenuItem_);
+  }
+
+  this.applyColour();
+};
+
+/**
+ * Create the dropdown editor.
+ * @private
+ */
+Blockly.FieldDropdown.prototype.dropdownCreate_ = function() {
+  var menu = new Blockly.Menu();
+  menu.setRole(Blockly.utils.aria.Role.LISTBOX);
+  this.menu_ = menu;
+
+  var options = this.getOptions(false);
+  this.selectedMenuItem_ = null;
+  for (var i = 0; i < options.length; i++) {
+    var content = options[i][0];  // Human-readable text or image.
+    var value = options[i][1];    // Language-neutral value.
+    if (typeof content == 'object') {
+      // An image, not text.
+      var image = new Image(content['width'], content['height']);
+      image.src = content['src'];
+      image.alt = content['alt'] || '';
+      content = image;
+    }
+    var menuItem = new Blockly.MenuItem(content, value);
+    menuItem.setRole(Blockly.utils.aria.Role.OPTION);
+    menuItem.setRightToLeft(this.sourceBlock_.RTL);
+    menuItem.setCheckable(true);
+    menu.addChild(menuItem);
+    menuItem.setChecked(value == this.value_);
+    if (value == this.value_) {
+      this.selectedMenuItem_ = menuItem;
+    }
+    menuItem.onAction(this.handleMenuActionEvent_, this);
+  }
+};
+
+/**
+ * Disposes of events and DOM-references belonging to the dropdown editor.
+ * @private
+ */
+Blockly.FieldDropdown.prototype.dropdownDispose_ = function() {
+  if (this.menu_) {
+    this.menu_.dispose();
+  }
+  this.menu_ = null;
+  this.selectedMenuItem_ = null;
+  this.applyColour();
+};
+
+/**
+ * Handle an action in the dropdown menu.
+ * @param {!Blockly.MenuItem} menuItem The MenuItem selected within menu.
+ * @private
+ */
+Blockly.FieldDropdown.prototype.handleMenuActionEvent_ = function(menuItem) {
+  Blockly.DropDownDiv.hideIfOwner(this, true);
+  this.onItemSelected_(/** @type {!Blockly.Menu} */ (this.menu_), menuItem);
+};
+
+/**
+ * Handle the selection of an item in the dropdown menu.
+ * @param {!Blockly.Menu} menu The Menu component clicked.
+ * @param {!Blockly.MenuItem} menuItem The MenuItem selected within menu.
+ * @protected
+ */
+Blockly.FieldDropdown.prototype.onItemSelected_ = function(menu, menuItem) {
+  this.setValue(menuItem.getValue());
+};
+
+/**
+ * Factor out common words in statically defined options.
+ * Create prefix and/or suffix labels.
+ * @private
+ */
+Blockly.FieldDropdown.prototype.trimOptions_ = function() {
+  var options = this.menuGenerator_;
+  if (!Array.isArray(options)) {
+    return;
+  }
+  var hasImages = false;
+
+  // Localize label text and image alt text.
+  for (var i = 0; i < options.length; i++) {
+    var label = options[i][0];
+    if (typeof label == 'string') {
+      options[i][0] = Blockly.utils.replaceMessageReferences(label);
+    } else {
+      if (label.alt != null) {
+        options[i][0].alt = Blockly.utils.replaceMessageReferences(label.alt);
+      }
+      hasImages = true;
+    }
+  }
+  if (hasImages || options.length < 2) {
+    return;  // Do nothing if too few items or at least one label is an image.
+  }
+  var strings = [];
+  for (var i = 0; i < options.length; i++) {
+    strings.push(options[i][0]);
+  }
+  var shortest = Blockly.utils.string.shortestStringLength(strings);
+  var prefixLength = Blockly.utils.string.commonWordPrefix(strings, shortest);
+  var suffixLength = Blockly.utils.string.commonWordSuffix(strings, shortest);
+  if (!prefixLength && !suffixLength) {
+    return;
+  }
+  if (shortest <= prefixLength + suffixLength) {
+    // One or more strings will entirely vanish if we proceed.  Abort.
+    return;
+  }
+  if (prefixLength) {
+    this.prefixField = strings[0].substring(0, prefixLength - 1);
+  }
+  if (suffixLength) {
+    this.suffixField = strings[0].substr(1 - suffixLength);
+  }
+
+  this.menuGenerator_ = Blockly.FieldDropdown.applyTrim_(options, prefixLength,
+      suffixLength);
+};
+
+/**
+ * Use the calculated prefix and suffix lengths to trim all of the options in
+ * the given array.
+ * @param {!Array<!Array>} options Array of option tuples:
+ *     (human-readable text or image, language-neutral name).
+ * @param {number} prefixLength The length of the common prefix.
+ * @param {number} suffixLength The length of the common suffix
+ * @return {!Array<!Array>} A new array with all of the option text trimmed.
+ */
+Blockly.FieldDropdown.applyTrim_ = function(options,
+    prefixLength, suffixLength) {
+  var newOptions = [];
+  // Remove the prefix and suffix from the options.
+  for (var i = 0; i < options.length; i++) {
+    var text = options[i][0];
+    var value = options[i][1];
+    text = text.substring(prefixLength, text.length - suffixLength);
+    newOptions[i] = [text, value];
+  }
+  return newOptions;
+};
+
+/**
+ * @return {boolean} True if the option list is generated by a function.
+ *     Otherwise false.
+ */
+Blockly.FieldDropdown.prototype.isOptionListDynamic = function() {
+  return typeof this.menuGenerator_ == 'function';
+};
+
+/**
+ * Return a list of the options for this dropdown.
+ * @param {boolean=} opt_useCache For dynamic options, whether or not to use the
+ *     cached options or to re-generate them.
+ * @return {!Array<!Array>} A non-empty array of option tuples:
+ *     (human-readable text or image, language-neutral name).
+ * @throws {TypeError} If generated options are incorrectly structured.
+ */
+Blockly.FieldDropdown.prototype.getOptions = function(opt_useCache) {
+  if (this.isOptionListDynamic()) {
+    if (!this.generatedOptions_ || !opt_useCache) {
+      this.generatedOptions_ = this.menuGenerator_.call(this);
+      Blockly.FieldDropdown.validateOptions_(this.generatedOptions_);
+    }
+    return this.generatedOptions_;
+  }
+  return /** @type {!Array<!Array<string>>} */ (this.menuGenerator_);
+};
+
+/**
+ * Ensure that the input value is a valid language-neutral option.
+ * @param {*=} opt_newValue The input value.
+ * @return {?string} A valid language-neutral option, or null if invalid.
+ * @protected
+ */
+Blockly.FieldDropdown.prototype.doClassValidation_ = function(opt_newValue) {
+  var isValueValid = false;
+  var options = this.getOptions(true);
+  for (var i = 0, option; (option = options[i]); i++) {
+    // Options are tuples of human-readable text and language-neutral values.
+    if (option[1] == opt_newValue) {
+      isValueValid = true;
+      break;
+    }
+  }
+  if (!isValueValid) {
+    if (this.sourceBlock_) {
+      console.warn('Cannot set the dropdown\'s value to an unavailable option.' +
+        ' Block type: ' + this.sourceBlock_.type + ', Field name: ' + this.name +
+        ', Value: ' + opt_newValue);
+    }
+    return null;
+  }
+  return /** @type {string} */ (opt_newValue);
+};
+
+/**
+ * Update the value of this dropdown field.
+ * @param {*} newValue The value to be saved. The default validator guarantees
+ * that this is one of the valid dropdown options.
+ * @protected
+ */
+Blockly.FieldDropdown.prototype.doValueUpdate_ = function(newValue) {
+  Blockly.FieldDropdown.superClass_.doValueUpdate_.call(this, newValue);
+  var options = this.getOptions(true);
+  for (var i = 0, option; (option = options[i]); i++) {
+    if (option[1] == this.value_) {
+      this.selectedOption_ = option;
+    }
+  }
+};
+
+/**
+ * Updates the dropdown arrow to match the colour/style of the block.
+ * @package
+ */
+Blockly.FieldDropdown.prototype.applyColour = function() {
+  if (this.borderRect_) {
+    this.borderRect_.setAttribute('stroke',
+        this.sourceBlock_.style.colourTertiary);
+    if (this.menu_) {
+      this.borderRect_.setAttribute('fill',
+          this.sourceBlock_.style.colourTertiary);
+    } else {
+      this.borderRect_.setAttribute('fill', 'transparent');
+    }
+  }
+  // Update arrow's colour.
+  if (this.sourceBlock_ && this.arrow_) {
+    if (this.sourceBlock_.isShadow()) {
+      this.arrow_.style.fill = this.sourceBlock_.style.colourSecondary;
+    } else {
+      this.arrow_.style.fill = this.sourceBlock_.style.colourPrimary;
+    }
+  }
+};
+
+/**
+ * Draws the border with the correct width.
+ * @protected
+ */
+Blockly.FieldDropdown.prototype.render_ = function() {
+  // Hide both elements.
+  this.textContent_.nodeValue = '';
+  this.imageElement_.style.display = 'none';
+
+  // Show correct element.
+  var option = this.selectedOption_ && this.selectedOption_[0];
+  if (option && typeof option == 'object') {
+    this.renderSelectedImage_(
+        /** @type {!Blockly.FieldDropdown.ImageProperties} */ (option));
+  } else {
+    this.renderSelectedText_();
+  }
+
+  this.positionBorderRect_();
+};
+
+/**
+ * Renders the selected option, which must be an image.
+ * @param {!Blockly.FieldDropdown.ImageProperties} imageJson Selected
+ *   option that must be an image.
+ * @private
+ */
+Blockly.FieldDropdown.prototype.renderSelectedImage_ = function(imageJson) {
+  this.imageElement_.style.display = '';
+  this.imageElement_.setAttributeNS(
+      Blockly.utils.dom.XLINK_NS, 'xlink:href', imageJson.src);
+  this.imageElement_.setAttribute('height', imageJson.height);
+  this.imageElement_.setAttribute('width', imageJson.width);
+
+  var imageHeight = Number(imageJson.height);
+  var imageWidth = Number(imageJson.width);
+
+  // Height and width include the border rect.
+  var hasBorder = !!this.borderRect_;
+  var height = Math.max(
+      hasBorder ? this.getConstants().FIELD_DROPDOWN_BORDER_RECT_HEIGHT : 0,
+      imageHeight + Blockly.FieldDropdown.IMAGE_Y_PADDING);
+  var xPadding = hasBorder ? this.getConstants().FIELD_BORDER_RECT_X_PADDING : 0;
+  var arrowWidth = 0;
+  if (this.svgArrow_) {
+    arrowWidth = this.positionSVGArrow_(imageWidth + xPadding, height / 2 -
+      this.getConstants().FIELD_DROPDOWN_SVG_ARROW_SIZE / 2);
+  } else {
+    arrowWidth = Blockly.utils.dom.getFastTextWidth(
+        /** @type {!SVGTSpanElement} */ (this.arrow_),
+        this.getConstants().FIELD_TEXT_FONTSIZE,
+        this.getConstants().FIELD_TEXT_FONTWEIGHT,
+        this.getConstants().FIELD_TEXT_FONTFAMILY);
+  }
+  this.size_.width = imageWidth + arrowWidth + xPadding * 2;
+  this.size_.height = height;
+
+  var arrowX = 0;
+  if (this.sourceBlock_.RTL) {
+    var imageX = xPadding + arrowWidth;
+    this.imageElement_.setAttribute('x', imageX);
+  } else {
+    arrowX = imageWidth + arrowWidth;
+    this.textElement_.setAttribute('text-anchor', 'end');
+    this.imageElement_.setAttribute('x', xPadding);
+  }
+  this.imageElement_.setAttribute('y', height / 2 - imageHeight / 2);
+
+  this.positionTextElement_(arrowX + xPadding, imageWidth + arrowWidth);
+};
+
+/**
+ * Renders the selected option, which must be text.
+ * @private
+ */
+Blockly.FieldDropdown.prototype.renderSelectedText_ = function() {
+  // Retrieves the selected option to display through getText_.
+  this.textContent_.nodeValue = this.getDisplayText_();
+  Blockly.utils.dom.addClass(/** @type {!Element} */ (this.textElement_),
+      'blocklyDropdownText');
+  this.textElement_.setAttribute('text-anchor', 'start');
+
+  // Height and width include the border rect.
+  var hasBorder = !!this.borderRect_;
+  var height = Math.max(
+      hasBorder ? this.getConstants().FIELD_DROPDOWN_BORDER_RECT_HEIGHT : 0,
+      this.getConstants().FIELD_TEXT_HEIGHT);
+  var textWidth = Blockly.utils.dom.getFastTextWidth(this.textElement_,
+      this.getConstants().FIELD_TEXT_FONTSIZE,
+      this.getConstants().FIELD_TEXT_FONTWEIGHT,
+      this.getConstants().FIELD_TEXT_FONTFAMILY);
+  var xPadding = hasBorder ? this.getConstants().FIELD_BORDER_RECT_X_PADDING : 0;
+  var arrowWidth = 0;
+  if (this.svgArrow_) {
+    arrowWidth = this.positionSVGArrow_(textWidth + xPadding, height / 2 -
+        this.getConstants().FIELD_DROPDOWN_SVG_ARROW_SIZE / 2);
+  }
+  this.size_.width = textWidth + arrowWidth + xPadding * 2;
+  this.size_.height = height;
+
+  this.positionTextElement_(xPadding, textWidth);
+};
+
+/**
+ * Position a drop-down arrow at the appropriate location at render-time.
+ * @param {number} x X position the arrow is being rendered at, in px.
+ * @param {number} y Y position the arrow is being rendered at, in px.
+ * @return {number} Amount of space the arrow is taking up, in px.
+ * @private
+ */
+Blockly.FieldDropdown.prototype.positionSVGArrow_ = function(x, y) {
+  if (!this.svgArrow_) {
+    return 0;
+  }
+  var hasBorder = !!this.borderRect_;
+  var xPadding = hasBorder ? this.getConstants().FIELD_BORDER_RECT_X_PADDING : 0;
+  var textPadding = this.getConstants().FIELD_DROPDOWN_SVG_ARROW_PADDING;
+  var svgArrowSize = this.getConstants().FIELD_DROPDOWN_SVG_ARROW_SIZE;
+  var arrowX = this.sourceBlock_.RTL ? xPadding : x + textPadding;
+  this.svgArrow_.setAttribute('transform',
+      'translate(' + arrowX + ',' + y + ')');
+  return svgArrowSize + textPadding;
+};
+
+/**
+ * Use the `getText_` developer hook to override the field's text
+ * representation.  Get the selected option text. If the selected option is an
+ * image we return the image alt text.
+ * @return {?string} Selected option text.
+ * @protected
+ * @override
+ */
+Blockly.FieldDropdown.prototype.getText_ = function() {
+  if (!this.selectedOption_) {
+    return null;
+  }
+  var option = this.selectedOption_[0];
+  if (typeof option == 'object') {
+    return option['alt'];
+  }
+  return option;
+};
+
+/**
+ * Validates the data structure to be processed as an options list.
+ * @param {?} options The proposed dropdown options.
+ * @throws {TypeError} If proposed options are incorrectly structured.
+ * @private
+ */
+Blockly.FieldDropdown.validateOptions_ = function(options) {
+  if (!Array.isArray(options)) {
+    throw TypeError('FieldDropdown options must be an array.');
+  }
+  if (!options.length) {
+    throw TypeError('FieldDropdown options must not be an empty array.');
+  }
+  var foundError = false;
+  for (var i = 0; i < options.length; ++i) {
+    var tuple = options[i];
+    if (!Array.isArray(tuple)) {
+      foundError = true;
+      console.error(
+          'Invalid option[' + i + ']: Each FieldDropdown option must be an ' +
+          'array. Found: ', tuple);
+    } else if (typeof tuple[1] != 'string') {
+      foundError = true;
+      console.error(
+          'Invalid option[' + i + ']: Each FieldDropdown option id must be ' +
+          'a string. Found ' + tuple[1] + ' in: ', tuple);
+    } else if (tuple[0] &&
+              (typeof tuple[0] != 'string') &&
+              (typeof tuple[0].src != 'string')) {
+      foundError = true;
+      console.error(
+          'Invalid option[' + i + ']: Each FieldDropdown option must have a ' +
+          'string label or image description. Found' + tuple[0] + ' in: ',
+          tuple);
+    }
+  }
+  if (foundError) {
+    throw TypeError('Found invalid FieldDropdown options.');
+  }
+};
+
+Blockly.fieldRegistry.register('field_dropdown', Blockly.FieldDropdown);

blockly/core/field_image.js

@@ -0,0 +1,287 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Image field.  Used for pictures, icons, etc.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldImage');
+
+goog.require('Blockly.Field');
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.Size');
+goog.require('Blockly.utils.Svg');
+
+
+/**
+ * Class for an image on a block.
+ * @param {string} src The URL of the image.
+ * @param {!(string|number)} width Width of the image.
+ * @param {!(string|number)} height Height of the image.
+ * @param {string=} opt_alt Optional alt text for when block is collapsed.
+ * @param {function(!Blockly.FieldImage)=} opt_onClick Optional function to be
+ *     called when the image is clicked. If opt_onClick is defined, opt_alt must
+ *     also be defined.
+ * @param {boolean=} opt_flipRtl Whether to flip the icon in RTL.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/image#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.Field}
+ * @constructor
+ */
+Blockly.FieldImage = function(src, width, height,
+    opt_alt, opt_onClick, opt_flipRtl, opt_config) {
+  // Return early.
+  if (!src) {
+    throw Error('Src value of an image field is required');
+  }
+  src = Blockly.utils.replaceMessageReferences(src);
+  var imageHeight = Number(Blockly.utils.replaceMessageReferences(height));
+  var imageWidth = Number(Blockly.utils.replaceMessageReferences(width));
+  if (isNaN(imageHeight) || isNaN(imageWidth)) {
+    throw Error('Height and width values of an image field must cast to' +
+      ' numbers.');
+  }
+  if (imageHeight <= 0 || imageWidth <= 0) {
+    throw Error('Height and width values of an image field must be greater' +
+      ' than 0.');
+  }
+
+  // Initialize configurable properties.
+  /**
+   * Whether to flip this image in RTL.
+   * @type {boolean}
+   * @private
+   */
+  this.flipRtl_ = false;
+
+  /**
+   * Alt text of this image.
+   * @type {string}
+   * @private
+   */
+  this.altText_ = '';
+
+  Blockly.FieldImage.superClass_.constructor.call(
+      this, src, null, opt_config);
+
+  if (!opt_config) {  // If the config wasn't passed, do old configuration.
+    this.flipRtl_ = !!opt_flipRtl;
+    this.altText_ = Blockly.utils.replaceMessageReferences(opt_alt) || '';
+  }
+
+  // Initialize other properties.
+  /**
+   * The size of the area rendered by the field.
+   * @type {Blockly.utils.Size}
+   * @protected
+   * @override
+   */
+  this.size_ = new Blockly.utils.Size(imageWidth,
+      imageHeight + Blockly.FieldImage.Y_PADDING);
+
+  /**
+   * Store the image height, since it is different from the field height.
+   * @type {number}
+   * @private
+   */
+  this.imageHeight_ = imageHeight;
+
+  /**
+   * The function to be called when this field is clicked.
+   * @type {?function(!Blockly.FieldImage)}
+   * @private
+   */
+  this.clickHandler_ = null;
+
+  if (typeof opt_onClick == 'function') {
+    this.clickHandler_ = opt_onClick;
+  }
+
+  /**
+   * The rendered field's image element.
+   * @type {SVGImageElement}
+   * @private
+   */
+  this.imageElement_ = null;
+};
+Blockly.utils.object.inherits(Blockly.FieldImage, Blockly.Field);
+
+/**
+ * The default value for this field.
+ * @type {*}
+ * @protected
+ */
+Blockly.FieldImage.prototype.DEFAULT_VALUE = '';
+
+/**
+ * Construct a FieldImage from a JSON arg object,
+ * dereferencing any string table references.
+ * @param {!Object} options A JSON object with options (src, width, height,
+ *    alt, and flipRtl).
+ * @return {!Blockly.FieldImage} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldImage.fromJson = function(options) {
+  return new Blockly.FieldImage(
+      options['src'], options['width'], options['height'],
+      undefined, undefined, undefined, options);
+};
+
+/**
+ * Vertical padding below the image, which is included in the reported height of
+ * the field.
+ * @type {number}
+ * @private
+ */
+Blockly.FieldImage.Y_PADDING = 1;
+
+/**
+ * Editable fields usually show some sort of UI indicating they are
+ * editable. This field should not.
+ * @type {boolean}
+ */
+Blockly.FieldImage.prototype.EDITABLE = false;
+
+/**
+ * Used to tell if the field needs to be rendered the next time the block is
+ * rendered. Image fields are statically sized, and only need to be
+ * rendered at initialization.
+ * @type {boolean}
+ * @protected
+ */
+Blockly.FieldImage.prototype.isDirty_ = false;
+
+/**
+ * Configure the field based on the given map of options.
+ * @param {!Object} config A map of options to configure the field based on.
+ * @protected
+ * @override
+ */
+Blockly.FieldImage.prototype.configure_ = function(config) {
+  Blockly.FieldImage.superClass_.configure_.call(this, config);
+  this.flipRtl_ = !!config['flipRtl'];
+  this.altText_ = Blockly.utils.replaceMessageReferences(config['alt']) || '';
+};
+
+/**
+ * Create the block UI for this image.
+ * @package
+ */
+Blockly.FieldImage.prototype.initView = function() {
+  this.imageElement_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.IMAGE,
+      {
+        'height': this.imageHeight_ + 'px',
+        'width': this.size_.width + 'px',
+        'alt': this.altText_
+      },
+      this.fieldGroup_);
+  this.imageElement_.setAttributeNS(Blockly.utils.dom.XLINK_NS,
+      'xlink:href', /** @type {string} */ (this.value_));
+
+  if (this.clickHandler_) {
+    this.imageElement_.style.cursor = 'pointer';
+  }
+};
+
+/**
+ * @override
+ */
+Blockly.FieldImage.prototype.updateSize_ = function() {
+  // NOP
+};
+
+/**
+ * Ensure that the input value (the source URL) is a string.
+ * @param {*=} opt_newValue The input value.
+ * @return {?string} A string, or null if invalid.
+ * @protected
+ */
+Blockly.FieldImage.prototype.doClassValidation_ = function(opt_newValue) {
+  if (typeof opt_newValue != 'string') {
+    return null;
+  }
+  return opt_newValue;
+};
+
+/**
+ * Update the value of this image field, and update the displayed image.
+ * @param {*} newValue The value to be saved. The default validator guarantees
+ * that this is a string.
+ * @protected
+ */
+Blockly.FieldImage.prototype.doValueUpdate_ = function(newValue) {
+  this.value_ = newValue;
+  if (this.imageElement_) {
+    this.imageElement_.setAttributeNS(Blockly.utils.dom.XLINK_NS,
+        'xlink:href', String(this.value_));
+  }
+};
+
+/**
+ * Get whether to flip this image in RTL
+ * @return {boolean} True if we should flip in RTL.
+ * @override
+ */
+Blockly.FieldImage.prototype.getFlipRtl = function() {
+  return this.flipRtl_;
+};
+
+/**
+ * Set the alt text of this image.
+ * @param {?string} alt New alt text.
+ * @public
+ */
+Blockly.FieldImage.prototype.setAlt = function(alt) {
+  if (alt == this.altText_) {
+    return;
+  }
+  this.altText_ = alt || '';
+  if (this.imageElement_) {
+    this.imageElement_.setAttribute('alt', this.altText_);
+  }
+};
+
+/**
+ * If field click is called, and click handler defined,
+ * call the handler.
+ * @protected
+ */
+Blockly.FieldImage.prototype.showEditor_ = function() {
+  if (this.clickHandler_) {
+    this.clickHandler_(this);
+  }
+};
+
+/**
+ * Set the function that is called when this image  is clicked.
+ * @param {?function(!Blockly.FieldImage)} func The function that is called
+ *    when the image is clicked, or null to remove.
+ */
+Blockly.FieldImage.prototype.setOnClickHandler = function(func) {
+  this.clickHandler_ = func;
+};
+
+/**
+ * Use the `getText_` developer hook to override the field's text
+ * representation.
+ * Return the image alt text instead.
+ * @return {?string} The image alt text.
+ * @protected
+ * @override
+ */
+Blockly.FieldImage.prototype.getText_ = function() {
+  return this.altText_;
+};
+
+Blockly.fieldRegistry.register('field_image', Blockly.FieldImage);

blockly/core/field_label.js

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Non-editable, non-serializable text field.  Used for titles,
+ *    labels, etc.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldLabel');
+
+goog.require('Blockly.Field');
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a non-editable, non-serializable text field.
+ * @param {string=} opt_value The initial value of the field. Should cast to a
+ *    string. Defaults to an empty string if null or undefined.
+ * @param {string=} opt_class Optional CSS class for the field's text.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/label#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.Field}
+ * @constructor
+ */
+Blockly.FieldLabel = function(opt_value, opt_class, opt_config) {
+  /**
+   * The html class name to use for this field.
+   * @type {?string}
+   * @private
+   */
+  this.class_ = null;
+
+  Blockly.FieldLabel.superClass_.constructor.call(
+      this, opt_value, null, opt_config);
+
+  if (!opt_config) {  // If the config was not passed use old configuration.
+    this.class_ = opt_class || null;
+  }
+};
+Blockly.utils.object.inherits(Blockly.FieldLabel, Blockly.Field);
+
+/**
+ * The default value for this field.
+ * @type {*}
+ * @protected
+ */
+Blockly.FieldLabel.prototype.DEFAULT_VALUE = '';
+
+/**
+ * Construct a FieldLabel from a JSON arg object,
+ * dereferencing any string table references.
+ * @param {!Object} options A JSON object with options (text, and class).
+ * @return {!Blockly.FieldLabel} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldLabel.fromJson = function(options) {
+  var text = Blockly.utils.replaceMessageReferences(options['text']);
+  return new Blockly.FieldLabel(text, undefined, options);
+};
+
+/**
+ * Editable fields usually show some sort of UI indicating they are
+ * editable. This field should not.
+ * @type {boolean}
+ */
+Blockly.FieldLabel.prototype.EDITABLE = false;
+
+/**
+ * @override
+ */
+Blockly.FieldLabel.prototype.configure_ = function(config) {
+  Blockly.FieldLabel.superClass_.configure_.call(this, config);
+  this.class_ = config['class'];
+};
+
+/**
+ * Create block UI for this label.
+ * @package
+ */
+Blockly.FieldLabel.prototype.initView = function() {
+  this.createTextElement_();
+  if (this.class_) {
+    Blockly.utils.dom.addClass(
+        /** @type {!SVGTextElement} */ (this.textElement_), this.class_);
+  }
+};
+
+/**
+ * Ensure that the input value casts to a valid string.
+ * @param {*=} opt_newValue The input value.
+ * @return {?string} A valid string, or null if invalid.
+ * @protected
+ */
+Blockly.FieldLabel.prototype.doClassValidation_ = function(opt_newValue) {
+  if (opt_newValue === null || opt_newValue === undefined) {
+    return null;
+  }
+  return String(opt_newValue);
+};
+
+/**
+ * Set the CSS class applied to the field's textElement_.
+ * @param {?string} cssClass The new CSS class name, or null to remove.
+ */
+Blockly.FieldLabel.prototype.setClass = function(cssClass) {
+  if (this.textElement_) {
+    // This check isn't necessary, but it's faster than letting removeClass
+    // figure it out.
+    if (this.class_) {
+      Blockly.utils.dom.removeClass(this.textElement_, this.class_);
+    }
+    if (cssClass) {
+      Blockly.utils.dom.addClass(this.textElement_, cssClass);
+    }
+  }
+  this.class_ = cssClass;
+};
+
+Blockly.fieldRegistry.register('field_label', Blockly.FieldLabel);

blockly/core/field_label_serializable.js

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Non-editable, serializable text field. Behaves like a
+ *    normal label but is serialized to XML. It may only be
+ *    edited programmatically.
+ */
+'use strict';
+
+goog.provide('Blockly.FieldLabelSerializable');
+
+goog.require('Blockly.FieldLabel');
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a non-editable, serializable text field.
+ * @param {*} opt_value The initial value of the field. Should cast to a
+ *    string. Defaults to an empty string if null or undefined.
+ * @param {string=} opt_class Optional CSS class for the field's text.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/label-serializable#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.FieldLabel}
+ * @constructor
+ *
+ */
+Blockly.FieldLabelSerializable = function(opt_value, opt_class, opt_config) {
+  Blockly.FieldLabelSerializable.superClass_.constructor.call(
+      this, opt_value, opt_class, opt_config);
+};
+Blockly.utils.object.inherits(Blockly.FieldLabelSerializable,
+    Blockly.FieldLabel);
+
+/**
+ * Construct a FieldLabelSerializable from a JSON arg object,
+ * dereferencing any string table references.
+ * @param {!Object} options A JSON object with options (text, and class).
+ * @return {!Blockly.FieldLabelSerializable} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldLabelSerializable.fromJson = function(options) {
+  var text = Blockly.utils.replaceMessageReferences(options['text']);
+  return new Blockly.FieldLabelSerializable(text, undefined, options);
+};
+
+/**
+ * Editable fields usually show some sort of UI indicating they are
+ * editable. This field should not.
+ * @type {boolean}
+ */
+Blockly.FieldLabelSerializable.prototype.EDITABLE = false;
+
+/**
+ * Serializable fields are saved by the XML renderer, non-serializable fields
+ * are not.  This field should be serialized, but only edited programmatically.
+ * @type {boolean}
+ */
+Blockly.FieldLabelSerializable.prototype.SERIALIZABLE = true;
+
+Blockly.fieldRegistry.register(
+    'field_label_serializable', Blockly.FieldLabelSerializable);

blockly/core/field_multilineinput.js

@@ -0,0 +1,414 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Text Area field.
+ * @author fraser@google.com (Neil Fraser)
+ * @author Andrew Mee
+ * @author acbart@udel.edu (Austin Cory Bart)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldMultilineInput');
+
+goog.require('Blockly.Css');
+goog.require('Blockly.Field');
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.FieldTextInput');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.aria');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.KeyCodes');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.Svg');
+goog.require('Blockly.utils.userAgent');
+goog.require('Blockly.WidgetDiv');
+
+
+/**
+ * Class for an editable text area field.
+ * @param {string=} opt_value The initial content of the field. Should cast to a
+ *    string. Defaults to an empty string if null or undefined.
+ * @param {Function=} opt_validator An optional function that is called
+ *     to validate any constraints on what the user entered.  Takes the new
+ *     text as an argument and returns either the accepted text, a replacement
+ *     text, or null to abort the change.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/multiline-text-input#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.FieldTextInput}
+ * @constructor
+ */
+Blockly.FieldMultilineInput = function(opt_value, opt_validator, opt_config) {
+  Blockly.FieldMultilineInput.superClass_.constructor.call(this,
+      opt_value, opt_validator, opt_config);
+
+  /**
+   * The SVG group element that will contain a text element for each text row
+   *     when initialized.
+   * @type {SVGGElement}
+   */
+  this.textGroup_ = null;
+
+  /**
+   * Defines the maximum number of lines of field.
+   * If exceeded, scrolling functionality is enabled.
+   * @type {number}
+   * @protected
+   */
+  this.maxLines_ = Infinity;
+
+  /**
+   * Whether Y overflow is currently occurring.
+   * @type {boolean}
+   * @protected
+   */
+  this.isOverflowedY_ = false;
+};
+Blockly.utils.object.inherits(Blockly.FieldMultilineInput,
+    Blockly.FieldTextInput);
+
+/**
+ * @override
+ */
+Blockly.FieldMultilineInput.prototype.configure_ = function(config) {
+  Blockly.FieldMultilineInput.superClass_.configure_.call(this, config);
+  config.maxLines && this.setMaxLines(config.maxLines);
+};
+
+/**
+ * Construct a FieldMultilineInput from a JSON arg object,
+ * dereferencing any string table references.
+ * @param {!Object} options A JSON object with options (text, and spellcheck).
+ * @return {!Blockly.FieldMultilineInput} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldMultilineInput.fromJson = function(options) {
+  var text = Blockly.utils.replaceMessageReferences(options['text']);
+  return new Blockly.FieldMultilineInput(text, undefined, options);
+};
+
+/**
+ * Serializes this field's value to XML. Should only be called by Blockly.Xml.
+ * @param {!Element} fieldElement The element to populate with info about the
+ *    field's state.
+ * @return {!Element} The element containing info about the field's state.
+ * @package
+ */
+Blockly.FieldMultilineInput.prototype.toXml = function(fieldElement) {
+  // Replace '\n' characters with HTML-escaped equivalent '&#10'. This is
+  // needed so the plain-text representation of the XML produced by
+  // `Blockly.Xml.domToText` will appear on a single line (this is a limitation
+  // of the plain-text format).
+  fieldElement.textContent = this.getValue().replace(/\n/g, '
');
+  return fieldElement;
+};
+
+/**
+ * Sets the field's value based on the given XML element. Should only be
+ * called by Blockly.Xml.
+ * @param {!Element} fieldElement The element containing info about the
+ *    field's state.
+ * @package
+ */
+Blockly.FieldMultilineInput.prototype.fromXml = function(fieldElement) {
+  this.setValue(fieldElement.textContent.replace(/
/g, '\n'));
+};
+
+/**
+ * Create the block UI for this field.
+ * @package
+ */
+Blockly.FieldMultilineInput.prototype.initView = function() {
+  this.createBorderRect_();
+  this.textGroup_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.G, {
+        'class': 'blocklyEditableText',
+      }, this.fieldGroup_);
+};
+
+/**
+ * Get the text from this field as displayed on screen.  May differ from getText
+ * due to ellipsis, and other formatting.
+ * @return {string} Currently displayed text.
+ * @protected
+ * @override
+ */
+Blockly.FieldMultilineInput.prototype.getDisplayText_ = function() {
+  var textLines = this.getText();
+  if (!textLines) {
+    // Prevent the field from disappearing if empty.
+    return Blockly.Field.NBSP;
+  }
+  var lines = textLines.split('\n');
+  textLines = '';
+  var displayLinesNumber = this.isOverflowedY_ ? this.maxLines_ : lines.length;
+  for (var i = 0; i < displayLinesNumber; i++) {
+    var text = lines[i];
+    if (text.length > this.maxDisplayLength) {
+      // Truncate displayed string and add an ellipsis ('...').
+      text = text.substring(0, this.maxDisplayLength - 4) + '...';
+    } else if (this.isOverflowedY_ && i === displayLinesNumber - 1) {
+      text = text.substring(0, text.length - 3) + '...';
+    }
+    // Replace whitespace with non-breaking spaces so the text doesn't collapse.
+    text = text.replace(/\s/g, Blockly.Field.NBSP);
+
+    textLines += text;
+    if (i !== displayLinesNumber - 1) {
+      textLines += '\n';
+    }
+  }
+  if (this.sourceBlock_.RTL) {
+    // The SVG is LTR, force value to be RTL.
+    textLines += '\u200F';
+  }
+  return textLines;
+};
+
+/**
+ * Called by setValue if the text input is valid. Updates the value of the
+ * field, and updates the text of the field if it is not currently being
+ * edited (i.e. handled by the htmlInput_). Is being redefined here to update
+ * overflow state of the field.
+ * @param {*} newValue The value to be saved. The default validator guarantees
+ * that this is a string.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.doValueUpdate_ = function(newValue) {
+  Blockly.FieldMultilineInput.superClass_.doValueUpdate_.call(this, newValue);
+  this.isOverflowedY_ = this.value_.split('\n').length > this.maxLines_;
+};
+
+/**
+ * Updates the text of the textElement.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.render_ = function() {
+  // Remove all text group children.
+  var currentChild;
+  while ((currentChild = this.textGroup_.firstChild)) {
+    this.textGroup_.removeChild(currentChild);
+  }
+
+  // Add in text elements into the group.
+  var lines = this.getDisplayText_().split('\n');
+  var y = 0;
+  for (var i = 0; i < lines.length; i++) {
+    var lineHeight = this.getConstants().FIELD_TEXT_HEIGHT +
+        this.getConstants().FIELD_BORDER_RECT_Y_PADDING;
+    var span = Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.TEXT, {
+          'class': 'blocklyText blocklyMultilineText',
+          x: this.getConstants().FIELD_BORDER_RECT_X_PADDING,
+          y: y + this.getConstants().FIELD_BORDER_RECT_Y_PADDING,
+          dy: this.getConstants().FIELD_TEXT_BASELINE
+        }, this.textGroup_);
+    span.appendChild(document.createTextNode(lines[i]));
+    y += lineHeight;
+  }
+
+  if (this.isBeingEdited_) {
+    var htmlInput = /** @type {!HTMLElement} */(this.htmlInput_);
+    if (this.isOverflowedY_) {
+      Blockly.utils.dom.addClass(htmlInput, 'blocklyHtmlTextAreaInputOverflowedY');
+    } else {
+      Blockly.utils.dom.removeClass(htmlInput, 'blocklyHtmlTextAreaInputOverflowedY');
+    }
+  }
+
+  this.updateSize_();
+
+  if (this.isBeingEdited_) {
+    if (this.sourceBlock_.RTL) {
+      // in RTL, we need to let the browser reflow before resizing
+      // in order to get the correct bounding box of the borderRect
+      // avoiding issue #2777.
+      setTimeout(this.resizeEditor_.bind(this), 0);
+    } else {
+      this.resizeEditor_();
+    }
+    var htmlInput = /** @type {!HTMLElement} */(this.htmlInput_);
+    if (!this.isTextValid_) {
+      Blockly.utils.dom.addClass(htmlInput, 'blocklyInvalidInput');
+      Blockly.utils.aria.setState(htmlInput,
+          Blockly.utils.aria.State.INVALID, true);
+    } else {
+      Blockly.utils.dom.removeClass(htmlInput, 'blocklyInvalidInput');
+      Blockly.utils.aria.setState(htmlInput,
+          Blockly.utils.aria.State.INVALID, false);
+    }
+  }
+};
+
+/**
+ * Updates the size of the field based on the text.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.updateSize_ = function() {
+  var nodes = this.textGroup_.childNodes;
+  var totalWidth = 0;
+  var totalHeight = 0;
+  for (var i = 0; i < nodes.length; i++) {
+    var tspan = /** @type {!Element} */ (nodes[i]);
+    var textWidth = Blockly.utils.dom.getTextWidth(tspan);
+    if (textWidth > totalWidth) {
+      totalWidth = textWidth;
+    }
+    totalHeight += this.getConstants().FIELD_TEXT_HEIGHT +
+        (i > 0 ? this.getConstants().FIELD_BORDER_RECT_Y_PADDING : 0);
+  }
+  if (this.isBeingEdited_) {
+    // The default width is based on the longest line in the display text,
+    // but when it's being edited, width should be calculated based on the
+    // absolute longest line, even if it would be truncated after editing.
+    // Otherwise we would get wrong editor width when there are more
+    // lines than this.maxLines_.
+    var actualEditorLines = this.value_.split('\n');
+    var dummyTextElement = Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.TEXT,{'class': 'blocklyText blocklyMultilineText'});
+    var fontSize = this.getConstants().FIELD_TEXT_FONTSIZE;
+    var fontWeight = this.getConstants().FIELD_TEXT_FONTWEIGHT;
+    var fontFamily = this.getConstants().FIELD_TEXT_FONTFAMILY;
+
+    for (var i = 0; i < actualEditorLines.length; i++) {
+      if (actualEditorLines[i].length > this.maxDisplayLength) {
+        actualEditorLines[i] = actualEditorLines[i].substring(0, this.maxDisplayLength);
+      }
+      dummyTextElement.textContent = actualEditorLines[i];
+      var lineWidth = Blockly.utils.dom.getFastTextWidth(
+          dummyTextElement, fontSize, fontWeight, fontFamily);
+      if (lineWidth > totalWidth) {
+        totalWidth = lineWidth;
+      }
+    }
+
+    var scrollbarWidth = this.htmlInput_.offsetWidth - this.htmlInput_.clientWidth;
+    totalWidth += scrollbarWidth;
+  }
+  if (this.borderRect_) {
+    totalHeight += this.getConstants().FIELD_BORDER_RECT_Y_PADDING * 2;
+    totalWidth += this.getConstants().FIELD_BORDER_RECT_X_PADDING * 2;
+    this.borderRect_.setAttribute('width', totalWidth);
+    this.borderRect_.setAttribute('height', totalHeight);
+  }
+  this.size_.width = totalWidth;
+  this.size_.height = totalHeight;
+
+  this.positionBorderRect_();
+};
+
+/**
+ * Show the inline free-text editor on top of the text.
+ * Overrides the default behaviour to force rerender in order to
+ * correct block size, based on editor text.
+ * @param {Event=} _opt_e Optional mouse event that triggered the field to open,
+ *     or undefined if triggered programmatically.
+ * @param {boolean=} opt_quietInput True if editor should be created without
+ *     focus.  Defaults to false.
+ * @override
+ */
+Blockly.FieldMultilineInput.prototype.showEditor_ = function(_opt_e, opt_quietInput) {
+  Blockly.FieldMultilineInput.superClass_.showEditor_.call(this, _opt_e, opt_quietInput);
+  this.forceRerender();
+};
+
+/**
+ * Create the text input editor widget.
+ * @return {!HTMLTextAreaElement} The newly created text input editor.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.widgetCreate_ = function() {
+  var div = Blockly.WidgetDiv.DIV;
+  var scale = this.workspace_.getScale();
+
+  var htmlInput =
+    /** @type {HTMLTextAreaElement} */ (document.createElement('textarea'));
+  htmlInput.className = 'blocklyHtmlInput blocklyHtmlTextAreaInput';
+  htmlInput.setAttribute('spellcheck', this.spellcheck_);
+  var fontSize = (this.getConstants().FIELD_TEXT_FONTSIZE * scale) + 'pt';
+  div.style.fontSize = fontSize;
+  htmlInput.style.fontSize = fontSize;
+  var borderRadius = (Blockly.FieldTextInput.BORDERRADIUS * scale) + 'px';
+  htmlInput.style.borderRadius = borderRadius;
+  var paddingX = this.getConstants().FIELD_BORDER_RECT_X_PADDING * scale;
+  var paddingY = this.getConstants().FIELD_BORDER_RECT_Y_PADDING * scale / 2;
+  htmlInput.style.padding = paddingY + 'px ' + paddingX + 'px ' + paddingY +
+      'px ' + paddingX + 'px';
+  var lineHeight = this.getConstants().FIELD_TEXT_HEIGHT +
+      this.getConstants().FIELD_BORDER_RECT_Y_PADDING;
+  htmlInput.style.lineHeight = (lineHeight * scale) + 'px';
+
+  div.appendChild(htmlInput);
+
+  htmlInput.value = htmlInput.defaultValue = this.getEditorText_(this.value_);
+  htmlInput.untypedDefaultValue_ = this.value_;
+  htmlInput.oldValue_ = null;
+  if (Blockly.utils.userAgent.GECKO) {
+    // In FF, ensure the browser reflows before resizing to avoid issue #2777.
+    setTimeout(this.resizeEditor_.bind(this), 0);
+  } else {
+    this.resizeEditor_();
+  }
+
+  this.bindInputEvents_(htmlInput);
+
+  return htmlInput;
+};
+
+/**
+ * Sets the maxLines config for this field.
+ * @param {number} maxLines Defines the maximum number of lines allowed,
+ *     before scrolling functionality is enabled.
+ */
+Blockly.FieldMultilineInput.prototype.setMaxLines = function(maxLines) {
+  if (typeof maxLines === 'number' && maxLines > 0 && maxLines !== this.maxLines_) {
+    this.maxLines_ = maxLines;
+    this.forceRerender();
+  }
+};
+
+/**
+ * Returns the maxLines config of this field.
+ * @return {number} The maxLines config value.
+ */
+Blockly.FieldMultilineInput.prototype.getMaxLines = function() {
+  return this.maxLines_;
+};
+
+/**
+ * Handle key down to the editor. Override the text input definition of this
+ * so as to not close the editor when enter is typed in.
+ * @param {!Event} e Keyboard event.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.onHtmlInputKeyDown_ = function(e) {
+  if (e.keyCode !== Blockly.utils.KeyCodes.ENTER) {
+    Blockly.FieldMultilineInput.superClass_.onHtmlInputKeyDown_.call(this, e);
+  }
+};
+
+/**
+ * CSS for multiline field.  See css.js for use.
+ */
+Blockly.Css.register([
+  /* eslint-disable indent */
+  '.blocklyHtmlTextAreaInput {',
+    'font-family: monospace;',
+    'resize: none;',
+    'overflow: hidden;',
+    'height: 100%;',
+    'text-align: left;',
+  '}',
+  '.blocklyHtmlTextAreaInputOverflowedY {',
+    'overflow-y: scroll;',
+  '}'
+  /* eslint-enable indent */
+]);
+
+
+Blockly.fieldRegistry.register('field_multilinetext', Blockly.FieldMultilineInput);

blockly/core/field_number.js

@@ -0,0 +1,315 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Number input field
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldNumber');
+
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.FieldTextInput');
+goog.require('Blockly.utils.aria');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for an editable number field.
+ * @param {string|number=} opt_value The initial value of the field. Should cast
+ *    to a number. Defaults to 0.
+ * @param {?(string|number)=} opt_min Minimum value.
+ * @param {?(string|number)=} opt_max Maximum value.
+ * @param {?(string|number)=} opt_precision Precision for value.
+ * @param {?Function=} opt_validator A function that is called to validate
+ *    changes to the field's value. Takes in a number & returns a validated
+ *    number, or null to abort the change.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/number#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.FieldTextInput}
+ * @constructor
+ */
+Blockly.FieldNumber = function(opt_value, opt_min, opt_max, opt_precision,
+    opt_validator, opt_config) {
+
+  /**
+   * The minimum value this number field can contain.
+   * @type {number}
+   * @protected
+   */
+  this.min_ = -Infinity;
+
+  /**
+   * The maximum value this number field can contain.
+   * @type {number}
+   * @protected
+   */
+  this.max_ = Infinity;
+
+  /**
+   * The multiple to which this fields value is rounded.
+   * @type {number}
+   * @protected
+   */
+  this.precision_ = 0;
+
+  /**
+   * The number of decimal places to allow, or null to allow any number of
+   * decimal digits.
+   * @type {?number}
+   * @private
+   */
+  this.decimalPlaces_ = null;
+
+  Blockly.FieldNumber.superClass_.constructor.call(
+      this, opt_value, opt_validator, opt_config);
+
+  if (!opt_config) {  // Only do one kind of configuration or the other.
+    this.setConstraints(opt_min, opt_max, opt_precision);
+  }
+};
+Blockly.utils.object.inherits(Blockly.FieldNumber, Blockly.FieldTextInput);
+
+/**
+ * The default value for this field.
+ * @type {*}
+ * @protected
+ */
+Blockly.FieldNumber.prototype.DEFAULT_VALUE = 0;
+
+/**
+ * Construct a FieldNumber from a JSON arg object.
+ * @param {!Object} options A JSON object with options (value, min, max, and
+ *                          precision).
+ * @return {!Blockly.FieldNumber} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldNumber.fromJson = function(options) {
+  return new Blockly.FieldNumber(options['value'],
+      undefined, undefined, undefined, undefined, options);
+};
+
+/**
+ * Serializable fields are saved by the XML renderer, non-serializable fields
+ * are not. Editable fields should also be serializable.
+ * @type {boolean}
+ */
+Blockly.FieldNumber.prototype.SERIALIZABLE = true;
+
+/**
+ * Configure the field based on the given map of options.
+ * @param {!Object} config A map of options to configure the field based on.
+ * @protected
+ * @override
+ */
+Blockly.FieldNumber.prototype.configure_ = function(config) {
+  Blockly.FieldNumber.superClass_.configure_.call(this, config);
+  this.setMinInternal_(config['min']);
+  this.setMaxInternal_(config['max']);
+  this.setPrecisionInternal_(config['precision']);
+};
+
+/**
+ * Set the maximum, minimum and precision constraints on this field.
+ * Any of these properties may be undefined or NaN to be disabled.
+ * Setting precision (usually a power of 10) enforces a minimum step between
+ * values. That is, the user's value will rounded to the closest multiple of
+ * precision. The least significant digit place is inferred from the precision.
+ * Integers values can be enforces by choosing an integer precision.
+ * @param {?(number|string|undefined)} min Minimum value.
+ * @param {?(number|string|undefined)} max Maximum value.
+ * @param {?(number|string|undefined)} precision Precision for value.
+ */
+Blockly.FieldNumber.prototype.setConstraints = function(min, max, precision) {
+  this.setMinInternal_(min);
+  this.setMaxInternal_(max);
+  this.setPrecisionInternal_(precision);
+  this.setValue(this.getValue());
+};
+
+/**
+ * Sets the minimum value this field can contain. Updates the value to reflect.
+ * @param {?(number|string|undefined)} min Minimum value.
+ */
+Blockly.FieldNumber.prototype.setMin = function(min) {
+  this.setMinInternal_(min);
+  this.setValue(this.getValue());
+};
+
+/**
+ * Sets the minimum value this field can contain. Called internally to avoid
+ * value updates.
+ * @param {?(number|string|undefined)} min Minimum value.
+ * @private
+ */
+Blockly.FieldNumber.prototype.setMinInternal_ = function(min) {
+  if (min == null) {
+    this.min_ = -Infinity;
+  } else {
+    min = Number(min);
+    if (!isNaN(min)) {
+      this.min_ = min;
+    }
+  }
+};
+
+/**
+ * Returns the current minimum value this field can contain. Default is
+ * -Infinity.
+ * @return {number} The current minimum value this field can contain.
+ */
+Blockly.FieldNumber.prototype.getMin = function() {
+  return this.min_;
+};
+
+/**
+ * Sets the maximum value this field can contain. Updates the value to reflect.
+ * @param {?(number|string|undefined)} max Maximum value.
+ */
+Blockly.FieldNumber.prototype.setMax = function(max) {
+  this.setMaxInternal_(max);
+  this.setValue(this.getValue());
+};
+
+/**
+ * Sets the maximum value this field can contain. Called internally to avoid
+ * value updates.
+ * @param {?(number|string|undefined)} max Maximum value.
+ * @private
+ */
+Blockly.FieldNumber.prototype.setMaxInternal_ = function(max) {
+  if (max == null) {
+    this.max_ = Infinity;
+  } else {
+    max = Number(max);
+    if (!isNaN(max)) {
+      this.max_ = max;
+    }
+  }
+};
+
+/**
+ * Returns the current maximum value this field can contain. Default is
+ * Infinity.
+ * @return {number} The current maximum value this field can contain.
+ */
+Blockly.FieldNumber.prototype.getMax = function() {
+  return this.max_;
+};
+
+/**
+ * Sets the precision of this field's value, i.e. the number to which the
+ * value is rounded. Updates the field to reflect.
+ * @param {?(number|string|undefined)} precision The number to which the
+ *    field's value is rounded.
+ */
+Blockly.FieldNumber.prototype.setPrecision = function(precision) {
+  this.setPrecisionInternal_(precision);
+  this.setValue(this.getValue());
+};
+
+/**
+ * Sets the precision of this field's value. Called internally to avoid
+ * value updates.
+ * @param {?(number|string|undefined)} precision The number to which the
+ *    field's value is rounded.
+ * @private
+ */
+Blockly.FieldNumber.prototype.setPrecisionInternal_ = function(precision) {
+  this.precision_ = Number(precision) || 0;
+  var precisionString = String(this.precision_);
+  if (precisionString.indexOf('e') != -1) {
+    // String() is fast.  But it turns .0000001 into '1e-7'.
+    // Use the much slower toLocaleString to access all the digits.
+    precisionString =
+        this.precision_.toLocaleString('en-US', {maximumFractionDigits: 20});
+  }
+  var decimalIndex = precisionString.indexOf('.');
+  if (decimalIndex == -1) {
+    // If the precision is 0 (float) allow any number of decimals,
+    // otherwise allow none.
+    this.decimalPlaces_ = precision ? 0 : null;
+  } else {
+    this.decimalPlaces_ = precisionString.length - decimalIndex - 1;
+  }
+};
+
+/**
+ * Returns the current precision of this field. The precision being the
+ * number to which the field's value is rounded. A precision of 0 means that
+ * the value is not rounded.
+ * @return {number} The number to which this field's value is rounded.
+ */
+Blockly.FieldNumber.prototype.getPrecision = function() {
+  return this.precision_;
+};
+
+/**
+ * Ensure that the input value is a valid number (must fulfill the
+ * constraints placed on the field).
+ * @param {*=} opt_newValue The input value.
+ * @return {?number} A valid number, or null if invalid.
+ * @protected
+ * @override
+ */
+Blockly.FieldNumber.prototype.doClassValidation_ = function(opt_newValue) {
+  if (opt_newValue === null) {
+    return null;
+  }
+  // Clean up text.
+  var newValue = String(opt_newValue);
+  // TODO: Handle cases like 'ten', '1.203,14', etc.
+  // 'O' is sometimes mistaken for '0' by inexperienced users.
+  newValue = newValue.replace(/O/ig, '0');
+  // Strip out thousands separators.
+  newValue = newValue.replace(/,/g, '');
+  // Ignore case of 'Infinity'.
+  newValue = newValue.replace(/infinity/i, 'Infinity');
+
+  // Clean up number.
+  var n = Number(newValue || 0);
+  if (isNaN(n)) {
+    // Invalid number.
+    return null;
+  }
+  // Get the value in range.
+  n = Math.min(Math.max(n, this.min_), this.max_);
+  // Round to nearest multiple of precision.
+  if (this.precision_ && isFinite(n)) {
+    n = Math.round(n / this.precision_) * this.precision_;
+  }
+  // Clean up floating point errors.
+  if (this.decimalPlaces_ != null) {
+    n = Number(n.toFixed(this.decimalPlaces_));
+  }
+  return n;
+};
+
+/**
+ * Create the number input editor widget.
+ * @return {!HTMLElement} The newly created number input editor.
+ * @protected
+ * @override
+ */
+Blockly.FieldNumber.prototype.widgetCreate_ = function() {
+  var htmlInput = Blockly.FieldNumber.superClass_.widgetCreate_.call(this);
+
+  // Set the accessibility state
+  if (this.min_ > -Infinity) {
+    Blockly.utils.aria.setState(htmlInput,
+        Blockly.utils.aria.State.VALUEMIN, this.min_);
+  }
+  if (this.max_ < Infinity) {
+    Blockly.utils.aria.setState(htmlInput,
+        Blockly.utils.aria.State.VALUEMAX, this.max_);
+  }
+  return htmlInput;
+};
+
+Blockly.fieldRegistry.register('field_number', Blockly.FieldNumber);

blockly/core/field_registry.js

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Fields can be created based on a JSON definition. This file
+ *    contains methods for registering those JSON definitions, and building the
+ *    fields based on JSON.
+ * @author bekawestberg@gmail.com (Beka Westberg)
+ */
+'use strict';
+
+goog.provide('Blockly.fieldRegistry');
+
+goog.require('Blockly.registry');
+
+goog.requireType('Blockly.Field');
+goog.requireType('Blockly.IRegistrableField');
+
+
+/**
+ * Registers a field type.
+ * Blockly.fieldRegistry.fromJson uses this registry to
+ * find the appropriate field type.
+ * @param {string} type The field type name as used in the JSON definition.
+ * @param {!Blockly.IRegistrableField} fieldClass The field class containing a
+ *     fromJson function that can construct an instance of the field.
+ * @throws {Error} if the type name is empty, the field is already
+ *     registered, or the fieldClass is not an object containing a fromJson
+ *     function.
+ */
+Blockly.fieldRegistry.register = function(type, fieldClass) {
+  Blockly.registry.register(Blockly.registry.Type.FIELD, type, fieldClass);
+};
+
+/**
+ * Unregisters the field registered with the given type.
+ * @param {string} type The field type name as used in the JSON definition.
+ */
+Blockly.fieldRegistry.unregister = function(type) {
+  Blockly.registry.unregister(Blockly.registry.Type.FIELD, type);
+};
+
+/**
+ * Construct a Field from a JSON arg object.
+ * Finds the appropriate registered field by the type name as registered using
+ * Blockly.fieldRegistry.register.
+ * @param {!Object} options A JSON object with a type and options specific
+ *     to the field type.
+ * @return {?Blockly.Field} The new field instance or null if a field wasn't
+ *     found with the given type name
+ * @package
+ */
+Blockly.fieldRegistry.fromJson = function(options) {
+  var fieldObject = /** @type {?Blockly.IRegistrableField} */ (
+    Blockly.registry.getObject(Blockly.registry.Type.FIELD, options['type']));
+  if (!fieldObject) {
+    console.warn('Blockly could not create a field of type ' + options['type'] +
+      '. The field is probably not being registered. This could be because' +
+      ' the file is not loaded, the field does not register itself (Issue' +
+      ' #1584), or the registration is not being reached.');
+    return null;
+  }
+  return fieldObject.fromJson(options);
+};