diff --git a/core/renderers/geras/info.js b/core/renderers/geras/info.js
index 121e3b353..582aab2da 100644
--- a/core/renderers/geras/info.js
+++ b/core/renderers/geras/info.js
@@ -11,22 +11,25 @@
  */
 'use strict';
 
-goog.provide('Blockly.geras');
-goog.provide('Blockly.geras.RenderInfo');
+goog.module('Blockly.geras.RenderInfo');
+goog.module.declareLegacyNamespace();
 
-goog.require('Blockly.blockRendering.ExternalValueInput');
-goog.require('Blockly.blockRendering.InputRow');
-goog.require('Blockly.blockRendering.InRowSpacer');
-goog.require('Blockly.blockRendering.RenderInfo');
-goog.require('Blockly.blockRendering.Types');
-goog.require('Blockly.geras.InlineInput');
-goog.require('Blockly.geras.StatementInput');
-goog.require('Blockly.inputTypes');
-goog.require('Blockly.utils.object');
-
-goog.requireType('Blockly.blockRendering.Field');
-goog.requireType('Blockly.BlockSvg');
-goog.requireType('Blockly.geras.Renderer');
+const BaseRenderInfo = goog.require('Blockly.blockRendering.RenderInfo');
+/* eslint-disable-next-line no-unused-vars */
+const BlockSvg = goog.requireType('Blockly.BlockSvg');
+const ExternalValueInput = goog.require('Blockly.blockRendering.ExternalValueInput');
+/* eslint-disable-next-line no-unused-vars */
+const Field = goog.requireType('Blockly.blockRendering.Field');
+const InlineInput = goog.require('Blockly.geras.InlineInput');
+/* eslint-disable-next-line no-unused-vars */
+const InputRow = goog.requireType('Blockly.blockRendering.InputRow');
+const InRowSpacer = goog.require('Blockly.blockRendering.InRowSpacer');
+/* eslint-disable-next-line no-unused-vars */
+const Renderer = goog.requireType('Blockly.geras.Renderer');
+const StatementInput = goog.require('Blockly.geras.StatementInput');
+const Types = goog.require('Blockly.blockRendering.Types');
+const inputTypes = goog.require('Blockly.inputTypes');
+const object = goog.require('Blockly.utils.object');
 
 
 /**
@@ -36,36 +39,35 @@ goog.requireType('Blockly.geras.Renderer');
  * may choose to rerender when getSize() is called).  However, calling it
  * repeatedly may be expensive.
  *
- * @param {!Blockly.geras.Renderer} renderer The renderer in use.
- * @param {!Blockly.BlockSvg} block The block to measure.
+ * @param {!Renderer} renderer The renderer in use.
+ * @param {!BlockSvg} block The block to measure.
  * @constructor
  * @package
- * @extends {Blockly.blockRendering.RenderInfo}
+ * @extends {BaseRenderInfo}
  */
-Blockly.geras.RenderInfo = function(renderer, block) {
-  Blockly.geras.RenderInfo.superClass_.constructor.call(this, renderer, block);
+const RenderInfo = function(renderer, block) {
+  RenderInfo.superClass_.constructor.call(this, renderer, block);
 };
-Blockly.utils.object.inherits(Blockly.geras.RenderInfo,
-    Blockly.blockRendering.RenderInfo);
+object.inherits(RenderInfo, BaseRenderInfo);
 
 /**
  * Get the block renderer in use.
- * @return {!Blockly.geras.Renderer} The block renderer in use.
+ * @return {!Renderer} The block renderer in use.
  * @package
  */
-Blockly.geras.RenderInfo.prototype.getRenderer = function() {
-  return /** @type {!Blockly.geras.Renderer} */ (this.renderer_);
+RenderInfo.prototype.getRenderer = function() {
+  return /** @type {!Renderer} */ (this.renderer_);
 };
 
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.populateBottomRow_ = function() {
-  Blockly.geras.RenderInfo.superClass_.populateBottomRow_.call(this);
+RenderInfo.prototype.populateBottomRow_ = function() {
+  RenderInfo.superClass_.populateBottomRow_.call(this);
 
-  var followsStatement = this.block_.inputList.length &&
+  const followsStatement = this.block_.inputList.length &&
       this.block_.inputList[this.block_.inputList.length - 1].type ==
-          Blockly.inputTypes.STATEMENT;
+          inputTypes.STATEMENT;
 
   // The minimum height of the bottom row is smaller in Geras than in other
   // renderers, because the dark path adds a pixel.
@@ -75,31 +77,27 @@ Blockly.geras.RenderInfo.prototype.populateBottomRow_ = function() {
     this.bottomRow.minHeight =
         this.constants_.MEDIUM_PADDING - this.constants_.DARK_PATH_OFFSET;
   }
-
 };
 
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.addInput_ = function(input, activeRow) {
+RenderInfo.prototype.addInput_ = function(input, activeRow) {
   // Non-dummy inputs have visual representations onscreen.
-  if (this.isInline && input.type == Blockly.inputTypes.VALUE) {
-    activeRow.elements.push(
-        new Blockly.geras.InlineInput(this.constants_, input));
+  if (this.isInline && input.type == inputTypes.VALUE) {
+    activeRow.elements.push(new InlineInput(this.constants_, input));
     activeRow.hasInlineInput = true;
-  } else if (input.type == Blockly.inputTypes.STATEMENT) {
-    activeRow.elements.push(
-        new Blockly.geras.StatementInput(this.constants_, input));
+  } else if (input.type == inputTypes.STATEMENT) {
+    activeRow.elements.push(new StatementInput(this.constants_, input));
     activeRow.hasStatement = true;
-  } else if (input.type == Blockly.inputTypes.VALUE) {
-    activeRow.elements.push(
-        new Blockly.blockRendering.ExternalValueInput(this.constants_, input));
+  } else if (input.type == inputTypes.VALUE) {
+    activeRow.elements.push(new ExternalValueInput(this.constants_, input));
     activeRow.hasExternalInput = true;
-  } else if (input.type == Blockly.inputTypes.DUMMY) {
+  } else if (input.type == inputTypes.DUMMY) {
     // Dummy inputs have no visual representation, but the information is still
     // important.
-    activeRow.minHeight = Math.max(activeRow.minHeight,
-        this.constants_.DUMMY_INPUT_MIN_HEIGHT);
+    activeRow.minHeight =
+        Math.max(activeRow.minHeight, this.constants_.DUMMY_INPUT_MIN_HEIGHT);
     activeRow.hasDummyInput = true;
   }
   // Ignore row alignment if inline.
@@ -111,40 +109,38 @@ Blockly.geras.RenderInfo.prototype.addInput_ = function(input, activeRow) {
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.addElemSpacing_ = function() {
-  var hasExternalInputs = false;
-  for (var i = 0, row; (row = this.rows[i]); i++) {
+RenderInfo.prototype.addElemSpacing_ = function() {
+  let hasExternalInputs = false;
+  for (let i = 0, row; (row = this.rows[i]); i++) {
     if (row.hasExternalInput) {
       hasExternalInputs = true;
     }
   }
-  for (var i = 0, row; (row = this.rows[i]); i++) {
-    var oldElems = row.elements;
+  for (let i = 0, row; (row = this.rows[i]); i++) {
+    const oldElems = row.elements;
     row.elements = [];
     // No spacing needed before the corner on the top row or the bottom row.
     if (row.startsWithElemSpacer()) {
       // There's a spacer before the first element in the row.
-      row.elements.push(new Blockly.blockRendering.InRowSpacer(
+      row.elements.push(new InRowSpacer(
           this.constants_, this.getInRowSpacing_(null, oldElems[0])));
     }
     if (!oldElems.length) {
       continue;
     }
-    for (var e = 0; e < oldElems.length - 1; e++) {
+    for (let e = 0; e < oldElems.length - 1; e++) {
       row.elements.push(oldElems[e]);
-      var spacing = this.getInRowSpacing_(oldElems[e], oldElems[e + 1]);
-      row.elements.push(
-          new Blockly.blockRendering.InRowSpacer(this.constants_, spacing));
+      const spacing = this.getInRowSpacing_(oldElems[e], oldElems[e + 1]);
+      row.elements.push(new InRowSpacer(this.constants_, spacing));
     }
     row.elements.push(oldElems[oldElems.length - 1]);
     if (row.endsWithElemSpacer()) {
-      var spacing = this.getInRowSpacing_(oldElems[oldElems.length - 1], null);
+      let spacing = this.getInRowSpacing_(oldElems[oldElems.length - 1], null);
       if (hasExternalInputs && row.hasDummyInput) {
         spacing += this.constants_.TAB_WIDTH;
       }
       // There's a spacer after the last element in the row.
-      row.elements.push(new Blockly.blockRendering.InRowSpacer(
-          this.constants_, spacing));
+      row.elements.push(new InRowSpacer(this.constants_, spacing));
     }
   }
 };
@@ -152,18 +148,18 @@ Blockly.geras.RenderInfo.prototype.addElemSpacing_ = function() {
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.getInRowSpacing_ = function(prev, next) {
+RenderInfo.prototype.getInRowSpacing_ = function(prev, next) {
   if (!prev) {
     // Between an editable field and the beginning of the row.
-    if (next && Blockly.blockRendering.Types.isField(next) &&
-        (/** @type {Blockly.blockRendering.Field} */ (next)).isEditable) {
+    if (next && Types.isField(next) &&
+        (/** @type {Field} */ (next)).isEditable) {
       return this.constants_.MEDIUM_PADDING;
     }
     // Inline input at the beginning of the row.
-    if (next && Blockly.blockRendering.Types.isInlineInput(next)) {
+    if (next && Types.isInlineInput(next)) {
       return this.constants_.MEDIUM_LARGE_PADDING;
     }
-    if (next && Blockly.blockRendering.Types.isStatementInput(next)) {
+    if (next && Types.isStatementInput(next)) {
       return this.constants_.STATEMENT_INPUT_PADDING_LEFT;
     }
     // Anything else at the beginning of the row.
@@ -171,30 +167,28 @@ Blockly.geras.RenderInfo.prototype.getInRowSpacing_ = function(prev, next) {
   }
 
   // Spacing between a non-input and the end of the row or a statement input.
-  if (!Blockly.blockRendering.Types.isInput(prev) && (!next ||
-      Blockly.blockRendering.Types.isStatementInput(next))) {
+  if (!Types.isInput(prev) && (!next || Types.isStatementInput(next))) {
     // Between an editable field and the end of the row.
-    if (Blockly.blockRendering.Types.isField(prev) &&
-        (/** @type {Blockly.blockRendering.Field} */ (prev)).isEditable) {
+    if (Types.isField(prev) && (/** @type {Field} */ (prev)).isEditable) {
       return this.constants_.MEDIUM_PADDING;
     }
     // Padding at the end of an icon-only row to make the block shape clearer.
-    if (Blockly.blockRendering.Types.isIcon(prev)) {
+    if (Types.isIcon(prev)) {
       return (this.constants_.LARGE_PADDING * 2) + 1;
     }
-    if (Blockly.blockRendering.Types.isHat(prev)) {
+    if (Types.isHat(prev)) {
       return this.constants_.NO_PADDING;
     }
     // Establish a minimum width for a block with a previous or next connection.
-    if (Blockly.blockRendering.Types.isPreviousOrNextConnection(prev)) {
+    if (Types.isPreviousOrNextConnection(prev)) {
       return this.constants_.LARGE_PADDING;
     }
     // Between rounded corner and the end of the row.
-    if (Blockly.blockRendering.Types.isLeftRoundedCorner(prev)) {
+    if (Types.isLeftRoundedCorner(prev)) {
       return this.constants_.MIN_BLOCK_WIDTH;
     }
     // Between a jagged edge and the end of the row.
-    if (Blockly.blockRendering.Types.isJaggedEdge(prev)) {
+    if (Types.isJaggedEdge(prev)) {
       return this.constants_.NO_PADDING;
     }
     // Between noneditable fields and icons and the end of the row.
@@ -202,33 +196,31 @@ Blockly.geras.RenderInfo.prototype.getInRowSpacing_ = function(prev, next) {
   }
 
   // Between inputs and the end of the row.
-  if (Blockly.blockRendering.Types.isInput(prev) && !next) {
-    if (Blockly.blockRendering.Types.isExternalInput(prev)) {
+  if (Types.isInput(prev) && !next) {
+    if (Types.isExternalInput(prev)) {
       return this.constants_.NO_PADDING;
-    } else if (Blockly.blockRendering.Types.isInlineInput(prev)) {
+    } else if (Types.isInlineInput(prev)) {
       return this.constants_.LARGE_PADDING;
-    } else if (Blockly.blockRendering.Types.isStatementInput(prev)) {
+    } else if (Types.isStatementInput(prev)) {
       return this.constants_.NO_PADDING;
     }
   }
 
   // Spacing between a non-input and an input.
-  if (!Blockly.blockRendering.Types.isInput(prev) &&
-      next && Blockly.blockRendering.Types.isInput(next)) {
+  if (!Types.isInput(prev) && next && Types.isInput(next)) {
     // Between an editable field and an input.
-    if (Blockly.blockRendering.Types.isField(prev) &&
-        (/** @type {Blockly.blockRendering.Field} */ (prev)).isEditable) {
-      if (Blockly.blockRendering.Types.isInlineInput(next)) {
+    if (Types.isField(prev) && (/** @type {Field} */ (prev)).isEditable) {
+      if (Types.isInlineInput(next)) {
         return this.constants_.SMALL_PADDING;
-      } else if (Blockly.blockRendering.Types.isExternalInput(next)) {
+      } else if (Types.isExternalInput(next)) {
         return this.constants_.SMALL_PADDING;
       }
     } else {
-      if (Blockly.blockRendering.Types.isInlineInput(next)) {
+      if (Types.isInlineInput(next)) {
         return this.constants_.MEDIUM_LARGE_PADDING;
-      } else if (Blockly.blockRendering.Types.isExternalInput(next)) {
+      } else if (Types.isExternalInput(next)) {
         return this.constants_.MEDIUM_LARGE_PADDING;
-      } else if (Blockly.blockRendering.Types.isStatementInput(next)) {
+      } else if (Types.isStatementInput(next)) {
         return this.constants_.LARGE_PADDING;
       }
     }
@@ -236,16 +228,14 @@ Blockly.geras.RenderInfo.prototype.getInRowSpacing_ = function(prev, next) {
   }
 
   // Spacing between an icon and an icon or field.
-  if (Blockly.blockRendering.Types.isIcon(prev) &&
-      next && !Blockly.blockRendering.Types.isInput(next)) {
+  if (Types.isIcon(prev) && next && !Types.isInput(next)) {
     return this.constants_.LARGE_PADDING;
   }
 
   // Spacing between an inline input and a field.
-  if (Blockly.blockRendering.Types.isInlineInput(prev) &&
-      next && Blockly.blockRendering.Types.isField(next)) {
+  if (Types.isInlineInput(prev) && next && Types.isField(next)) {
     // Editable field after inline input.
-    if ((/** @type {Blockly.blockRendering.Field} */ (next)).isEditable) {
+    if ((/** @type {Field} */ (next)).isEditable) {
       return this.constants_.MEDIUM_PADDING;
     } else {
       // Noneditable field after inline input.
@@ -253,46 +243,43 @@ Blockly.geras.RenderInfo.prototype.getInRowSpacing_ = function(prev, next) {
     }
   }
 
-  if (Blockly.blockRendering.Types.isLeftSquareCorner(prev) && next) {
+  if (Types.isLeftSquareCorner(prev) && next) {
     // Spacing between a hat and a corner
-    if (Blockly.blockRendering.Types.isHat(next)) {
+    if (Types.isHat(next)) {
       return this.constants_.NO_PADDING;
     }
     // Spacing between a square corner and a previous or next connection
-    if (Blockly.blockRendering.Types.isPreviousConnection(next)) {
+    if (Types.isPreviousConnection(next)) {
       return next.notchOffset;
-    } else if (Blockly.blockRendering.Types.isNextConnection(next)) {
+    } else if (Types.isNextConnection(next)) {
       // Next connections are shifted slightly to the left (in both LTR and RTL)
       // to make the dark path under the previous connection show through.
-      var offset = (this.RTL ? 1 : -1) *
-          this.constants_.DARK_PATH_OFFSET / 2;
+      const offset = (this.RTL ? 1 : -1) * this.constants_.DARK_PATH_OFFSET / 2;
       return next.notchOffset + offset;
     }
   }
 
   // Spacing between a rounded corner and a previous or next connection.
-  if (Blockly.blockRendering.Types.isLeftRoundedCorner(prev) && next) {
-    if (Blockly.blockRendering.Types.isPreviousConnection(next)) {
+  if (Types.isLeftRoundedCorner(prev) && next) {
+    if (Types.isPreviousConnection(next)) {
       return next.notchOffset - this.constants_.CORNER_RADIUS;
-    } else if (Blockly.blockRendering.Types.isNextConnection(next)) {
+    } else if (Types.isNextConnection(next)) {
       // Next connections are shifted slightly to the left (in both LTR and RTL)
       // to make the dark path under the previous connection show through.
-      var offset = (this.RTL ? 1 : -1) *
-          this.constants_.DARK_PATH_OFFSET / 2;
+      const offset = (this.RTL ? 1 : -1) * this.constants_.DARK_PATH_OFFSET / 2;
       return next.notchOffset - this.constants_.CORNER_RADIUS + offset;
     }
   }
 
   // Spacing between two fields of the same editability.
-  if (Blockly.blockRendering.Types.isField(prev) &&
-      next && Blockly.blockRendering.Types.isField(next) &&
-      ((/** @type {Blockly.blockRendering.Field} */ (prev)).isEditable ==
-          (/** @type {Blockly.blockRendering.Field} */ (next)).isEditable)) {
+  if (Types.isField(prev) && next && Types.isField(next) &&
+      ((/** @type {Field} */ (prev)).isEditable ==
+       (/** @type {Field} */ (next)).isEditable)) {
     return this.constants_.LARGE_PADDING;
   }
 
   // Spacing between anything and a jagged edge.
-  if (next && Blockly.blockRendering.Types.isJaggedEdge(next)) {
+  if (next && Types.isJaggedEdge(next)) {
     return this.constants_.LARGE_PADDING;
   }
 
@@ -302,15 +289,13 @@ Blockly.geras.RenderInfo.prototype.getInRowSpacing_ = function(prev, next) {
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.getSpacerRowHeight_ = function(prev, next) {
+RenderInfo.prototype.getSpacerRowHeight_ = function(prev, next) {
   // If we have an empty block add a spacer to increase the height.
-  if (Blockly.blockRendering.Types.isTopRow(prev) &&
-      Blockly.blockRendering.Types.isBottomRow(next)) {
+  if (Types.isTopRow(prev) && Types.isBottomRow(next)) {
     return this.constants_.EMPTY_BLOCK_SPACER_HEIGHT;
   }
   // Top and bottom rows act as a spacer so we don't need any extra padding.
-  if (Blockly.blockRendering.Types.isTopRow(prev) ||
-      Blockly.blockRendering.Types.isBottomRow(next)) {
+  if (Types.isTopRow(prev) || Types.isBottomRow(next)) {
     return this.constants_.NO_PADDING;
   }
   if (prev.hasExternalInput && next.hasExternalInput) {
@@ -334,33 +319,32 @@ Blockly.geras.RenderInfo.prototype.getSpacerRowHeight_ = function(prev, next) {
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.getElemCenterline_ = function(row, elem) {
-  if (Blockly.blockRendering.Types.isSpacer(elem)) {
+RenderInfo.prototype.getElemCenterline_ = function(row, elem) {
+  if (Types.isSpacer(elem)) {
     return row.yPos + elem.height / 2;
   }
-  if (Blockly.blockRendering.Types.isBottomRow(row)) {
-    var baseline = row.yPos + row.height - row.descenderHeight;
-    if (Blockly.blockRendering.Types.isNextConnection(elem)) {
+  if (Types.isBottomRow(row)) {
+    const baseline = row.yPos + row.height - row.descenderHeight;
+    if (Types.isNextConnection(elem)) {
       return baseline + elem.height / 2;
     }
     return baseline - elem.height / 2;
   }
-  if (Blockly.blockRendering.Types.isTopRow(row)) {
-    if (Blockly.blockRendering.Types.isHat(elem)) {
+  if (Types.isTopRow(row)) {
+    if (Types.isHat(elem)) {
       return row.capline - elem.height / 2;
     }
     return row.capline + elem.height / 2;
   }
 
-  var result = row.yPos;
-  if (Blockly.blockRendering.Types.isField(elem) ||
-      Blockly.blockRendering.Types.isIcon(elem)) {
+  let result = row.yPos;
+  if (Types.isField(elem) || Types.isIcon(elem)) {
     result += (elem.height / 2);
     if ((row.hasInlineInput || row.hasStatement) &&
         elem.height + this.constants_.TALL_INPUT_FIELD_OFFSET_Y <= row.height) {
       result += this.constants_.TALL_INPUT_FIELD_OFFSET_Y;
     }
-  } else if (Blockly.blockRendering.Types.isInlineInput(elem)) {
+  } else if (Types.isInlineInput(elem)) {
     result += elem.height / 2;
   } else {
     result += (row.height / 2);
@@ -371,22 +355,22 @@ Blockly.geras.RenderInfo.prototype.getElemCenterline_ = function(row, elem) {
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.alignRowElements_ = function() {
+RenderInfo.prototype.alignRowElements_ = function() {
   if (!this.isInline) {
-    Blockly.geras.RenderInfo.superClass_.alignRowElements_.call(this);
+    RenderInfo.superClass_.alignRowElements_.call(this);
     return;
   }
 
   // Walk backgrounds through rows on the block, keeping track of the right
   // input edge.
-  var nextRightEdge = 0;
-  var prevInput = null;
-  for (var i = this.rows.length - 1, row; (row = this.rows[i]); i--) {
+  let nextRightEdge = 0;
+  let prevInput = null;
+  for (let i = this.rows.length - 1, row; (row = this.rows[i]); i--) {
     row.nextRightEdge = nextRightEdge;
-    if (Blockly.blockRendering.Types.isInputRow(row)) {
+    if (Types.isInputRow(row)) {
       if (row.hasStatement) {
         this.alignStatementRow_(
-            /** @type {!Blockly.blockRendering.InputRow} */ (row));
+            /** @type {!InputRow} */ (row));
       }
       if (prevInput && prevInput.hasStatement && row.width < prevInput.width) {
         row.nextRightEdge = prevInput.width;
@@ -398,17 +382,17 @@ Blockly.geras.RenderInfo.prototype.alignRowElements_ = function() {
   }
   // Walk down each row from the top, comparing the prev and next right input
   // edges and setting the desired width to the max of the two.
-  var prevRightEdge = 0;
-  for (var i = 0, row; (row = this.rows[i]); i++) {
+  let prevRightEdge = 0;
+  for (let i = 0, row; (row = this.rows[i]); i++) {
     if (row.hasStatement) {
       prevRightEdge = this.getDesiredRowWidth_(row);
-    } else if (Blockly.blockRendering.Types.isSpacer(row)) {
+    } else if (Types.isSpacer(row)) {
       // Set the spacer row to the max of the prev or next input width.
       row.width = Math.max(prevRightEdge, row.nextRightEdge);
     } else {
-      var currentWidth = row.width;
-      var desiredWidth = Math.max(prevRightEdge, row.nextRightEdge);
-      var missingSpace = desiredWidth - currentWidth;
+      const currentWidth = row.width;
+      const desiredWidth = Math.max(prevRightEdge, row.nextRightEdge);
+      const missingSpace = desiredWidth - currentWidth;
       if (missingSpace > 0) {
         this.addAlignmentPadding_(row, missingSpace);
       }
@@ -420,26 +404,24 @@ Blockly.geras.RenderInfo.prototype.alignRowElements_ = function() {
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.getDesiredRowWidth_ = function(
-    row) {
+RenderInfo.prototype.getDesiredRowWidth_ = function(row) {
   // Limit the width of a statement row when a block is inline.
   if (this.isInline && row.hasStatement) {
     return this.statementEdge + this.constants_.MAX_BOTTOM_WIDTH + this.startX;
   }
-  return Blockly.geras.RenderInfo.superClass_.getDesiredRowWidth_.call(this,
-      row);
+  return RenderInfo.superClass_.getDesiredRowWidth_.call(this, row);
 };
 
 /**
  * @override
  */
-Blockly.geras.RenderInfo.prototype.finalize_ = function() {
+RenderInfo.prototype.finalize_ = function() {
   // Performance note: this could be combined with the draw pass, if the time
   // that this takes is excessive.  But it shouldn't be, because it only
   // accesses and sets properties that already exist on the objects.
-  var widestRowWithConnectedBlocks = 0;
-  var yCursor = 0;
-  for (var i = 0, row; (row = this.rows[i]); i++) {
+  let widestRowWithConnectedBlocks = 0;
+  let yCursor = 0;
+  for (let i = 0, row; (row = this.rows[i]); i++) {
     row.yPos = yCursor;
     row.xPos = this.startX;
     yCursor += row.height;
@@ -447,11 +429,11 @@ Blockly.geras.RenderInfo.prototype.finalize_ = function() {
     widestRowWithConnectedBlocks =
         Math.max(widestRowWithConnectedBlocks, row.widthWithConnectedBlocks);
     // Add padding to the bottom row if block height is less than minimum
-    var heightWithoutHat = yCursor - this.topRow.ascenderHeight;
+    const heightWithoutHat = yCursor - this.topRow.ascenderHeight;
     if (row == this.bottomRow &&
         heightWithoutHat < this.constants_.MIN_BLOCK_HEIGHT) {
       // But the hat height shouldn't be part of this.
-      var diff = this.constants_.MIN_BLOCK_HEIGHT - heightWithoutHat;
+      const diff = this.constants_.MIN_BLOCK_HEIGHT - heightWithoutHat;
       this.bottomRow.height += diff;
       yCursor += diff;
     }
@@ -460,18 +442,20 @@ Blockly.geras.RenderInfo.prototype.finalize_ = function() {
   if (this.outputConnection && this.block_.nextConnection &&
       this.block_.nextConnection.isConnected()) {
     // Include width of connected block in value to stack width measurement.
-    widestRowWithConnectedBlocks =
-        Math.max(widestRowWithConnectedBlocks,
-            this.block_.nextConnection.targetBlock().getHeightWidth().width -
+    widestRowWithConnectedBlocks = Math.max(
+        widestRowWithConnectedBlocks,
+        this.block_.nextConnection.targetBlock().getHeightWidth().width -
             this.constants_.DARK_PATH_OFFSET);
   }
 
   this.bottomRow.baseline = yCursor - this.bottomRow.descenderHeight;
 
   // The dark (lowlight) adds to the size of the block in both x and y.
-  this.widthWithChildren = widestRowWithConnectedBlocks +
-      this.startX + this.constants_.DARK_PATH_OFFSET;
+  this.widthWithChildren = widestRowWithConnectedBlocks + this.startX +
+      this.constants_.DARK_PATH_OFFSET;
   this.width += this.constants_.DARK_PATH_OFFSET;
   this.height = yCursor + this.constants_.DARK_PATH_OFFSET;
   this.startY = this.topRow.capline;
 };
+
+exports = RenderInfo;
diff --git a/tests/deps.js b/tests/deps.js
index 14ae08221..c3e682394 100644
--- a/tests/deps.js
+++ b/tests/deps.js
@@ -134,7 +134,7 @@ goog.addDependency('../../core/renderers/geras/constants.js', ['Blockly.geras.Co
 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'], {'lang': 'es6', 'module': 'goog'});
-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.geras.InlineInput', 'Blockly.geras.StatementInput', 'Blockly.inputTypes', 'Blockly.utils.object']);
+goog.addDependency('../../core/renderers/geras/info.js', ['Blockly.geras.RenderInfo'], ['Blockly.blockRendering.ExternalValueInput', 'Blockly.blockRendering.InRowSpacer', 'Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.Types', 'Blockly.geras.InlineInput', 'Blockly.geras.StatementInput', 'Blockly.inputTypes', 'Blockly.utils.object'], {'lang': 'es6', 'module': 'goog'});
 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']);