diff --git a/core/connection.js b/core/connection.js
index 27526c711..553938825 100644
--- a/core/connection.js
+++ b/core/connection.js
@@ -10,33 +10,33 @@
  */
 'use strict';
 
-goog.provide('Blockly.Connection');
+goog.module('Blockly.Connection');
+goog.module.declareLegacyNamespace();
 
-goog.require('Blockly.connectionTypes');
+const connectionTypes = goog.require('Blockly.connectionTypes');
+const Block = goog.requireType('Blockly.Block');
+const deprecation = goog.require('Blockly.utils.deprecation');
+const Events = goog.require('Blockly.Events');
+const IASTNodeLocationWithBlock = goog.require('Blockly.IASTNodeLocationWithBlock');
+const IConnectionChecker = goog.requireType('Blockly.IConnectionChecker');
+const Input = goog.requireType('Blockly.Input');
+const Xml = goog.require('Blockly.Xml');
 /** @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 {!Block} source The block establishing this connection.
  * @param {number} type The type of the connection.
  * @constructor
- * @implements {Blockly.IASTNodeLocationWithBlock}
+ * @implements {IASTNodeLocationWithBlock}
  */
-Blockly.Connection = function(source, type) {
+const Connection = function(source, type) {
   /**
-   * @type {!Blockly.Block}
+   * @type {!Block}
    * @protected
    */
   this.sourceBlock_ = source;
@@ -47,67 +47,67 @@ Blockly.Connection = function(source, 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.CAN_CONNECT = 0;
+Connection.REASON_SELF_CONNECTION = 1;
+Connection.REASON_WRONG_TYPE = 2;
+Connection.REASON_TARGET_NULL = 3;
+Connection.REASON_CHECKS_FAILED = 4;
+Connection.REASON_DIFFERENT_WORKSPACES = 5;
+Connection.REASON_SHADOW_PARENT = 6;
+Connection.REASON_DRAG_CHECKS_FAILED = 7;
 
 /**
  * Connection this connection connects to.  Null if not connected.
- * @type {Blockly.Connection}
+ * @type {Connection}
  */
-Blockly.Connection.prototype.targetConnection = null;
+Connection.prototype.targetConnection = null;
 
 /**
  * Has this connection been disposed of?
  * @type {boolean}
  * @package
  */
-Blockly.Connection.prototype.disposed = false;
+Connection.prototype.disposed = false;
 
 /**
  * List of compatible value types.  Null if all types are compatible.
  * @type {Array}
  * @private
  */
-Blockly.Connection.prototype.check_ = null;
+Connection.prototype.check_ = null;
 
 /**
  * DOM representation of a shadow block, or null if none.
  * @type {Element}
  * @private
  */
-Blockly.Connection.prototype.shadowDom_ = null;
+Connection.prototype.shadowDom_ = null;
 
 /**
  * Horizontal location of this connection.
  * @type {number}
  * @package
  */
-Blockly.Connection.prototype.x = 0;
+Connection.prototype.x = 0;
 
 /**
  * Vertical location of this connection.
  * @type {number}
  * @package
  */
-Blockly.Connection.prototype.y = 0;
+Connection.prototype.y = 0;
 
 /**
  * Connect two connections together.  This is the connection on the superior
  * block.
- * @param {!Blockly.Connection} childConnection Connection on inferior block.
+ * @param {!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();
+Connection.prototype.connect_ = function(childConnection) {
+  const INPUT = connectionTypes.INPUT_VALUE;
+  const parentConnection = this;
+  const parentBlock = parentConnection.getSourceBlock();
+  const childBlock = childConnection.getSourceBlock();
 
   // Make sure the childConnection is available.
   if (childConnection.isConnected()) {
@@ -115,11 +115,11 @@ Blockly.Connection.prototype.connect_ = function(childConnection) {
   }
 
   // Make sure the parentConnection is available.
-  var orphan;
+  let orphan;
   if (parentConnection.isConnected()) {
-    var shadowDom = parentConnection.getShadowDom(true);
+    const shadowDom = parentConnection.getShadowDom(true);
     parentConnection.shadowDom_ = null;  // Set to null so it doesn't respawn.
-    var target = parentConnection.targetBlock();
+    const target = parentConnection.targetBlock();
     if (target.isShadow()) {
       target.dispose(false);
     } else {
@@ -130,23 +130,24 @@ Blockly.Connection.prototype.connect_ = function(childConnection) {
   }
 
   // Connect the new connection to the parent.
-  var event;
-  if (Blockly.Events.isEnabled()) {
-    event = new (Blockly.Events.get(Blockly.Events.BLOCK_MOVE))(childBlock);
+  let event;
+  if (Events.isEnabled()) {
+    event = new (Events.get(Events.BLOCK_MOVE))(childBlock);
   }
-  Blockly.Connection.connectReciprocally_(parentConnection, childConnection);
+  connectReciprocally(parentConnection, childConnection);
   childBlock.setParent(parentBlock);
   if (event) {
     event.recordNew();
-    Blockly.Events.fire(event);
+    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));
+    const orphanConnection = parentConnection.type === INPUT ?
+        orphan.outputConnection :
+        orphan.previousConnection;
+    const connection = Connection.getConnectionForOrphanedConnection(
+        childBlock, /** @type {!Connection} */ (orphanConnection));
     if (connection) {
       orphanConnection.connect(connection);
     } else {
@@ -160,14 +161,13 @@ Blockly.Connection.prototype.connect_ = function(childConnection) {
  * Dispose of this connection and deal with connected blocks.
  * @package
  */
-Blockly.Connection.prototype.dispose = function() {
-
+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();
+    const targetBlock = this.targetBlock();
     if (targetBlock) {
       // Disconnect the attached normal block.
       targetBlock.unplug();
@@ -179,9 +179,9 @@ Blockly.Connection.prototype.dispose = function() {
 
 /**
  * Get the source block for this connection.
- * @return {!Blockly.Block} The source block.
+ * @return {!Block} The source block.
  */
-Blockly.Connection.prototype.getSourceBlock = function() {
+Connection.prototype.getSourceBlock = function() {
   return this.sourceBlock_;
 };
 
@@ -189,82 +189,75 @@ Blockly.Connection.prototype.getSourceBlock = function() {
  * 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;
+Connection.prototype.isSuperior = function() {
+  return this.type == connectionTypes.INPUT_VALUE ||
+      this.type == connectionTypes.NEXT_STATEMENT;
 };
 
 /**
  * Is the connection connected?
  * @return {boolean} True if connection is connected to another connection.
  */
-Blockly.Connection.prototype.isConnected = function() {
+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,
+ * @param {Connection} target Connection to check compatibility with.
+ * @return {number} 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',
+Connection.prototype.canConnectWithReason = function(target) {
+  deprecation.warn(
+      'Connection.prototype.canConnectWithReason', 'July 2020', 'July 2021',
       'the workspace\'s connection checker');
-  return this.getConnectionChecker().canConnectWithReason(
-      this, target, false);
+  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
+ * @param {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',
+Connection.prototype.checkConnection = function(target) {
+  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) {
+  const checker = this.getConnectionChecker();
+  const reason = checker.canConnectWithReason(this, target, false);
+  if (reason != 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
+ * @return {!IConnectionChecker} The connection type checker for the
  *     source block's workspace.
  * @package
  */
-Blockly.Connection.prototype.getConnectionChecker = function() {
+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.
+ * @param {!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',
+Connection.prototype.isConnectionAllowed = function(candidate) {
+  deprecation.warn(
+      'Connection.prototype.isConnectionAllowed', 'July 2020', 'July 2021',
       'the workspace\'s connection checker');
   return this.getConnectionChecker().canConnect(this, candidate, true);
 };
@@ -272,29 +265,29 @@ Blockly.Connection.prototype.isConnectionAllowed = function(candidate) {
 /**
  * Called when an attempted connection fails. NOP by default (i.e. for headless
  * workspaces).
- * @param {!Blockly.Connection} _otherConnection Connection that this connection
+ * @param {!Connection} _otherConnection Connection that this connection
  *     failed to connect to.
  * @package
  */
-Blockly.Connection.prototype.onFailedConnect = function(_otherConnection) {
+Connection.prototype.onFailedConnect = function(_otherConnection) {
   // NOP
 };
 
 /**
  * Connect this connection to another connection.
- * @param {!Blockly.Connection} otherConnection Connection to connect to.
+ * @param {!Connection} otherConnection Connection to connect to.
  */
-Blockly.Connection.prototype.connect = function(otherConnection) {
+Connection.prototype.connect = function(otherConnection) {
   if (this.targetConnection == otherConnection) {
     // Already connected together.  NOP.
     return;
   }
 
-  var checker = this.getConnectionChecker();
+  const checker = this.getConnectionChecker();
   if (checker.canConnect(this, otherConnection, false)) {
-    var eventGroup = Blockly.Events.getGroup();
+    const eventGroup = Events.getGroup();
     if (!eventGroup) {
-      Blockly.Events.setGroup(true);
+      Events.setGroup(true);
     }
     // Determine which block is superior (higher in the source stack).
     if (this.isSuperior()) {
@@ -305,18 +298,17 @@ Blockly.Connection.prototype.connect = function(otherConnection) {
       otherConnection.connect_(this);
     }
     if (!eventGroup) {
-      Blockly.Events.setGroup(false);
+      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
+ * @param {Connection} first The first connection to update.
+ * @param {Connection} second The second connection to update.
  */
-Blockly.Connection.connectReciprocally_ = function(first, second) {
+const connectReciprocally = function(first, second) {
   if (!first || !second) {
     throw Error('Cannot connect null connections.');
   }
@@ -329,19 +321,18 @@ Blockly.Connection.connectReciprocally_ = function(first, second) {
  * 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',
+ * @param {!Block} block The superior block.
+ * @param {!Block} orphanBlock The inferior block.
+ * @return {?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();
+const getSingleConnection = function(block, orphanBlock) {
+  let foundConnection = null;
+  const output = orphanBlock.outputConnection;
+  const typeChecker = output.getConnectionChecker();
 
-  for (var i = 0, input; (input = block.inputList[i]); i++) {
-    var connection = input.connection;
+  for (let i = 0, input; (input = block.inputList[i]); i++) {
+    const connection = input.connection;
     if (connection && typeChecker.canConnect(output, connection, false)) {
       if (foundConnection) {
         return null;  // More than one connection.
@@ -358,64 +349,62 @@ Blockly.Connection.getSingleConnection_ = function(block, orphanBlock) {
  * 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
+ * @param {!Block} startBlock The block on which to start the search.
+ * @param {!Block} orphanBlock The block that is looking for a home.
+ * @return {?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;
-    };
+const getConnectionForOrphanedOutput = function(startBlock, orphanBlock) {
+  let newBlock = startBlock;
+  let connection;
+  while (
+      (connection = getSingleConnection(
+           /** @type {!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
+ * @param {!Block} startBlock The block on which to start the search.
+ * @param {!Connection} orphanConnection The connection that is looking
  *     for a home.
- * @return {?Blockly.Connection} The suitable connection point on the chain of
+ * @return {?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;
-    };
+Connection.getConnectionForOrphanedConnection = function(
+    startBlock, orphanConnection) {
+  if (orphanConnection.type === connectionTypes.OUTPUT_VALUE) {
+    return getConnectionForOrphanedOutput(
+        startBlock, orphanConnection.getSourceBlock());
+  }
+  // Otherwise we're dealing with a stack.
+  const connection = startBlock.lastConnectionInStack(true);
+  const 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;
+Connection.prototype.disconnect = function() {
+  const 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;
+  let parentBlock, childBlock, parentConnection;
   if (this.isSuperior()) {
     // Superior block.
     parentBlock = this.sourceBlock_;
@@ -428,9 +417,9 @@ Blockly.Connection.prototype.disconnect = function() {
     parentConnection = otherConnection;
   }
 
-  var eventGroup = Blockly.Events.getGroup();
+  const eventGroup = Events.getGroup();
   if (!eventGroup) {
-    Blockly.Events.setGroup(true);
+    Events.setGroup(true);
   }
   this.disconnectInternal_(parentBlock, childBlock);
   if (!childBlock.isShadow()) {
@@ -438,29 +427,28 @@ Blockly.Connection.prototype.disconnect = function() {
     parentConnection.respawnShadow_();
   }
   if (!eventGroup) {
-    Blockly.Events.setGroup(false);
+    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.
+ * @param {!Block} parentBlock The superior block.
+ * @param {!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);
+Connection.prototype.disconnectInternal_ = function(parentBlock, childBlock) {
+  let event;
+  if (Events.isEnabled()) {
+    event = new (Events.get(Events.BLOCK_MOVE))(childBlock);
   }
-  var otherConnection = this.targetConnection;
+  const otherConnection = this.targetConnection;
   otherConnection.targetConnection = null;
   this.targetConnection = null;
   childBlock.setParent(null);
   if (event) {
     event.recordNew();
-    Blockly.Events.fire(event);
+    Events.fire(event);
   }
 };
 
@@ -468,11 +456,11 @@ Blockly.Connection.prototype.disconnectInternal_ = function(parentBlock,
  * 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();
+Connection.prototype.respawnShadow_ = function() {
+  const parentBlock = this.getSourceBlock();
+  const shadow = this.getShadowDom();
   if (parentBlock.workspace && shadow) {
-    var blockShadow = Blockly.Xml.domToBlock(shadow, parentBlock.workspace);
+    const blockShadow = Xml.domToBlock(shadow, parentBlock.workspace);
     if (blockShadow.outputConnection) {
       this.connect(blockShadow.outputConnection);
     } else if (blockShadow.previousConnection) {
@@ -485,9 +473,9 @@ Blockly.Connection.prototype.respawnShadow_ = function() {
 
 /**
  * Returns the block that this connection connects to.
- * @return {?Blockly.Block} The connected block or null if none is connected.
+ * @return {?Block} The connected block or null if none is connected.
  */
-Blockly.Connection.prototype.targetBlock = function() {
+Connection.prototype.targetBlock = function() {
   if (this.isConnected()) {
     return this.targetConnection.getSourceBlock();
   }
@@ -497,36 +485,31 @@ Blockly.Connection.prototype.targetBlock = function() {
 /**
  * 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.
+ * @param {!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',
+Connection.prototype.checkType = function(otherConnection) {
+  deprecation.warn(
+      'Connection.prototype.checkType', 'October 2019', 'January 2021',
       'the workspace\'s connection checker');
-  return this.getConnectionChecker().canConnect(this, otherConnection,
-      false);
+  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.
+ * @param {!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',
+Connection.prototype.checkType_ = function(otherConnection) {
+  deprecation.warn(
+      'Connection.prototype.checkType_', 'October 2019', 'January 2021',
       'the workspace\'s connection checker');
   return this.checkType(otherConnection);
 };
@@ -535,12 +518,13 @@ Blockly.Connection.prototype.checkType_ = function(otherConnection) {
  * Function to be called when this connection's compatible types have changed.
  * @protected
  */
-Blockly.Connection.prototype.onCheckChanged_ = function() {
+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_;
+  if (this.isConnected() &&
+      (!this.targetConnection ||
+       !this.getConnectionChecker().canConnect(
+           this, this.targetConnection, false))) {
+    const child = this.isSuperior() ? this.targetBlock() : this.sourceBlock_;
     child.unplug();
   }
 };
@@ -549,10 +533,10 @@ Blockly.Connection.prototype.onCheckChanged_ = function() {
  * 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
+ * @return {!Connection} The connection being modified
  *     (to allow chaining).
  */
-Blockly.Connection.prototype.setCheck = function(check) {
+Connection.prototype.setCheck = function(check) {
   if (check) {
     // Ensure that check is in an array.
     if (!Array.isArray(check)) {
@@ -572,7 +556,7 @@ Blockly.Connection.prototype.setCheck = function(check) {
  *     Null if all types are compatible.
  * @public
  */
-Blockly.Connection.prototype.getCheck = function() {
+Connection.prototype.getCheck = function() {
   return this.check_;
 };
 
@@ -580,9 +564,9 @@ Blockly.Connection.prototype.getCheck = function() {
  * Changes the connection's shadow block.
  * @param {?Element} shadow DOM representation of a block or null.
  */
-Blockly.Connection.prototype.setShadowDom = function(shadow) {
+Connection.prototype.setShadowDom = function(shadow) {
   this.shadowDom_ = shadow;
-  var target = this.targetBlock();
+  const target = this.targetBlock();
   if (!target) {
     this.respawnShadow_();
   } else if (target.isShadow()) {
@@ -600,10 +584,10 @@ Blockly.Connection.prototype.setShadowDom = function(shadow) {
  *     shadowDom is just returned.
  * @return {?Element} Shadow DOM representation of a block or null.
  */
-Blockly.Connection.prototype.getShadowDom = function(returnCurrent) {
+Connection.prototype.getShadowDom = function(returnCurrent) {
   return (returnCurrent && this.targetBlock().isShadow()) ?
-      /** @type {!Element} */ (Blockly.Xml.blockToDom(
-          /** @type {!Blockly.Block} */ (this.targetBlock()))) :
+      /** @type {!Element} */ (Xml.blockToDom(
+          /** @type {!Block} */ (this.targetBlock()))) :
       this.shadowDom_;
 };
 
@@ -616,23 +600,23 @@ Blockly.Connection.prototype.getShadowDom = function(returnCurrent) {
  * {@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.
+ * @return {!Array<!Connection>} List of connections.
  * @package
  */
-Blockly.Connection.prototype.neighbours = function(_maxLimit) {
+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
+ * @return {?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++) {
+Connection.prototype.getParentInput = function() {
+  let parentInput = null;
+  const inputs = this.sourceBlock_.inputList;
+  for (let i = 0; i < inputs.length; i++) {
     if (inputs[i].connection === this) {
       parentInput = inputs[i];
       break;
@@ -646,12 +630,12 @@ Blockly.Connection.prototype.getParentInput = function() {
  * (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_;
+Connection.prototype.toString = function() {
+  const block = this.sourceBlock_;
   if (!block) {
     return 'Orphan Connection';
   }
-  var msg;
+  let msg;
   if (block.outputConnection == this) {
     msg = 'Output Connection of ';
   } else if (block.previousConnection == this) {
@@ -659,8 +643,8 @@ Blockly.Connection.prototype.toString = function() {
   } else if (block.nextConnection == this) {
     msg = 'Next Connection of ';
   } else {
-    var parentInput = null;
-    for (var i = 0, input; (input = block.inputList[i]); i++) {
+    let parentInput = null;
+    for (let i = 0, input; (input = block.inputList[i]); i++) {
       if (input.connection == this) {
         parentInput = input;
         break;
@@ -675,3 +659,5 @@ Blockly.Connection.prototype.toString = function() {
   }
   return msg + block.toDevString();
 };
+
+exports = Connection;
diff --git a/tests/deps.js b/tests/deps.js
index 6128287ca..9c9e44102 100644
--- a/tests/deps.js
+++ b/tests/deps.js
@@ -19,7 +19,7 @@ goog.addDependency('../../core/bubble.js', ['Blockly.Bubble'], ['Blockly.IBubble
 goog.addDependency('../../core/bubble_dragger.js', ['Blockly.BubbleDragger'], ['Blockly.Bubble', 'Blockly.ComponentManager', 'Blockly.Events', 'Blockly.Events.CommentMove', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.Coordinate'], {'lang': 'es6', 'module': 'goog'});
 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'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/component_manager.js', ['Blockly.ComponentManager'], [], {'lang': 'es6', 'module': 'goog'});
-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.js', ['Blockly.Connection'], ['Blockly.Events', 'Blockly.Events.BlockMove', 'Blockly.IASTNodeLocationWithBlock', 'Blockly.Xml', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.deprecation'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/connection_checker.js', ['Blockly.ConnectionChecker'], ['Blockly.Connection', 'Blockly.IConnectionChecker', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.registry'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/connection_db.js', ['Blockly.ConnectionDB'], ['Blockly.RenderedConnection', 'Blockly.connectionTypes', 'Blockly.constants'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/connection_types.js', ['Blockly.connectionTypes'], [], {'lang': 'es6', 'module': 'goog'});