diff --git a/core/block_dragger.js b/core/block_dragger.js
index a1d4b6f2d..b7c11e8a3 100644
--- a/core/block_dragger.js
+++ b/core/block_dragger.js
@@ -10,61 +10,63 @@
  */
 'use strict';
 
-goog.provide('Blockly.BlockDragger');
+goog.module('Blockly.BlockDragger');
+goog.module.declareLegacyNamespace();
 
-goog.require('Blockly.blockAnimations');
-/** @suppress {extraRequire} */
-goog.require('Blockly.constants');
-goog.require('Blockly.Events');
+/* eslint-disable-next-line no-unused-vars */
+const BlockSvg = goog.requireType('Blockly.BlockSvg');
+const Coordinate = goog.require('Blockly.utils.Coordinate');
+/* eslint-disable-next-line no-unused-vars */
+const IBlockDragger = goog.require('Blockly.IBlockDragger');
+/* eslint-disable-next-line no-unused-vars */
+const IDragTarget = goog.requireType('Blockly.IDragTarget');
+const InsertionMarkerManager = goog.require('Blockly.InsertionMarkerManager');
+/* eslint-disable-next-line no-unused-vars */
+const WorkspaceSvg = goog.requireType('Blockly.WorkspaceSvg');
+const blockAnimation = goog.require('Blockly.blockAnimations');
+const dom = goog.require('Blockly.utils.dom');
+const events = goog.require('Blockly.Events');
+const registry = goog.require('Blockly.registry');
 /** @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.
+ * @param {!BlockSvg} block The block to drag.
+ * @param {!WorkspaceSvg} workspace The workspace to drag on.
  * @constructor
- * @implements {Blockly.IBlockDragger}
+ * @implements {IBlockDragger}
  */
-Blockly.BlockDragger = function(block, workspace) {
+const BlockDragger = function(block, workspace) {
   /**
    * The top block in the stack that is being dragged.
-   * @type {!Blockly.BlockSvg}
+   * @type {!BlockSvg}
    * @protected
    */
   this.draggingBlock_ = block;
 
   /**
    * The workspace on which the block is being dragged.
-   * @type {!Blockly.WorkspaceSvg}
+   * @type {!WorkspaceSvg}
    * @protected
    */
   this.workspace_ = workspace;
 
   /**
    * Object that keeps track of connections on dragged blocks.
-   * @type {!Blockly.InsertionMarkerManager}
+   * @type {!InsertionMarkerManager}
    * @protected
    */
   this.draggedConnectionManager_ =
-      new Blockly.InsertionMarkerManager(this.draggingBlock_);
+      new InsertionMarkerManager(this.draggingBlock_);
 
   /**
    * Which drag area the mouse pointer is over, if any.
-   * @type {?Blockly.IDragTarget}
+   * @type {?IDragTarget}
    * @private
    */
   this.dragTarget_ = null;
@@ -79,7 +81,7 @@ Blockly.BlockDragger = function(block, workspace) {
   /**
    * The location of the top left corner of the dragging block at the beginning
    * of the drag in workspace coordinates.
-   * @type {!Blockly.utils.Coordinate}
+   * @type {!Coordinate}
    * @protected
    */
   this.startXY_ = this.draggingBlock_.getRelativeToSurfaceXY();
@@ -91,14 +93,14 @@ Blockly.BlockDragger = function(block, workspace) {
    * @type {Array<!Object>}
    * @protected
    */
-  this.dragIconData_ = Blockly.BlockDragger.initIconData_(block);
+  this.dragIconData_ = initIconData(block);
 };
 
 /**
  * Sever all links from this object.
  * @package
  */
-Blockly.BlockDragger.prototype.dispose = function() {
+BlockDragger.prototype.dispose = function() {
   this.dragIconData_.length = 0;
 
   if (this.draggedConnectionManager_) {
@@ -110,19 +112,19 @@ Blockly.BlockDragger.prototype.dispose = function() {
  * 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.
+ * @param {!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) {
+const 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
+  const dragIconData = [];
+  const descendants = block.getDescendants(false);
+
+  for (let i = 0, descendant; (descendant = descendants[i]); i++) {
+    const icons = descendant.getIcons();
+    for (let j = 0; j < icons.length; j++) {
+      const data = {
+        // Coordinate with x and y properties (workspace
         // coordinates).
         location: icons[j].getIconLocation(),
         // Blockly.Icon
@@ -136,16 +138,15 @@ Blockly.BlockDragger.initIconData_ = function(block) {
 
 /**
  * Start dragging a block.  This includes moving it to the drag surface.
- * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ * @param {!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);
+BlockDragger.prototype.startDrag = function(currentDragDeltaXY, healStack) {
+  if (!events.getGroup()) {
+    events.setGroup(true);
   }
   this.fireDragStartEvent_();
 
@@ -159,9 +160,9 @@ Blockly.BlockDragger.prototype.startDrag = function(
 
   // 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();
+  dom.startTextWidthCache();
   this.workspace_.setResizesEnabled(false);
-  Blockly.blockAnimations.disconnectUiStop();
+  blockAnimation.disconnectUiStop();
 
   if (this.shouldDisconnect_(healStack)) {
     this.disconnectBlock_(healStack, currentDragDeltaXY);
@@ -180,9 +181,9 @@ Blockly.BlockDragger.prototype.startDrag = function(
  * @return {boolean} True to disconnect the block, false otherwise.
  * @protected
  */
-Blockly.BlockDragger.prototype.shouldDisconnect_ = function(healStack) {
+BlockDragger.prototype.shouldDisconnect_ = function(healStack) {
   return !!(
-    this.draggingBlock_.getParent() ||
+      this.draggingBlock_.getParent() ||
       (healStack && this.draggingBlock_.nextConnection &&
        this.draggingBlock_.nextConnection.targetBlock()));
 };
@@ -191,18 +192,18 @@ Blockly.BlockDragger.prototype.shouldDisconnect_ = function(healStack) {
  * 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
+ * @param {!Coordinate} currentDragDeltaXY How far the pointer has
  *     moved from the position at mouse down, in pixel units.
  * @protected
  */
-Blockly.BlockDragger.prototype.disconnectBlock_ = function(
+BlockDragger.prototype.disconnectBlock_ = function(
     healStack, currentDragDeltaXY) {
   this.draggingBlock_.unplug(healStack);
-  var delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
-  var newLoc = Blockly.utils.Coordinate.sum(this.startXY_, delta);
+  const delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+  const newLoc = Coordinate.sum(this.startXY_, delta);
 
   this.draggingBlock_.translate(newLoc.x, newLoc.y);
-  Blockly.blockAnimations.disconnectUiEffect(this.draggingBlock_);
+  blockAnimation.disconnectUiEffect(this.draggingBlock_);
   this.draggedConnectionManager_.updateAvailableConnections();
 };
 
@@ -210,31 +211,31 @@ Blockly.BlockDragger.prototype.disconnectBlock_ = function(
  * 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))(
+BlockDragger.prototype.fireDragStartEvent_ = function() {
+  const event = new (events.get(events.BLOCK_DRAG))(
       this.draggingBlock_, true, this.draggingBlock_.getDescendants(false));
-  Blockly.Events.fire(event);
+  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
+ * @param {!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);
+BlockDragger.prototype.drag = function(e, currentDragDeltaXY) {
+  const delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+  const newLoc = Coordinate.sum(this.startXY_, delta);
   this.draggingBlock_.moveDuringDrag(newLoc);
   this.dragIcons_(delta);
 
-  var oldDragTarget = this.dragTarget_;
+  const oldDragTarget = this.dragTarget_;
   this.dragTarget_ = this.workspace_.getDragTarget(e);
 
   this.draggedConnectionManager_.update(delta, this.dragTarget_);
-  var oldWouldDeleteBlock = this.wouldDeleteBlock_;
+  const oldWouldDeleteBlock = this.wouldDeleteBlock_;
   this.wouldDeleteBlock_ = this.draggedConnectionManager_.wouldDeleteBlock();
   if (oldWouldDeleteBlock != this.wouldDeleteBlock_) {
     // Prevent unnecessary add/remove class calls.
@@ -253,26 +254,26 @@ Blockly.BlockDragger.prototype.drag = function(e, currentDragDeltaXY) {
 /**
  * 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
+ * @param {!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) {
+BlockDragger.prototype.endDrag = function(e, currentDragDeltaXY) {
   // Make sure internal state is fresh.
   this.drag(e, currentDragDeltaXY);
   this.dragIconData_ = [];
   this.fireDragEndEvent_();
 
-  Blockly.utils.dom.stopTextWidthCache();
+  dom.stopTextWidthCache();
 
-  Blockly.blockAnimations.disconnectUiStop();
+  blockAnimation.disconnectUiStop();
 
-  var preventMove = !!this.dragTarget_ &&
+  const preventMove = !!this.dragTarget_ &&
       this.dragTarget_.shouldPreventMove(this.draggingBlock_);
   if (preventMove) {
     var newLoc = this.startXY_;
   } else {
-    var newValues = this.getNewLocationAfterDrag_(currentDragDeltaXY);
+    const newValues = this.getNewLocationAfterDrag_(currentDragDeltaXY);
     var delta = newValues.delta;
     var newLoc = newValues.newLocation;
   }
@@ -282,7 +283,7 @@ Blockly.BlockDragger.prototype.endDrag = function(e, currentDragDeltaXY) {
     this.dragTarget_.onDrop(this.draggingBlock_);
   }
 
-  var deleted = this.maybeDeleteBlock_();
+  const deleted = this.maybeDeleteBlock_();
   if (!deleted) {
     // These are expensive and don't need to be done if we're deleting.
     this.draggingBlock_.setDragging(false);
@@ -299,25 +300,23 @@ Blockly.BlockDragger.prototype.endDrag = function(e, currentDragDeltaXY) {
   }
   this.workspace_.setResizesEnabled(true);
 
-  Blockly.Events.setGroup(false);
+  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
+ * @param {!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
+ * @return {{delta: !Coordinate, newLocation:
+ *     !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 = {};
+BlockDragger.prototype.getNewLocationAfterDrag_ = function(currentDragDeltaXY) {
+  const newValues = {};
   newValues.delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
-  newValues.newLocation =
-      Blockly.utils.Coordinate.sum(this.startXY_, newValues.delta);
+  newValues.newLocation = Coordinate.sum(this.startXY_, newValues.delta);
   return newValues;
 };
 
@@ -328,7 +327,7 @@ Blockly.BlockDragger.prototype.getNewLocationAfterDrag_ = function(
  * @return {boolean} True if the block was deleted.
  * @protected
  */
-Blockly.BlockDragger.prototype.maybeDeleteBlock_ = function() {
+BlockDragger.prototype.maybeDeleteBlock_ = function() {
   if (this.wouldDeleteBlock_) {
     // Fire a move event, so we know where to go back to for an undo.
     this.fireMoveEvent_();
@@ -341,11 +340,11 @@ Blockly.BlockDragger.prototype.maybeDeleteBlock_ = function() {
 
 /**
  * Updates the necessary information to place a block at a certain location.
- * @param {!Blockly.utils.Coordinate} delta The change in location from where
+ * @param {!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) {
+BlockDragger.prototype.updateBlockAfterMove_ = function(delta) {
   this.draggingBlock_.moveConnections(delta.x, delta.y);
   this.fireMoveEvent_();
   if (this.draggedConnectionManager_.wouldConnectBlock()) {
@@ -361,10 +360,10 @@ Blockly.BlockDragger.prototype.updateBlockAfterMove_ = function(delta) {
  * 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))(
+BlockDragger.prototype.fireDragEndEvent_ = function() {
+  const event = new (events.get(events.BLOCK_DRAG))(
       this.draggingBlock_, false, this.draggingBlock_.getDescendants(false));
-  Blockly.Events.fire(event);
+  events.fire(event);
 };
 
 /**
@@ -374,12 +373,12 @@ Blockly.BlockDragger.prototype.fireDragEndEvent_ = function() {
  * @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();
+BlockDragger.prototype.updateToolboxStyle_ = function(isEnd) {
+  const toolbox = this.workspace_.getToolbox();
 
   if (toolbox) {
-    var style = this.draggingBlock_.isDeletable() ? 'blocklyToolboxDelete' :
-                                                    'blocklyToolboxGrab';
+    const style = this.draggingBlock_.isDeletable() ? 'blocklyToolboxDelete' :
+                                                      'blocklyToolboxGrab';
 
     if (isEnd && typeof toolbox.removeStyle == 'function') {
       toolbox.removeStyle(style);
@@ -394,12 +393,11 @@ Blockly.BlockDragger.prototype.updateToolboxStyle_ = function(isEnd) {
  * 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_);
+BlockDragger.prototype.fireMoveEvent_ = function() {
+  const event = new (events.get(events.BLOCK_MOVE))(this.draggingBlock_);
   event.oldCoordinate = this.startXY_;
   event.recordNew();
-  Blockly.Events.fire(event);
+  events.fire(event);
 };
 
 /**
@@ -407,7 +405,7 @@ Blockly.BlockDragger.prototype.fireMoveEvent_ = function() {
  * dragging block would be deleted if released immediately.
  * @protected
  */
-Blockly.BlockDragger.prototype.updateCursorDuringBlockDrag_ = function() {
+BlockDragger.prototype.updateCursorDuringBlockDrag_ = function() {
   this.draggingBlock_.setDeleteStyle(this.wouldDeleteBlock_);
 };
 
@@ -416,14 +414,14 @@ Blockly.BlockDragger.prototype.updateCursorDuringBlockDrag_ = function() {
  * 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
+ * @param {!Coordinate} pixelCoord A coordinate with x and y
  *     values in CSS pixel units.
- * @return {!Blockly.utils.Coordinate} The input coordinate divided by the
+ * @return {!Coordinate} The input coordinate divided by the
  *     workspace scale.
  * @protected
  */
-Blockly.BlockDragger.prototype.pixelsToWorkspaceUnits_ = function(pixelCoord) {
-  var result = new Blockly.utils.Coordinate(
+BlockDragger.prototype.pixelsToWorkspaceUnits_ = function(pixelCoord) {
+  const result = new Coordinate(
       pixelCoord.x / this.workspace_.scale,
       pixelCoord.y / this.workspace_.scale);
   if (this.workspace_.isMutator) {
@@ -431,7 +429,7 @@ Blockly.BlockDragger.prototype.pixelsToWorkspaceUnits_ = function(pixelCoord) {
     // 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;
+    const mainScale = this.workspace_.options.parentWorkspace.scale;
     result.scale(1 / mainScale);
   }
   return result;
@@ -439,26 +437,26 @@ Blockly.BlockDragger.prototype.pixelsToWorkspaceUnits_ = function(pixelCoord) {
 
 /**
  * Move all of the icons connected to this drag.
- * @param {!Blockly.utils.Coordinate} dxy How far to move the icons from their
+ * @param {!Coordinate} dxy How far to move the icons from their
  *     original positions, in workspace units.
  * @protected
  */
-Blockly.BlockDragger.prototype.dragIcons_ = function(dxy) {
+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));
+  for (let i = 0; i < this.dragIconData_.length; i++) {
+    const data = this.dragIconData_[i];
+    data.icon.setIconLocation(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
+ * @return {!Array<!BlockSvg>} A possibly empty list of insertion
  *     marker blocks.
  * @public
  */
-Blockly.BlockDragger.prototype.getInsertionMarkers = function() {
+BlockDragger.prototype.getInsertionMarkers = function() {
   // No insertion markers with the old style of dragged connection managers.
   if (this.draggedConnectionManager_ &&
       this.draggedConnectionManager_.getInsertionMarkers) {
@@ -467,6 +465,6 @@ Blockly.BlockDragger.prototype.getInsertionMarkers = function() {
   return [];
 };
 
-Blockly.registry.register(
-    Blockly.registry.Type.BLOCK_DRAGGER, Blockly.registry.DEFAULT,
-    Blockly.BlockDragger);
+registry.register(registry.Type.BLOCK_DRAGGER, registry.DEFAULT, BlockDragger);
+
+exports = BlockDragger;
diff --git a/tests/deps.js b/tests/deps.js
index d96855422..e3090ff34 100644
--- a/tests/deps.js
+++ b/tests/deps.js
@@ -10,7 +10,7 @@ goog.addDependency('../../blocks/variables_dynamic.js', ['Blockly.Constants.Vari
 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'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/block_drag_surface.js', ['Blockly.BlockDragSurfaceSvg'], ['Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.Svg', 'Blockly.utils.dom'], {'lang': 'es6', 'module': 'goog'});
-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_dragger.js', ['Blockly.BlockDragger'], ['Blockly.Events', 'Blockly.Events.BlockDrag', 'Blockly.Events.BlockMove', 'Blockly.IBlockDragger', 'Blockly.InsertionMarkerManager', 'Blockly.blockAnimations', 'Blockly.registry', 'Blockly.utils.Coordinate', 'Blockly.utils.dom'], {'lang': 'es6', 'module': 'goog'});
 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.internalConstants', '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.internalConstants', 'Blockly.utils', 'Blockly.utils.Size', 'Blockly.utils.colour', 'Blockly.utils.deprecation', 'Blockly.utils.toolbox']);
 goog.addDependency('../../core/blocks.js', ['Blockly.Blocks'], [], {'lang': 'es6', 'module': 'goog'});