diff --git "a/core/block_render.js" "b/core/block_render.js"
new file mode 100644--- /dev/null
+++ "b/core/block_render.js"
@@ -0,0 +1,2433 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2012 Google Inc.
+ * https://developers.google.com/blockly/
+ *
+ * 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 Methods for graphically rendering a block as SVG.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.BlockSvg.render');
+
+goog.require('Blockly.BlockSvg');
+goog.require('Blockly.scratchBlocksUtils');
+goog.require('Blockly.utils');
+goog.require('Blockly.constants');
+
+
+// UI constants for rendering blocks.
+/**
+* Grid unit to pixels conversion
+* @const
+*/
+Blockly.BlockSvg.GRID_UNIT = 4;
+
+/**
+ * Horizontal space between elements.
+ * @const
+ */
+Blockly.BlockSvg.SEP_SPACE_X = 2 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Vertical space between elements.
+ * @const
+ */
+Blockly.BlockSvg.SEP_SPACE_Y = 2 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum width of a block.
+ * @const
+ */
+Blockly.BlockSvg.MIN_BLOCK_X = 16 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum width of a block with output (reporters).
+ * @const
+ */
+Blockly.BlockSvg.MIN_BLOCK_X_OUTPUT = 12 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum width of a shadow block with output (single fields).
+ * @const
+ */
+Blockly.BlockSvg.MIN_BLOCK_X_SHADOW_OUTPUT = 10 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum height of a block.
+ * @const
+ */
+Blockly.BlockSvg.MIN_BLOCK_Y = 12 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Height of extra row after a statement input.
+ * @const
+ */
+Blockly.BlockSvg.EXTRA_STATEMENT_ROW_Y = 8 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum width of a C- or E-shaped block.
+ * @const
+ */
+Blockly.BlockSvg.MIN_BLOCK_X_WITH_STATEMENT = 40 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum height of a shadow block with output and a single field.
+ * This is used for shadow blocks that only contain a field - which are smaller than even reporters.
+ * @const
+ */
+Blockly.BlockSvg.MIN_BLOCK_Y_SINGLE_FIELD_OUTPUT = 8 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum height of a non-shadow block with output, i.e. a reporter.
+ * @const
+ */
+Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER = 10 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum space for a statement input height.
+ * @const
+ */
+Blockly.BlockSvg.MIN_STATEMENT_INPUT_HEIGHT = 6 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Width of vertical notch.
+ * @const
+ */
+Blockly.BlockSvg.NOTCH_WIDTH = 8 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Height of vertical notch.
+ * @const
+ */
+Blockly.BlockSvg.NOTCH_HEIGHT = 2 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Rounded corner radius.
+ * @const
+ */
+Blockly.BlockSvg.CORNER_RADIUS = 1 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum width of statement input edge on the left, in px.
+ * @const
+ */
+Blockly.BlockSvg.STATEMENT_INPUT_EDGE_WIDTH = 4 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Inner space between edge of statement input and notch.
+ * @const
+ */
+Blockly.BlockSvg.STATEMENT_INPUT_INNER_SPACE = 2 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Height of the top hat.
+ * @const
+ */
+Blockly.BlockSvg.START_HAT_HEIGHT = 16;
+
+/**
+ * Height of the vertical separator line for icons that appear at the left edge
+ * of a block, such as extension icons.
+ * @const
+ */
+Blockly.BlockSvg.ICON_SEPARATOR_HEIGHT = 10 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Path of the top hat's curve.
+ * @const
+ */
+Blockly.BlockSvg.START_HAT_PATH = 'c 25,-22 71,-22 96,0';
+
+/**
+ * SVG path for drawing next/previous notch from left to right.
+ * @const
+ */
+Blockly.BlockSvg.NOTCH_PATH_LEFT = `c 2 0 3 1 4 2 l 4 4 c 1 1 2 2 4 2 h 12 c 2 0 3 -1 4 -2 l 4 -4 c 1 -1 2 -2 4 -2`;
+
+/**
+ * SVG path for drawing next/previous notch from right to left.
+ * @const
+ */
+Blockly.BlockSvg.NOTCH_PATH_RIGHT = `c -2 0 -3 1 -4 2 l -4 4 c -1 1 -2 2 -4 2 h -12 c -2 0 -3 -1 -4 -2 l -4 -4 c -1 -1 -2 -2 -4 -2`;
+
+/**
+ * @const
+ */
+Blockly.BlockSvg.NOTCH_SWITCH_PATH_LEFT = `c 2 0 3 1 4 2 l 4 4 c 1 1 2 2 4 2 c 2 0 4 -4 6 -4 c 2 0 4 4 6 4 c 2 0 3 -1 4 -2 l 4 -4 c 1 -1 2 -2 4 -2`;
+
+/**
+ * @const
+ */
+Blockly.BlockSvg.NOTCH_SWITCH_PATH_RIGHT = `c -2 0 -3 1 -4 2 l -4 4 c -1 1 -2 2 -4 2 c -2 0 -4 -4 -6 -4 c -2 0 -4 4 -6 4 c -2 0 -3 -1 -4 -2 l -4 -4 c -1 -1 -2 -2 -4 -2`;
+
+/**
+ * @const
+ * @type {boolean}
+ */
+Blockly.BlockSvg.NOTCH_SWITCH_ENABLE = true
+
+/**
+ * Amount of padding before the notch.
+ * @const
+ */
+Blockly.BlockSvg.NOTCH_START_PADDING = 3 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * SVG start point for drawing the top-left corner.
+ * @const
+ */
+Blockly.BlockSvg.TOP_LEFT_CORNER_START =
+    'm 0,' + Blockly.BlockSvg.CORNER_RADIUS;
+
+/**
+ * SVG path for drawing the rounded top-left corner.
+ * @const
+ */
+Blockly.BlockSvg.TOP_LEFT_CORNER =
+    'A ' + Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS + ' 0 0,1 ' +
+    Blockly.BlockSvg.CORNER_RADIUS + ',0';
+
+/**
+ * SVG path for drawing the rounded top-right corner.
+ * @const
+ */
+Blockly.BlockSvg.TOP_RIGHT_CORNER =
+    'a ' + Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS + ' 0 0,1 ' +
+    Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS;
+
+/**
+ * SVG path for drawing the rounded bottom-right corner.
+ * @const
+ */
+Blockly.BlockSvg.BOTTOM_RIGHT_CORNER =
+    ' a ' + Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS + ' 0 0,1 -' +
+    Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS;
+
+/**
+ * SVG path for drawing the rounded bottom-left corner.
+ * @const
+ */
+Blockly.BlockSvg.BOTTOM_LEFT_CORNER =
+    'a ' + Blockly.BlockSvg.CORNER_RADIUS + ',' +
+     Blockly.BlockSvg.CORNER_RADIUS + ' 0 0,1 -' +
+     Blockly.BlockSvg.CORNER_RADIUS + ',-' +
+     Blockly.BlockSvg.CORNER_RADIUS;
+
+/**
+ * SVG path for drawing the top-left corner of a statement input.
+ * @const
+ */
+Blockly.BlockSvg.INNER_TOP_LEFT_CORNER =
+    ' a ' + Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS + ' 0 0,0 -' +
+    Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS;
+
+/**
+ * SVG path for drawing the bottom-left corner of a statement input.
+ * Includes the rounded inside corner.
+ * @const
+ */
+Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER =
+    'a ' + Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS + ' 0 0,0 ' +
+    Blockly.BlockSvg.CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.CORNER_RADIUS;
+
+/**
+ * SVG path for an empty leaf input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_LEAF = 
+  `
+  M ${6 * Blockly.BlockSvg.GRID_UNIT} 0
+  l ${2 * Blockly.BlockSvg.GRID_UNIT} 0
+  a ${4 * Blockly.BlockSvg.GRID_UNIT} ${4 * Blockly.BlockSvg.GRID_UNIT} 0 0 1 ${4 * Blockly.BlockSvg.GRID_UNIT} ${4 * Blockly.BlockSvg.GRID_UNIT}
+  l 0 ${2.4 * Blockly.BlockSvg.GRID_UNIT}
+  a ${1.6 * Blockly.BlockSvg.GRID_UNIT} ${1.6 * Blockly.BlockSvg.GRID_UNIT} 0 0 1 -${1.6 * Blockly.BlockSvg.GRID_UNIT} ${1.6 * Blockly.BlockSvg.GRID_UNIT}
+  h -${4 * Blockly.BlockSvg.GRID_UNIT}
+  l -${2.4 * Blockly.BlockSvg.GRID_UNIT} 0
+  a ${4 * Blockly.BlockSvg.GRID_UNIT} ${4 * Blockly.BlockSvg.GRID_UNIT} 0 0 1 -${4 * Blockly.BlockSvg.GRID_UNIT} -${4 * Blockly.BlockSvg.GRID_UNIT}
+  l 0 -${2.4 * Blockly.BlockSvg.GRID_UNIT}
+  a ${1.6 * Blockly.BlockSvg.GRID_UNIT} ${1.6 * Blockly.BlockSvg.GRID_UNIT} 0 0 1 ${1.6 * Blockly.BlockSvg.GRID_UNIT} -${1.6 * Blockly.BlockSvg.GRID_UNIT}
+  z
+  `
+
+/**
+ * Width of empty plus input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_PLUS_WIDTH = 12 * Blockly.BlockSvg.GRID_UNIT;
+/**
+ * SVG path for an empty leaf input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_PLUS = 
+  `
+  M ${9 * Blockly.BlockSvg.GRID_UNIT} 0
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 1 ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT}
+  l 0 2
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 0 ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT}
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 1 ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT}
+  l 0 4
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 1 -${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT}
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 0 -${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT}
+  l 0 2
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 1 -${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT}
+  h -${6 * Blockly.BlockSvg.GRID_UNIT}
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 1 -${Blockly.BlockSvg.GRID_UNIT} -${Blockly.BlockSvg.GRID_UNIT}
+  l 0 -2
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 0 -${Blockly.BlockSvg.GRID_UNIT} -${Blockly.BlockSvg.GRID_UNIT}
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 1 -${Blockly.BlockSvg.GRID_UNIT} -${Blockly.BlockSvg.GRID_UNIT}
+  l 0 -4
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 1 ${Blockly.BlockSvg.GRID_UNIT} -${Blockly.BlockSvg.GRID_UNIT}
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 0 ${Blockly.BlockSvg.GRID_UNIT} -${Blockly.BlockSvg.GRID_UNIT}
+  l 0 -2
+  a ${Blockly.BlockSvg.GRID_UNIT} ${Blockly.BlockSvg.GRID_UNIT} 0 0 1 ${Blockly.BlockSvg.GRID_UNIT} -${Blockly.BlockSvg.GRID_UNIT} 
+  z
+  `
+
+/**
+ * Width of empty leaf input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_LEAF_WIDTH = 12 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * SVG path for an empty hexagonal input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_HEXAGONAL =
+    'M ' + 4 * Blockly.BlockSvg.GRID_UNIT + ',0 ' +
+    ' h ' + 4 * Blockly.BlockSvg.GRID_UNIT +
+    ' l ' + 4 * Blockly.BlockSvg.GRID_UNIT + ',' + 4 * Blockly.BlockSvg.GRID_UNIT +
+    ' l ' + -4 * Blockly.BlockSvg.GRID_UNIT + ',' + 4 * Blockly.BlockSvg.GRID_UNIT +
+    ' h ' + -4 * Blockly.BlockSvg.GRID_UNIT +
+    ' l ' + -4 * Blockly.BlockSvg.GRID_UNIT + ',' + -4 * Blockly.BlockSvg.GRID_UNIT +
+    ' l ' + 4 * Blockly.BlockSvg.GRID_UNIT + ',' + -4 * Blockly.BlockSvg.GRID_UNIT +
+    ' z';
+
+/**
+ * Width of empty boolean input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_HEXAGONAL_WIDTH = 12 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * SVG path for an empty square input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_SQUARE =
+    Blockly.BlockSvg.TOP_LEFT_CORNER_START +
+    Blockly.BlockSvg.TOP_LEFT_CORNER +
+    ' h ' + (12 * Blockly.BlockSvg.GRID_UNIT - 2 * Blockly.BlockSvg.CORNER_RADIUS) +
+    Blockly.BlockSvg.TOP_RIGHT_CORNER +
+    ' v ' + (8 * Blockly.BlockSvg.GRID_UNIT - 2 * Blockly.BlockSvg.CORNER_RADIUS) +
+    Blockly.BlockSvg.BOTTOM_RIGHT_CORNER +
+    ' h ' + (-12 * Blockly.BlockSvg.GRID_UNIT + 2 * Blockly.BlockSvg.CORNER_RADIUS) +
+    Blockly.BlockSvg.BOTTOM_LEFT_CORNER +
+    ' z';
+
+/**
+ * Width of empty square input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_SQUARE_WIDTH = 12 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * SVG path for an empty round input shape.
+ * @const
+ */
+
+Blockly.BlockSvg.INPUT_SHAPE_ROUND =
+  'M ' + (4 * Blockly.BlockSvg.GRID_UNIT) + ',0' +
+  ' h ' + (4 * Blockly.BlockSvg.GRID_UNIT) +
+  ' a ' + (4 * Blockly.BlockSvg.GRID_UNIT) + ' ' +
+      (4 * Blockly.BlockSvg.GRID_UNIT) + ' 0 0 1 0 ' + (8 * Blockly.BlockSvg.GRID_UNIT) +
+  ' h ' + (-4 * Blockly.BlockSvg.GRID_UNIT) +
+  ' a ' + (4 * Blockly.BlockSvg.GRID_UNIT) + ' ' +
+      (4 * Blockly.BlockSvg.GRID_UNIT) + ' 0 0 1 0 -' + (8 * Blockly.BlockSvg.GRID_UNIT) +
+  ' z';
+
+/**
+ * Width of empty round input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_ROUND_WIDTH = 12 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Height of empty input shape.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_SHAPE_HEIGHT = 8 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Height of user inputs
+ * @const
+ */
+Blockly.BlockSvg.FIELD_HEIGHT = 8 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Width of user inputs
+ * @const
+ */
+Blockly.BlockSvg.FIELD_WIDTH = 6 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Editable field padding (left/right of the text).
+ * @const
+ */
+Blockly.BlockSvg.EDITABLE_FIELD_PADDING = 6;
+
+/**
+ * Square box field padding (left/right of the text).
+ * @const
+ */
+Blockly.BlockSvg.BOX_FIELD_PADDING = 2 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Drop-down arrow padding.
+ * @const
+ */
+Blockly.BlockSvg.DROPDOWN_ARROW_PADDING = 2 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Minimum width of user inputs during editing
+ * @const
+ */
+Blockly.BlockSvg.FIELD_WIDTH_MIN_EDIT = 8 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Maximum width of user inputs during editing
+ * @const
+ */
+Blockly.BlockSvg.FIELD_WIDTH_MAX_EDIT = Infinity;
+
+/**
+ * Maximum height of user inputs during editing
+ * @const
+ */
+Blockly.BlockSvg.FIELD_HEIGHT_MAX_EDIT = Blockly.BlockSvg.FIELD_HEIGHT;
+
+/**
+ * Top padding of user inputs
+ * @const
+ */
+Blockly.BlockSvg.FIELD_TOP_PADDING = 0.5 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Corner radius of number inputs
+ * @const
+ */
+Blockly.BlockSvg.NUMBER_FIELD_CORNER_RADIUS = 4 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Corner radius of text inputs
+ * @const
+ */
+Blockly.BlockSvg.TEXT_FIELD_CORNER_RADIUS = 1 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Default radius for a field, in px.
+ * @const
+ */
+Blockly.BlockSvg.FIELD_DEFAULT_CORNER_RADIUS = 4 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Max text display length for a field (per-horizontal/vertical)
+ * @const
+ */
+Blockly.BlockSvg.MAX_DISPLAY_LENGTH = Infinity;
+
+/**
+ * Minimum X of inputs and fields for blocks with a previous connection.
+ * Ensures that inputs will not overlap with the top notch of blocks.
+ * @const
+ */
+Blockly.BlockSvg.INPUT_AND_FIELD_MIN_X = 12 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Vertical padding around inline elements.
+ * @const
+ */
+Blockly.BlockSvg.INLINE_PADDING_Y = 1 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Point size of text field before animation. Must match size in CSS.
+ * See implementation in field_textinput.
+ */
+Blockly.BlockSvg.FIELD_TEXTINPUT_FONTSIZE_INITIAL = 12;
+
+/**
+ * Point size of text field after animation.
+ * See implementation in field_textinput.
+ */
+Blockly.BlockSvg.FIELD_TEXTINPUT_FONTSIZE_FINAL = 12;
+
+/**
+ * Whether text fields are allowed to expand past their truncated block size.
+ * @const{boolean}
+ */
+Blockly.BlockSvg.FIELD_TEXTINPUT_EXPAND_PAST_TRUNCATION = false;
+
+/**
+ * Whether text fields should animate their positioning.
+ * @const{boolean}
+ */
+Blockly.BlockSvg.FIELD_TEXTINPUT_ANIMATE_POSITIONING = false;
+
+/**
+ * Map of output/input shapes and the amount they should cause a block to be padded.
+ * Outer key is the outer shape, inner key is the inner shape.
+ * When a block with the outer shape contains an input block with the inner shape
+ * on its left or right edge, that side is extended by the padding specified.
+ * See also: `Blockly.BlockSvg.computeOutputPadding_`.
+ */
+Blockly.BlockSvg.SHAPE_IN_SHAPE_PADDING = {
+  1 : { // Outer shape: hexagon.
+    0 : 5 * Blockly.BlockSvg.GRID_UNIT, // Field in hexagon.
+    1 : 2 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in hexagon.
+    2 : 5 * Blockly.BlockSvg.GRID_UNIT, // Round in hexagon.
+    3 : 5 * Blockly.BlockSvg.GRID_UNIT, // Square in hexagon.
+    4 : 5 * Blockly.BlockSvg.GRID_UNIT, // Leaf in hexagon.
+    5 : 3 * Blockly.BlockSvg.GRID_UNIT, // Plus in hexagon.
+    6 : 2 * Blockly.BlockSvg.GRID_UNIT, // Octagon in hexagon.
+    7 : 5 * Blockly.BlockSvg.GRID_UNIT, // Bumped in hexagon.
+    8 : 2 * Blockly.BlockSvg.GRID_UNIT, // Indented in hexagon.
+    9 : 2 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in hexagon.
+    10: 2 * Blockly.BlockSvg.GRID_UNIT, // Arrow in hexagon.
+    11: 5 * Blockly.BlockSvg.GRID_UNIT, // Ticket in hexagon.
+  },
+  2 : { // Outer shape: round.
+    0 : 3 * Blockly.BlockSvg.GRID_UNIT, // Field in round.
+    1 : 3 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in round.
+    2 : 1 * Blockly.BlockSvg.GRID_UNIT, // Round in round.
+    3 : 3 * Blockly.BlockSvg.GRID_UNIT, // Square in round.
+    4 : 3 * Blockly.BlockSvg.GRID_UNIT, // Leaf in round.
+    5 : 2 * Blockly.BlockSvg.GRID_UNIT, // Plus in round.
+    6 : 0 * Blockly.BlockSvg.GRID_UNIT, // Octagon in round.
+    7 : 1 * Blockly.BlockSvg.GRID_UNIT, // Bumped in round.
+    8 : 3 * Blockly.BlockSvg.GRID_UNIT, // Indented in round.
+    9 : 3 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in round.
+    10: 3 * Blockly.BlockSvg.GRID_UNIT, // Arrow in round.
+    11: 3 * Blockly.BlockSvg.GRID_UNIT, // Ticket in round.
+  },
+  3 : { // Outer shape: square.
+    0 : 2 * Blockly.BlockSvg.GRID_UNIT, // Field in square.
+    1 : 2 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in square.
+    2 : 2 * Blockly.BlockSvg.GRID_UNIT, // Round in square.
+    3 : 2 * Blockly.BlockSvg.GRID_UNIT, // Square in square.
+    4 : 2 * Blockly.BlockSvg.GRID_UNIT, // Leaf in square.
+    5 : 2 * Blockly.BlockSvg.GRID_UNIT, // Plus in square.
+    6 : 2 * Blockly.BlockSvg.GRID_UNIT, // Octagon in square.
+    7 : 2 * Blockly.BlockSvg.GRID_UNIT, // Bumped in square.
+    8 : 2 * Blockly.BlockSvg.GRID_UNIT, // Indented in square.
+    9 : 2 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in square.
+    10: 2 * Blockly.BlockSvg.GRID_UNIT, // Arrow in square.
+    11: 2 * Blockly.BlockSvg.GRID_UNIT, // Ticket in square.
+  },
+  4 : { // Outer shape: leaf.
+    0 : 3 * Blockly.BlockSvg.GRID_UNIT, // Field in leaf.
+    1 : 3 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in leaf.
+    2 : 2 * Blockly.BlockSvg.GRID_UNIT, // Round in leaf.
+    3 : 2 * Blockly.BlockSvg.GRID_UNIT, // Square in leaf.
+    4 : 1 * Blockly.BlockSvg.GRID_UNIT, // Leaf in leaf.
+    5 : 2 * Blockly.BlockSvg.GRID_UNIT, // Plus in leaf.
+    6 : 2 * Blockly.BlockSvg.GRID_UNIT, // Octagon in leaf.
+    7 : 2 * Blockly.BlockSvg.GRID_UNIT, // Bumped in leaf.
+    8 : 3 * Blockly.BlockSvg.GRID_UNIT, // Indented in leaf.
+    9 : 3 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in leaf.
+    10: 3 * Blockly.BlockSvg.GRID_UNIT, // Arrow in leaf.
+    11: 2 * Blockly.BlockSvg.GRID_UNIT, // Ticket in leaf.
+  },
+  5 : { // Outer shape: plus.
+    0 : 5 * Blockly.BlockSvg.GRID_UNIT, // Field in plus.
+    1 : 4 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in plus.
+    2 : 4 * Blockly.BlockSvg.GRID_UNIT, // Round in plus.
+    3 : 5 * Blockly.BlockSvg.GRID_UNIT, // Square in plus.
+    4 : 5 * Blockly.BlockSvg.GRID_UNIT, // Leaf in plus.
+    5 : 3 * Blockly.BlockSvg.GRID_UNIT, // Plus in plus.
+    6 : 4 * Blockly.BlockSvg.GRID_UNIT, // Octagon in plus.
+    7 : 4 * Blockly.BlockSvg.GRID_UNIT, // Bumped in plus.
+    8 : 4 * Blockly.BlockSvg.GRID_UNIT, // Indented in plus.
+    9 : 4 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in plus.
+    10: 4 * Blockly.BlockSvg.GRID_UNIT, // Arrow in plus.
+    11: 5 * Blockly.BlockSvg.GRID_UNIT, // Ticket in plus.
+  },
+  6 : { // Outer shape: octagon.
+    0 : 5 * Blockly.BlockSvg.GRID_UNIT, // Field in octagon.
+    1 : 2 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in octagon.
+    2 : 5 * Blockly.BlockSvg.GRID_UNIT, // Round in octagon.
+    3 : 5 * Blockly.BlockSvg.GRID_UNIT, // Square in octagon.
+    4 : 5 * Blockly.BlockSvg.GRID_UNIT, // Leaf in octagon.
+    5 : 3 * Blockly.BlockSvg.GRID_UNIT, // Plus in octagon.
+    6 : 2 * Blockly.BlockSvg.GRID_UNIT, // Octagon in octagon.
+    7 : 5 * Blockly.BlockSvg.GRID_UNIT, // Bumped in octagon.
+    8 : 2 * Blockly.BlockSvg.GRID_UNIT, // Indented in octagon.
+    9 : 2 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in octagon.
+    10: 2 * Blockly.BlockSvg.GRID_UNIT, // Arrow in octagon.
+    11: 5 * Blockly.BlockSvg.GRID_UNIT, // Ticket in octagon.
+  },
+  7 : { // Outer shape: bumped.
+    0 : 3 * Blockly.BlockSvg.GRID_UNIT, // Field in bumped.
+    1 : 3 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in bumped.
+    2 : 1 * Blockly.BlockSvg.GRID_UNIT, // Round in bumped.
+    3 : 3 * Blockly.BlockSvg.GRID_UNIT, // Square in bumped.
+    4 : 3 * Blockly.BlockSvg.GRID_UNIT, // Leaf in bumped.
+    5 : 2 * Blockly.BlockSvg.GRID_UNIT, // Plus in bumped.
+    6 : 0 * Blockly.BlockSvg.GRID_UNIT, // Octagon in bumped.
+    7 : 1 * Blockly.BlockSvg.GRID_UNIT, // Bumped in bumped.
+    8 : 3 * Blockly.BlockSvg.GRID_UNIT, // Indented in bumped.
+    9 : 3 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in bumped.
+    10: 3 * Blockly.BlockSvg.GRID_UNIT, // Arrow in bumped.
+    11: 3 * Blockly.BlockSvg.GRID_UNIT, // Ticket in bumped.
+  },
+  8 : { // Outer shape: indented.
+    0 : 5 * Blockly.BlockSvg.GRID_UNIT, // Field in indented.
+    1 : 2 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in indented.
+    2 : 5 * Blockly.BlockSvg.GRID_UNIT, // Round in indented.
+    3 : 5 * Blockly.BlockSvg.GRID_UNIT, // Square in indented.
+    4 : 5 * Blockly.BlockSvg.GRID_UNIT, // Leaf in indented.
+    5 : 3 * Blockly.BlockSvg.GRID_UNIT, // Plus in indented.
+    6 : 2 * Blockly.BlockSvg.GRID_UNIT, // Octagon in indented.
+    7 : 5 * Blockly.BlockSvg.GRID_UNIT, // Bumped in indented.
+    8 : 2 * Blockly.BlockSvg.GRID_UNIT, // Indented in indented.
+    9 : 2 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in indented.
+    10: 2 * Blockly.BlockSvg.GRID_UNIT, // Arrow in indented.
+    11: 5 * Blockly.BlockSvg.GRID_UNIT, // Ticket in indented.
+  },
+  9 : { // Outer shape: scrapped.
+    0 : 5 * Blockly.BlockSvg.GRID_UNIT, // Field in scrapped.
+    1 : 2 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in scrapped.
+    2 : 5 * Blockly.BlockSvg.GRID_UNIT, // Round in scrapped.
+    3 : 5 * Blockly.BlockSvg.GRID_UNIT, // Square in scrapped.
+    4 : 5 * Blockly.BlockSvg.GRID_UNIT, // Leaf in scrapped.
+    5 : 3 * Blockly.BlockSvg.GRID_UNIT, // Plus in scrapped.
+    6 : 2 * Blockly.BlockSvg.GRID_UNIT, // Octagon in scrapped.
+    7 : 5 * Blockly.BlockSvg.GRID_UNIT, // Bumped in scrapped.
+    8 : 2 * Blockly.BlockSvg.GRID_UNIT, // Indented in scrapped.
+    9 : 2 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in scrapped.
+    10: 2 * Blockly.BlockSvg.GRID_UNIT, // Arrow in scrapped.
+    11: 5 * Blockly.BlockSvg.GRID_UNIT, // Ticket in scrapped.
+  },
+  10: { // Outer shape: arrow.
+    0 : 5 * Blockly.BlockSvg.GRID_UNIT, // Field in arrow.
+    1 : 2 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in arrow.
+    2 : 5 * Blockly.BlockSvg.GRID_UNIT, // Round in arrow.
+    3 : 5 * Blockly.BlockSvg.GRID_UNIT, // Square in arrow.
+    4 : 5 * Blockly.BlockSvg.GRID_UNIT, // Leaf in arrow.
+    5 : 3 * Blockly.BlockSvg.GRID_UNIT, // Plus in arrow.
+    6 : 2 * Blockly.BlockSvg.GRID_UNIT, // Octagon in arrow.
+    7 : 5 * Blockly.BlockSvg.GRID_UNIT, // Bumped in arrow.
+    8 : 2 * Blockly.BlockSvg.GRID_UNIT, // Indented in arrow.
+    9 : 2 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in arrow.
+    10: 2 * Blockly.BlockSvg.GRID_UNIT, // Arrow in arrow.
+    11: 5 * Blockly.BlockSvg.GRID_UNIT, // Ticket in arrow.
+  },
+  11: { // Outer shape: ticket.
+    0 : 6 * Blockly.BlockSvg.GRID_UNIT, // Field in ticket.
+    1 : 6 * Blockly.BlockSvg.GRID_UNIT, // Hexagon in ticket.
+    2 : 6 * Blockly.BlockSvg.GRID_UNIT, // Round in ticket.
+    3 : 6 * Blockly.BlockSvg.GRID_UNIT, // Square in ticket.
+    4 : 6 * Blockly.BlockSvg.GRID_UNIT, // Leaf in ticket.
+    5 : 6 * Blockly.BlockSvg.GRID_UNIT, // Plus in ticket.
+    6 : 6 * Blockly.BlockSvg.GRID_UNIT, // Octagon in ticket.
+    7 : 6 * Blockly.BlockSvg.GRID_UNIT, // Bumped in ticket.
+    8 : 6 * Blockly.BlockSvg.GRID_UNIT, // Indented in ticket.
+    9 : 6 * Blockly.BlockSvg.GRID_UNIT, // Scrapped in ticket.
+    10: 6 * Blockly.BlockSvg.GRID_UNIT, // Arrow in ticket.
+    11: 6 * Blockly.BlockSvg.GRID_UNIT, // Ticket in ticket.
+  },
+};
+
+/**
+ * Default shape padding used by custom shapes if not set
+ * @const
+ */
+Blockly.BlockSvg.DEFAULT_SHAPE_PADDING = Blockly.BlockSvg.GRID_UNIT * 5;
+  
+/**
+ * Corner radius of the hat on the define block.
+ * @const
+ */
+Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS = 5 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * SVG path for drawing the rounded top-left corner.
+ * @const
+ */
+Blockly.BlockSvg.TOP_LEFT_CORNER_DEFINE_HAT =
+    'a ' + Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS + ' 0 0,1 ' +
+    Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS + ',-' +
+    Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS;
+
+/**
+ * SVG path for drawing the rounded top-left corner.
+ * @const
+ */
+Blockly.BlockSvg.TOP_RIGHT_CORNER_DEFINE_HAT =
+    'a ' + Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS + ' 0 0,1 ' +
+    Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS + ',' +
+    Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS;
+
+/**
+ * Padding on the right side of the internal block on the define block.
+ * @const
+ */
+Blockly.BlockSvg.DEFINE_BLOCK_PADDING_RIGHT = 2 * Blockly.BlockSvg.GRID_UNIT;
+
+/**
+ * Change the colour of a block.
+ */
+Blockly.BlockSvg.prototype.updateColour = function() {
+  var strokeColour = this.getColourTertiary();
+  var renderShadowed = this.isShadow() &&
+      !Blockly.scratchBlocksUtils.isShadowArgumentReporter(this);
+
+  if (renderShadowed && this.parentBlock_) {
+    // Pull shadow block stroke colour from parent block's tertiary if possible.
+    strokeColour = this.parentBlock_.getColourTertiary();
+    // Special case: if we contain a colour field, set to a special stroke colour.
+    if (this.inputList[0] &&
+        this.inputList[0].fieldRow[0] &&
+        (this.inputList[0].fieldRow[0] instanceof Blockly.FieldColour ||
+        this.inputList[0].fieldRow[0] instanceof Blockly.FieldColourSlider)) {
+      strokeColour = Blockly.Colours.colourPickerStroke;
+    }
+  }
+
+  // Render block stroke
+  this.svgPath_.setAttribute('stroke', strokeColour);
+
+  // Render block fill
+  if (this.isGlowingBlock_ || renderShadowed) {
+    // Use the block's shadow colour if possible.
+    if (this.getShadowColour()) {
+      var fillColour = this.getShadowColour();
+    } else {
+      //if reporter and only contain menu field, set color to parent
+      if (
+        renderShadowed &&
+        this.parentBlock_ &&
+        this.outputConnection &&
+        this.inputList.length == 1 &&
+        this.inputList[0].fieldRow.length == 1 &&
+        this.inputList[0].fieldRow[0] instanceof Blockly.FieldDropdown
+      ) {
+        var fillColour = this.parentBlock_.getColourSecondary();
+      } else {
+        var fillColour = this.getColourSecondary();
+      }
+    }
+  } else {
+    var fillColour = this.getColour();
+  }
+  this.svgPath_.setAttribute('fill', fillColour);
+
+  // Render opacity
+  this.svgPath_.setAttribute('fill-opacity', this.getOpacity());
+
+  // Update colours of input shapes.
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.outlinePath) {
+      input.outlinePath.setAttribute('fill', this.getColourTertiary());
+    }
+  }
+
+  // Render icon(s) if applicable
+  var icons = this.getIcons();
+  for (var i = 0; i < icons.length; i++) {
+    icons[i].updateColour();
+  }
+
+  // Bump every dropdown to change its colour.
+  for (var x = 0, input; input = this.inputList[x]; x++) {
+    for (var y = 0, field; field = input.fieldRow[y]; y++) {
+      field.setText(null);
+    }
+  }
+};
+
+/**
+ * Visual effect to show that if the dragging block is dropped, this block will
+ * be replaced.  If a shadow block it will disappear.  Otherwise it will bump.
+ * @param {boolean} add True if highlighting should be added.
+ */
+Blockly.BlockSvg.prototype.highlightForReplacement = function(add) {
+  if (add) {
+    var replacementGlowFilterId = this.workspace.options.replacementGlowFilterId
+      || 'blocklyReplacementGlowFilter';
+    this.svgPath_.setAttribute('filter', 'url(#' + replacementGlowFilterId + ')');
+    Blockly.utils.addClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyReplaceable');
+  } else {
+    this.svgPath_.removeAttribute('filter');
+    Blockly.utils.removeClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyReplaceable');
+  }
+};
+
+/**
+ * Visual effect to show that if the dragging block is dropped it will connect
+ * to this input.
+ * @param {Blockly.Connection} conn The connection on the input to highlight.
+ * @param {boolean} add True if highlighting should be added.
+ */
+Blockly.BlockSvg.prototype.highlightShapeForInput = function(conn, add) {
+  var input = this.getInputWithConnection(conn);
+  if (!input) {
+    throw 'No input found for the connection';
+  }
+  if (!input.outlinePath) {
+    return;
+  }
+  if (add) {
+    var replacementGlowFilterId = this.workspace.options.replacementGlowFilterId
+      || 'blocklyReplacementGlowFilter';
+    input.outlinePath.setAttribute('filter',
+        'url(#' + replacementGlowFilterId + ')');
+    Blockly.utils.addClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyReplaceable');
+  } else {
+    input.outlinePath.removeAttribute('filter');
+    Blockly.utils.removeClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyReplaceable');
+  }
+};
+
+/**
+ * Returns a bounding box describing the dimensions of this block
+ * and any blocks stacked below it.
+ * @return {!{height: number, width: number}} Object with height and width properties.
+ */
+Blockly.BlockSvg.prototype.getHeightWidth = function() {
+  var height = this.height;
+  var width = this.width;
+  // Recursively add size of subsequent blocks.
+  var nextBlock = this.getNextBlock();
+  if (nextBlock) {
+    var nextHeightWidth = nextBlock.getHeightWidth();
+    height += nextHeightWidth.height;
+    height -= Blockly.BlockSvg.NOTCH_HEIGHT; // Exclude height of connected notch.
+    width = Math.max(width, nextHeightWidth.width);
+  }
+  return {height: height, width: width};
+};
+
+/**
+ * Render the block.
+ * Lays out and reflows a block based on its contents and settings.
+ * @param {boolean=} opt_bubble If false, just render this block.
+ *   If true, also render block's parent, grandparent, etc.  Defaults to true.
+ */
+Blockly.BlockSvg.prototype.render = function(opt_bubble) {
+  Blockly.Field.startCache();
+  this.rendered = true;
+
+  var cursorX = Blockly.BlockSvg.SEP_SPACE_X;
+  if (this.RTL) {
+    cursorX = -cursorX;
+  }
+  // Move the icons into position.
+  var icons = this.getIcons();
+  var scratchCommentIcon = null;
+  for (var i = 0; i < icons.length; i++) {
+    if (icons[i] instanceof Blockly.ScratchBlockComment) {
+      // Don't render scratch block comment icon until
+      // after the inputs
+      scratchCommentIcon = icons[i];
+    } else {
+      cursorX = icons[i].renderIcon(cursorX);
+    }
+  }
+  cursorX += this.RTL ?
+      Blockly.BlockSvg.SEP_SPACE_X : -Blockly.BlockSvg.SEP_SPACE_X;
+  // If there are no icons, cursorX will be 0, otherwise it will be the
+  // width that the first label needs to move over by.
+
+  // If this is an extension reporter block, add a horizontal offset.
+  if (this.isScratchExtension && this.outputConnection) {
+    cursorX += this.RTL ?
+      -Blockly.BlockSvg.GRID_UNIT : Blockly.BlockSvg.GRID_UNIT;
+  }
+
+  var inputRows = this.renderCompute_(cursorX);
+  this.renderDraw_(cursorX, inputRows);
+  this.renderMoveConnections_();
+
+  this.renderClassify_();
+
+  // Position the Scratch Block Comment Icon at the end of the block
+  if (scratchCommentIcon) {
+    var iconX = this.RTL ? -inputRows.rightEdge : inputRows.rightEdge;
+    var inputMarginY = inputRows[0].height / 2;
+    scratchCommentIcon.renderIcon(iconX, inputMarginY);
+  }
+
+  if (opt_bubble !== false) {
+    // Render all blocks above this one (propagate a reflow).
+    var parentBlock = this.getParent();
+    if (parentBlock) {
+      parentBlock.render(true);
+    } else {
+      // Top-most block.  Fire an event to allow scrollbars to resize.
+      Blockly.resizeSvgContents(this.workspace);
+    }
+  }
+  Blockly.Field.stopCache();
+
+  this.updateIntersectionObserver();
+};
+
+/**
+ * Render a list of fields starting at the specified location.
+ * @param {!Array.<!Blockly.Field>} fieldList List of fields.
+ * @param {number} cursorX X-coordinate to start the fields.
+ * @param {number} cursorY Y-coordinate around which fields are centered.
+ * @return {number} X-coordinate of the end of the field row (plus a gap).
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderFields_ = function(fieldList, cursorX,
+    cursorY) {
+  if (this.edgeShapeWidth_ && this.inputList.find(v => v.type == Blockly.NEXT_STATEMENT)) cursorX += this.edgeShapeWidth_ + Blockly.BlockSvg.CORNER_RADIUS * 2
+  if (this.RTL) {
+    cursorX = -cursorX;
+  }
+  for (var t = 0, field; field = fieldList[t]; t++) {
+    var root = field.getSvgRoot();
+    if (!root) {
+      continue;
+    }
+    // In blocks with a notch, fields should be bumped to a min X,
+    // to avoid overlapping with the notch. Label and image fields are
+    // excluded.
+    if (this.previousConnection && !(field instanceof Blockly.FieldLabel) &&
+        !(field instanceof Blockly.FieldImage)) {
+      cursorX = this.RTL ?
+        Math.min(cursorX, -Blockly.BlockSvg.INPUT_AND_FIELD_MIN_X) :
+        Math.max(cursorX, Blockly.BlockSvg.INPUT_AND_FIELD_MIN_X);
+    }
+    // Offset the field upward by half its height.
+    // This vertically centers the fields around cursorY.
+    var yOffset = -field.getSize().height / 2;
+
+    // If this is an extension block, and this field is the first field, and
+    // it is an image field, and this block has a previous connection, bump
+    // the image down by one grid unit to align it vertically.
+    if (this.isScratchExtension && (field === this.inputList[0].fieldRow[0])
+        && (field instanceof Blockly.FieldImage) && this.previousConnection) {
+      yOffset += Blockly.BlockSvg.GRID_UNIT;
+    }
+
+    // If this is an extension hat block, adjust the height of the vertical
+    // separator without adjusting the field height. The effect is to move
+    // the bottom end of the line up one grid unit.
+    if (this.isScratchExtension &&
+        !this.previousConnection && this.nextConnection &&
+        field instanceof Blockly.FieldVerticalSeparator) {
+      field.setLineHeight(Blockly.BlockSvg.ICON_SEPARATOR_HEIGHT -
+          Blockly.BlockSvg.GRID_UNIT);
+    }
+
+    var translateX, translateY;
+    var scale = '';
+    if (this.RTL) {
+      cursorX -= field.renderSep + field.renderWidth;
+      translateX = cursorX;
+      translateY = cursorY + yOffset;
+      if (field.renderWidth) {
+        cursorX -= Blockly.BlockSvg.SEP_SPACE_X;
+      }
+    } else {
+      translateX = cursorX + field.renderSep;
+      translateY = cursorY + yOffset;
+      if (field.renderWidth) {
+        cursorX += field.renderSep + field.renderWidth +
+            Blockly.BlockSvg.SEP_SPACE_X;
+      }
+    }
+    if (this.RTL &&
+        field instanceof Blockly.FieldImage &&
+        field.getFlipRTL()) {
+      scale = 'scale(-1 1)';
+      translateX += field.renderWidth;
+    }
+    root.setAttribute('transform',
+        'translate(' + translateX + ', ' + translateY + ') ' + scale);
+
+    // Fields are invisible on insertion marker.
+    if (this.isInsertionMarker()) {
+      root.setAttribute('display', 'none');
+    }
+  }
+  return this.RTL ? -cursorX : cursorX;
+};
+
+/**
+ * Computes the height and widths for each row and field.
+ * @param {number} iconWidth Offset of first row due to icons.
+ * @return {!Array.<!Array.<!Object>>} 2D array of objects, each containing
+ *     position information.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderCompute_ = function(iconWidth) {
+  var inputList = this.inputList;
+  var inputRows = [];
+  // Block will be drawn from 0 (left edge) to rightEdge, in px.
+  inputRows.rightEdge = 0;
+  // Drawn from 0 to bottomEdge vertically.
+  inputRows.bottomEdge = 0;
+  var fieldValueWidth = 0;  // Width of longest external value field.
+  var fieldStatementWidth = 0;  // Width of longest statement field.
+  var hasValue = false;
+  var hasStatement = false;
+  var hasDummy = false;
+  var lastType = undefined;
+
+  // Previously created row, for special-casing row heights on C- and E- shaped blocks.
+  var previousRow;
+  for (var i = 0, input; input = inputList[i]; i++) {
+    if (!input.isVisible()) {
+      continue;
+    }
+    var isSecondInputOnProcedure = (this.type == 'procedures_definition' ||
+        this.type == 'procedures_definition_return') &&
+        lastType && lastType == Blockly.NEXT_STATEMENT;
+    var row;
+    // Don't create a new row for the second dummy input on a procedure block.
+    // See github.com/LLK/scratch-blocks/issues/1658
+    // In all other cases, statement and value inputs catch all preceding dummy
+    // inputs, and cause a line break before following inputs.
+    if (!isSecondInputOnProcedure &&
+        (!lastType || lastType == Blockly.NEXT_STATEMENT ||
+        input.type == Blockly.NEXT_STATEMENT)) {
+      lastType = input.type;
+      row = this.createRowForInput_(input);
+      inputRows.push(row);
+    } else {
+      row = inputRows[inputRows.length - 1];
+    }
+    row.push(input);
+
+    // Compute minimum dimensions for this input.
+    input.renderHeight = this.computeInputHeight_(input, row, previousRow);
+    input.renderWidth = this.computeInputWidth_(input);
+
+    // If the input is a statement input, determine if a notch
+    // should be drawn at the inner bottom of the C.
+    row.statementNotchAtBottom = true;
+    if (input.connection && input.connection.type === Blockly.NEXT_STATEMENT) {
+      var linkedBlock = input.connection.targetBlock();
+      if (linkedBlock && !linkedBlock.lastConnectionInStack()) {
+        row.statementNotchAtBottom = false;
+      }
+    }
+
+    // Expand input size.
+    if (input.connection) {
+      var linkedBlock = input.connection.targetBlock();
+      var paddedHeight = 0;
+      var paddedWidth = 0;
+      if (linkedBlock) {
+        // A block is connected to the input - use its size.
+        var bBox = linkedBlock.getHeightWidth();
+        paddedHeight = bBox.height;
+        paddedWidth = bBox.width;
+      } else {
+        // No block connected - use the size of the rendered empty input shape.
+        paddedHeight = Blockly.BlockSvg.INPUT_SHAPE_HEIGHT;
+      }
+      if (input.connection.type === Blockly.INPUT_VALUE) {
+        paddedHeight += 2 * Blockly.BlockSvg.INLINE_PADDING_Y;
+      }
+      if (input.connection.type === Blockly.NEXT_STATEMENT) {
+        // Subtract height of notch, only if the last block in the stack has a next connection.
+        if (row.statementNotchAtBottom) {
+          paddedHeight -= Blockly.BlockSvg.NOTCH_HEIGHT;
+        }
+      }
+      input.renderHeight = Math.max(input.renderHeight, paddedHeight);
+      input.renderWidth = Math.max(input.renderWidth, paddedWidth);
+    }
+    row.height = Math.max(row.height, input.renderHeight);
+    input.fieldWidth = 0;
+    if (inputRows.length == 1) {
+      // The first row gets shifted to accommodate any icons.
+      input.fieldWidth += this.RTL ? -iconWidth : iconWidth;
+    }
+    var previousFieldEditable = false;
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      if (j != 0) {
+        input.fieldWidth += Blockly.BlockSvg.SEP_SPACE_X;
+      }
+      // Get the dimensions of the field.
+      var fieldSize = field.getSize();
+      field.renderWidth = fieldSize.width;
+      field.renderSep = (previousFieldEditable && field.EDITABLE) ?
+          Blockly.BlockSvg.SEP_SPACE_X : 0;
+      // See github.com/LLK/scratch-blocks/issues/1658
+      if (!isSecondInputOnProcedure) {
+        input.fieldWidth += field.renderWidth + field.renderSep;
+      }
+      row.height = Math.max(row.height, fieldSize.height);
+      previousFieldEditable = field.EDITABLE;
+    }
+
+    if (row.type != Blockly.BlockSvg.INLINE) {
+      if (row.type == Blockly.NEXT_STATEMENT) {
+        hasStatement = true;
+        fieldStatementWidth = Math.max(fieldStatementWidth, input.fieldWidth);
+      } else {
+        if (row.type == Blockly.INPUT_VALUE) {
+          hasValue = true;
+        } else if (row.type == Blockly.DUMMY_INPUT) {
+          hasDummy = true;
+        }
+        fieldValueWidth = Math.max(fieldValueWidth, input.fieldWidth);
+      }
+    }
+    previousRow = row;
+  }
+
+  // fix incorrect width calculations for mega-chin blocks
+  // ie, C- or E- shaped blocks with labels and/or inputs on the end branch
+  if (hasStatement) {
+    // the mega-chin block issue only happens to blocks with images
+    const input = inputList[inputList.length - 1];
+    const field = input.fieldRow[0];
+    if (field instanceof Blockly.FieldImage) {
+      // check for inputs before the last branch
+      const measureables = [];
+      for (var i = inputList.length - 1; i--; ) {
+        if (inputList[i].type == Blockly.NEXT_STATEMENT) break;
+        measureables.push(inputList[i]);
+      }
+
+      if (measureables.length) {
+        const newWidth = measureables.reduce((w, input) => w + (input.fieldWidth), 0);
+        input.fieldWidth = newWidth * (Blockly.BlockSvg.BOX_FIELD_PADDING / 4);
+      }
+    }
+  }
+
+  // Compute padding for output blocks.
+  // Data is attached to the row.
+  this.computeOutputPadding_(inputRows);
+  // Compute the statement edge.
+  // This is the width of a block where statements are nested.
+  inputRows.statementEdge = Blockly.BlockSvg.STATEMENT_INPUT_EDGE_WIDTH +
+      fieldStatementWidth;
+
+  // Compute the preferred right edge.
+  inputRows.rightEdge = this.computeRightEdge_(inputRows.rightEdge,
+      hasStatement);
+
+  // Bottom edge is sum of row heights
+  for (var i = 0; i < inputRows.length; i++) {
+    inputRows.bottomEdge += inputRows[i].height;
+  }
+
+  inputRows.hasValue = hasValue;
+  inputRows.hasStatement = hasStatement;
+  inputRows.hasDummy = hasDummy;
+  return inputRows;
+};
+
+/**
+ * Compute the minimum width of this input based on the connection type and
+ * outputs.
+ * @param {!Blockly.Input} input The input to measure.
+ * @return {number} the computed width of this input.
+ * @private
+ */
+Blockly.BlockSvg.prototype.computeInputWidth_ = function(input) {
+  // Empty input shape widths.
+  if (input.type == Blockly.INPUT_VALUE &&
+      (!input.connection || !input.connection.isConnected())) {
+    const shape = input.connection.getOutputShape();
+    switch (shape) {
+      case Blockly.OUTPUT_SHAPE_SQUARE:
+        return Blockly.BlockSvg.INPUT_SHAPE_SQUARE_WIDTH;
+      case Blockly.OUTPUT_SHAPE_ROUND:
+        return Blockly.BlockSvg.INPUT_SHAPE_ROUND_WIDTH;
+      case Blockly.OUTPUT_SHAPE_HEXAGONAL:
+        return Blockly.BlockSvg.INPUT_SHAPE_HEXAGONAL_WIDTH;
+      case Blockly.OUTPUT_SHAPE_LEAF:
+        return Blockly.BlockSvg.INPUT_SHAPE_LEAF_WIDTH;
+      case Blockly.OUTPUT_SHAPE_PLUS:
+        return Blockly.BlockSvg.INPUT_SHAPE_PLUS_WIDTH;
+      default: {
+        const customShape = Blockly.BlockSvg.CUSTOM_SHAPES.get(shape);
+        if (customShape) return customShape.emptyInputWidth;
+        return 0;
+      }
+    }
+  } else {
+    return 0;
+  }
+};
+
+/**
+ * Compute the minimum height of this input.
+ * @param {!Blockly.Input} input The input to measure.
+ * @param {!Object} row The row of the block that is currently being measured.
+ * @param {!Object} previousRow The previous row of the block, which was just
+ *     measured.
+ * @return {number} the computed height of this input.
+ * @private
+ */
+Blockly.BlockSvg.prototype.computeInputHeight_ = function(input, row,
+    previousRow) {
+  if (this.inputList.length === 1 && this.outputConnection &&
+      (this.isShadow() &&
+      !Blockly.scratchBlocksUtils.isShadowArgumentReporter(this) &&
+      (this.type !== 'procedures_prototype' ||
+      this.type !== 'procedures_call')) &&
+      this.type !== 'polygon') {
+    // "Lone" field blocks are smaller.
+    return Blockly.BlockSvg.MIN_BLOCK_Y_SINGLE_FIELD_OUTPUT;
+  } else if (this.outputConnection) {
+    // If this is an extension reporter block, make it taller.
+    if (this.isScratchExtension || this.type === 'polygon') {
+      return Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER + 2 * Blockly.BlockSvg.GRID_UNIT;
+    }
+    // All other reporters.
+    return Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER;
+  } else if (row.type == Blockly.NEXT_STATEMENT) {
+    // Statement input.
+    return Blockly.BlockSvg.MIN_STATEMENT_INPUT_HEIGHT;
+  } else if (previousRow && previousRow.type == Blockly.NEXT_STATEMENT) {
+    // Extra row for below statement input.
+    return Blockly.BlockSvg.EXTRA_STATEMENT_ROW_Y;
+  } else {
+    // If this is an extension block, and it has a previous connection,
+    // make it taller.
+    if (this.isScratchExtension && this.previousConnection) {
+      return Blockly.BlockSvg.MIN_BLOCK_Y + 2 * Blockly.BlockSvg.GRID_UNIT;
+    }
+    // All other blocks.
+    return Blockly.BlockSvg.MIN_BLOCK_Y;
+  }
+};
+
+/**
+ * Create a row for an input and associated fields.
+ * @param {!Blockly.Input} input The input that the row is based on.
+ * @return {!Object} The new row, with the correct type and default sizing info.
+ */
+Blockly.BlockSvg.prototype.createRowForInput_ = function(input) {
+  // Create new row.
+  var row = [];
+  if (input.type != Blockly.NEXT_STATEMENT) {
+    row.type = Blockly.BlockSvg.INLINE;
+  } else {
+    row.type = input.type;
+  }
+  row.height = 0;
+  // Default padding for a block: same as separators between fields/inputs.
+  row.paddingStart = Blockly.BlockSvg.SEP_SPACE_X;
+  row.paddingEnd = Blockly.BlockSvg.SEP_SPACE_X;
+  return row;
+};
+
+/**
+ * Compute the preferred right edge of the block.
+ * @param {number} curEdge The previously calculated right edge.
+ * @param {boolean} hasStatement Whether this block has a statement input.
+ * @return {number} The preferred right edge of the block.
+ */
+Blockly.BlockSvg.prototype.computeRightEdge_ = function(curEdge, hasStatement) {
+  var edge = curEdge;
+  if (this.previousConnection || this.nextConnection) {
+    // Blocks with notches
+    edge = Math.max(edge, Blockly.BlockSvg.MIN_BLOCK_X);
+  } else if (this.outputConnection) {
+    if (this.isShadow() &&
+        !Blockly.scratchBlocksUtils.isShadowArgumentReporter(this)) {
+      if (this.type === 'polygon') {
+        edge = edge
+      } else {
+        // Single-fields
+        edge = Math.max(edge, Blockly.BlockSvg.MIN_BLOCK_X_SHADOW_OUTPUT);
+      }
+    } else {
+      // Reporters
+      edge = Math.max(edge, Blockly.BlockSvg.MIN_BLOCK_X_OUTPUT);
+    }
+  }
+  if (hasStatement) {
+    // Statement blocks (C- or E- shaped) have a longer minimum width.
+    edge = Math.max(edge, Blockly.BlockSvg.MIN_BLOCK_X_WITH_STATEMENT);
+  }
+
+  // Ensure insertion markers are at least insertionMarkerMinWidth_ wide.
+  if (this.insertionMarkerMinWidth_ > 0) {
+    edge = Math.max(edge, this.insertionMarkerMinWidth_);
+  }
+  return edge;
+};
+
+/**
+ * For a block with output,
+ * determine start and end padding, based on connected inputs.
+ * Padding will depend on the shape of the output, the shape of the input,
+ * and possibly the size of the input.
+ * @param {!Array.<!Array.<!Object>>} inputRows Partially calculated rows.
+ */
+Blockly.BlockSvg.prototype.computeOutputPadding_ = function(inputRows) {
+  // Only apply to blocks with outputs and not single fields (shadows).
+  if (!this.getOutputShape() || !this.outputConnection ||
+      (this.isShadow() &&
+      !Blockly.scratchBlocksUtils.isShadowArgumentReporter(this))) {
+    return;
+  }
+  // Blocks with outputs must have single row to be padded.
+  if (inputRows.length > 1) {
+    return;
+  }
+  var row = inputRows[0];
+  var shape = this.getOutputShape();
+  // Reset any padding: it's about to be set.
+  row.paddingStart = 0;
+  row.paddingEnd = 0;
+  // Start row padding: based on first input or first field.
+  var firstInput = row[0];
+  var firstField = firstInput.fieldRow[0];
+  var otherShape;
+  // In checking the left/start side, a field takes precedence over any input.
+  // That's because a field will be rendered before any value input.
+  if (firstField || !firstInput.connection) {
+    otherShape = 0; // Field comes first in the row.
+  } else {
+    // Value input comes first in the row.
+    var inputConnection = firstInput.connection;
+    if (!inputConnection.targetConnection) {
+      // Not connected: use the drawn shape.
+      otherShape = inputConnection.getOutputShape();
+    } else {
+      // Connected: use the connected block's output shape.
+      otherShape = inputConnection.targetConnection.getSourceBlock().getOutputShape();
+    }
+    // Special case for hexagonal output: if the connection is larger height
+    // than a standard reporter, add some start padding.
+    // https://github.com/LLK/scratch-blocks/issues/376
+    if (shape == Blockly.OUTPUT_SHAPE_HEXAGONAL &&
+        otherShape != Blockly.OUTPUT_SHAPE_HEXAGONAL) {
+      var deltaHeight = firstInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER;
+      // One grid unit per level of nesting.
+      row.paddingStart += deltaHeight / 2;
+    }
+  }
+  
+  const customShape = Blockly.BlockSvg.CUSTOM_SHAPES.get(shape);
+  if (customShape && customShape.blockPaddingStart) {
+    row.paddingStart += customShape.blockPaddingStart(this, otherShape, firstInput, firstField, row);
+  }
+
+  const paddingStart = (Blockly.BlockSvg.SHAPE_IN_SHAPE_PADDING[shape] || {})[otherShape];
+  row.paddingStart += paddingStart === undefined ? Blockly.BlockSvg.DEFAULT_SHAPE_PADDING : paddingStart;
+
+  // End row padding: based on last input or last field.
+  var lastInput = row[row.length - 1];
+  // In checking the right/end side, any value input takes precedence over any field.
+  // That's because fields are rendered before inputs...the last item
+  // in the row will be an input, if one exists.
+  if (lastInput.connection) {
+    // Value input last in the row.
+    var inputConnection = lastInput.connection;
+    if (!inputConnection.targetConnection) {
+      // Not connected: use the drawn shape.
+      otherShape = inputConnection.getOutputShape();
+    } else {
+      // Connected: use the connected block's output shape.
+      otherShape = inputConnection.targetConnection.getSourceBlock().getOutputShape();
+    }
+    // Special case for hexagonal output: if the connection is larger height
+    // than a standard reporter, add some end padding.
+    // https://github.com/LLK/scratch-blocks/issues/376
+    if (shape == Blockly.OUTPUT_SHAPE_HEXAGONAL &&
+        otherShape != Blockly.OUTPUT_SHAPE_HEXAGONAL) {
+      var deltaHeight = lastInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER;
+      // One grid unit per level of nesting.
+      row.paddingEnd += deltaHeight / 2;
+    }
+  } else {
+    // No input in this row - mark as field.
+    otherShape = 0;
+  }
+  
+  if (customShape && customShape.blockPaddingEnd) {
+    const lastField = lastInput.fieldRow[lastInput.fieldRow.length - 1];
+    row.paddingEnd += customShape.blockPaddingEnd(this, otherShape, lastInput, lastField, row);
+  }
+
+  const paddingEnd = (Blockly.BlockSvg.SHAPE_IN_SHAPE_PADDING[shape] || {})[otherShape];
+  row.paddingEnd += paddingEnd === undefined ? Blockly.BlockSvg.DEFAULT_SHAPE_PADDING : paddingEnd;
+};
+
+/**
+ * Draw the path of the block.
+ * Move the fields to the correct locations.
+ * @param {number} iconWidth Offset of first row due to icons.
+ * @param {!Array.<!Array.<!Object>>} inputRows 2D array of objects, each
+ *     containing position information.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderDraw_ = function(iconWidth, inputRows) {
+  this.startHat_ = false;
+  // Should the top left corners be rounded or square?
+  // Currently, it is squared only if it's a hat.
+  this.squareTopLeftCorner_ = false;
+  if (!this.outputConnection && !this.previousConnection) {
+    // No output or previous connection.
+    this.squareTopLeftCorner_ = true;
+    this.startHat_ = true;
+    inputRows.rightEdge = Math.max(inputRows.rightEdge, 100);
+  }
+
+  // Amount of space to skip drawing the top and bottom,
+  // to make room for the left and right to draw shapes (curves or angles).
+  this.edgeShapeWidth_ = 0;
+  this.edgeShape_ = null;
+  if (this.outputConnection) {
+    // Width of the curve/pointy-curve
+    var shape = this.getOutputShape();
+    if (shape != Blockly.OUTPUT_SHAPE_SQUARE) {
+      this.edgeShapeWidth_ = inputRows.bottomEdge / 2;
+      this.edgeShape_ = shape;
+      this.squareTopLeftCorner_ = true;
+    }
+  }
+
+  // Assemble the block's path.
+  var steps = [];
+
+  this.renderDrawTop_(steps, inputRows.rightEdge);
+  var cursorY = this.renderDrawRight_(steps, inputRows, iconWidth);
+  this.renderDrawBottom_(steps, cursorY);
+  this.renderDrawLeft_(steps, cursorY);
+
+  var pathString = steps.join(' ');
+  this.svgPath_.setAttribute('d', pathString);
+
+  if (this.RTL) {
+    // Mirror the block's path.
+    // This is awesome.
+    this.svgPath_.setAttribute('transform', 'scale(-1 1)');
+  }
+};
+
+/**
+ * Give the block an attribute 'data-shapes' that lists its shape[s], and an
+ *     attribute 'data-category' with its category.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderClassify_ = function() {
+  var shapes = [];
+
+  if (this.outputConnection) {
+    if (this.isShadow_ && !(this.type === 'polygon' || this.type === 'procedures_prototype')) {
+      shapes.push('argument');
+    } else {
+      shapes.push('reporter');
+    }
+    switch (this.edgeShape_) {
+      case Blockly.OUTPUT_SHAPE_HEXAGONAL:
+        shapes.push('boolean');
+        break;
+      case Blockly.OUTPUT_SHAPE_ROUND:
+        shapes.push('round');
+        break;
+      case Blockly.OUTPUT_SHAPE_LEAF:
+        shapes.push('leaf');
+        break;
+      case Blockly.OUTPUT_SHAPE_PLUS:
+        shapes.push('plus');
+        break;
+      default: {
+        const isCustomShape = Blockly.BlockSvg.CUSTOM_SHAPES.has(this.edgeShape_);
+        if (isCustomShape) shapes.push('custom');
+      }
+    }
+  } else {
+    // count the number of statement inputs
+    var inputList = this.inputList;
+    var statementCount = 0;
+    for (var i = 0, input; input = inputList[i]; i++) {
+      if (input.connection && input.connection.type === Blockly.NEXT_STATEMENT) {
+        statementCount++;
+      }
+    }
+
+    if (statementCount) {
+      shapes.push('c-block');
+      shapes.push('c-' + statementCount);
+    }
+    if (this.startHat_) {
+      shapes.push('hat'); // c-block+hats are possible (e.x. reprter procedures)
+    } else if (!statementCount) {
+      shapes.push('stack'); //only call it "stack" if it's not a c-block
+    }
+    if (!this.nextConnection) {
+      shapes.push('end');
+    }
+  }
+
+  this.svgGroup_.setAttribute('data-shapes', shapes.join(' '));
+
+  if (this.getCategory()) {
+    this.svgGroup_.setAttribute('data-category', this.getCategory());
+  }
+};
+
+/**
+ * Render the top edge of the block.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @param {number} rightEdge Minimum width of block.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderDrawTop_ = function(steps, rightEdge) {
+  if (this.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE ||
+    this.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE + '_return') {
+    steps.push('m 0, 0');
+    steps.push(Blockly.BlockSvg.TOP_LEFT_CORNER_DEFINE_HAT);
+  } else {
+    // Position the cursor at the top-left starting point.
+    if (this.squareTopLeftCorner_) {
+      steps.push('m 0,0');
+      if (this.startHat_) {
+        steps.push(Blockly.BlockSvg.START_HAT_PATH);
+      }
+      // Skip space for the output shape
+      if (this.edgeShapeWidth_) {
+        steps.push('m ' + this.edgeShapeWidth_ + ',0');
+      }
+    } else {
+      steps.push(Blockly.BlockSvg.TOP_LEFT_CORNER_START);
+      // Top-left rounded corner.
+      steps.push(Blockly.BlockSvg.TOP_LEFT_CORNER);
+    }
+
+    // Top edge.
+    if (this.previousConnection) {
+      // Space before the notch
+      steps.push('H', Blockly.BlockSvg.NOTCH_START_PADDING);
+      if (Blockly.BlockSvg.NOTCH_SWITCH_ENABLE && (this.previousConnection.check_ || []).includes("switchCase")) {
+        steps.push(Blockly.BlockSvg.NOTCH_SWITCH_PATH_LEFT);
+      } else {
+        steps.push(Blockly.BlockSvg.NOTCH_PATH_LEFT);
+      }
+      // Create previous block connection.
+      var connectionX = (this.RTL ?
+          -Blockly.BlockSvg.NOTCH_WIDTH : Blockly.BlockSvg.NOTCH_WIDTH);
+      this.previousConnection.setOffsetInBlock(connectionX, 0);
+    }
+  }
+  this.width = rightEdge;
+};
+
+/**
+ * Render the right edge of the block.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @param {!Array.<!Array.<!Object>>} inputRows 2D array of objects, each
+ *     containing position information.
+ * @param {number} iconWidth Offset of first row due to icons.
+ * @return {number} Height of block.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderDrawRight_ = function(steps,
+    inputRows, iconWidth) {
+  var cursorX = 0;
+  var cursorY = 0;
+  if (!this.isCollapsed()) {
+    var connectionX, connectionY;
+    for (var y = 0, row; row = inputRows[y]; y++) {
+      cursorX = row.paddingStart;
+      if (y == 0) {
+        cursorX += this.RTL ? -iconWidth : iconWidth;
+      }
+  
+      if (row.type == Blockly.BlockSvg.INLINE) {
+        // Inline inputs.
+        for (var x = 0, input; input = row[x]; x++) {
+          // Align fields vertically within the row.
+          // Moves the field to half of the row's height.
+          // In renderFields_, the field is further centered
+          // by its own rendered height.
+          var fieldY = cursorY + row.height / 2;
+  
+          var fieldX = Blockly.BlockSvg.getAlignedCursor_(cursorX, input,
+              inputRows.rightEdge);
+  
+          cursorX = this.renderFields_(input.fieldRow, fieldX, fieldY);
+          if (input.type == Blockly.INPUT_VALUE) {
+            // Create inline input connection.
+            // In blocks with a notch, inputs should be bumped to a min X,
+            // to avoid overlapping with the notch.
+            if (this.previousConnection) {
+              cursorX = Math.max(cursorX, Blockly.BlockSvg.INPUT_AND_FIELD_MIN_X);
+            }
+            connectionX = this.RTL ? -cursorX : cursorX;
+            // Attempt to center the connection vertically.
+            var connectionYOffset = row.height / 2;
+            connectionY = cursorY + connectionYOffset;
+            input.connection.setOffsetInBlock(connectionX, connectionY);
+            this.renderInputShape_(input, cursorX, cursorY + connectionYOffset);
+            cursorX += input.renderWidth + Blockly.BlockSvg.SEP_SPACE_X;
+          }
+        }
+        // Remove final separator and replace it with right-padding.
+        cursorX -= Blockly.BlockSvg.SEP_SPACE_X;
+        cursorX += row.paddingEnd;
+        // Update right edge for all inputs, such that all rows
+        // stretch to be at least the size of all previous rows.
+        inputRows.rightEdge = Math.max(cursorX, inputRows.rightEdge, this.inputList.find(v => v.type == Blockly.NEXT_STATEMENT) ? Blockly.BlockSvg.MIN_BLOCK_X_WITH_STATEMENT + this.edgeShapeWidth_ : 0);
+        // Move to the right edge
+        cursorX = Math.max(cursorX, inputRows.rightEdge);
+        this.width = Math.max(this.width, cursorX);
+        if (this.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE + '_return') {
+          this.renderDefineBlock_(steps, inputRows, row[0], row, cursorY, cursorX);
+        }
+        if (this.type != Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE + '_return') {
+          if (!this.edgeShape_ || this.inputList.find(v => v.type == Blockly.NEXT_STATEMENT)) {
+            // Include corner radius in drawing the horizontal line.
+            steps.push('H', cursorX - Blockly.BlockSvg.CORNER_RADIUS);
+            steps.push(Blockly.BlockSvg.TOP_RIGHT_CORNER);
+          } else {
+            // Don't include corner radius - no corner (edge shape drawn).
+            steps.push('H', cursorX - this.edgeShapeWidth_);
+          }
+          // Subtract CORNER_RADIUS * 2 to account for the top right corner
+          // and also the bottom right corner. Only move vertically the non-corner length.
+          if (!this.edgeShape_ || this.inputList.find(v => v.type == Blockly.NEXT_STATEMENT)) {
+            steps.push('v', row.height - Blockly.BlockSvg.CORNER_RADIUS * 2);
+          }
+        }
+      } else if (row.type == Blockly.NEXT_STATEMENT) {
+        // Nested statement.
+        var input = row[0];
+        var fieldX = cursorX;
+        // Align fields vertically within the row.
+        // In renderFields_, the field is further centered by its own height.
+        var fieldY = cursorY;
+        fieldY += Blockly.BlockSvg.MIN_STATEMENT_INPUT_HEIGHT;
+        this.renderFields_(input.fieldRow, fieldX, fieldY);
+        // Move to the start of the notch.
+        cursorX = inputRows.statementEdge + Blockly.BlockSvg.NOTCH_WIDTH;
+  
+        if (this.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE) {
+          this.renderDefineBlock_(steps, inputRows, input, row, cursorY);
+        } else {
+          Blockly.BlockSvg.drawStatementInputFromTopRight_(steps, cursorX,
+              inputRows.rightEdge, row, this);
+        }
+  
+        // Create statement connection.
+        connectionX = this.RTL ? -cursorX : cursorX;
+        input.connection.setOffsetInBlock(connectionX, cursorY);
+        if (input.connection.isConnected()) {
+          this.width = Math.max(this.width, inputRows.statementEdge +
+            input.connection.targetBlock().getHeightWidth().width + (this.inputList.find(v => v.type == Blockly.NEXT_STATEMENT) ? this.edgeShapeWidth_ : 0));
+        }
+        if ((!(this.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE ||
+          this.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE + '_return')) &&
+          (y == inputRows.length - 1 ||
+            inputRows[y + 1].type == Blockly.NEXT_STATEMENT)) {
+          // If the final input is a statement stack, add a small row underneath.
+          // Consecutive statement stacks are also separated by a small divider.
+          steps.push(Blockly.BlockSvg.TOP_RIGHT_CORNER);
+          steps.push('v', Blockly.BlockSvg.EXTRA_STATEMENT_ROW_Y - 2 * Blockly.BlockSvg.CORNER_RADIUS);
+          cursorY += Blockly.BlockSvg.EXTRA_STATEMENT_ROW_Y;
+        }
+      }
+      cursorY += row.height;
+    }
+  }
+  this.drawEdgeShapeRight_(steps);
+  if (!inputRows.length) {
+    cursorY = Blockly.BlockSvg.MIN_BLOCK_Y;
+    steps.push('V', cursorY);
+  }
+  if (this.edgeShape_ && this.inputList.find(v => v.type == Blockly.NEXT_STATEMENT)) steps[1] = `m ${cursorY / 2} 0`
+  return cursorY;
+};
+
+/**
+ * Render the input shapes.
+ * If there's a connected block, hide the input shape.
+ * Otherwise, draw and set the position of the input shape.
+ * @param {!Blockly.Input} input Input to be rendered.
+ * @param {Number} x X offset of input.
+ * @param {Number} y Y offset of input.
+ */
+Blockly.BlockSvg.prototype.renderInputShape_ = function(input, x, y) {
+  var inputShape = input.outlinePath;
+  if (!inputShape) {
+    // No input shape for this input - e.g., the block is an insertion marker.
+    return;
+  }
+  // Input shapes are only visibly rendered on non-connected slots.
+  if (input.connection.targetConnection) {
+    inputShape.setAttribute('style', 'visibility: hidden');
+  } else {
+    var inputShapeX = 0, inputShapeY = 0;
+    var inputShapeInfo =
+        Blockly.BlockSvg.getInputShapeInfo_(input.connection.getOutputShape());
+    if (this.RTL) {
+      inputShapeX = -x - inputShapeInfo.width;
+    } else {
+      inputShapeX = x;
+    }
+    inputShapeY = y - (Blockly.BlockSvg.INPUT_SHAPE_HEIGHT / 2);
+    inputShape.setAttribute('d', inputShapeInfo.path);
+    inputShape.setAttribute('transform',
+        'translate(' + inputShapeX + ',' + inputShapeY + ')');
+    inputShape.setAttribute('data-argument-type', inputShapeInfo.argType);
+    inputShape.setAttribute('style', 'visibility: visible');
+  }
+};
+
+/**
+ * Render the bottom edge of the block.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @param {number} cursorY Height of block.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderDrawBottom_ = function(steps, cursorY) {
+  this.height = cursorY;
+  if (!this.edgeShape_ || this.inputList.find(v => v.type == Blockly.NEXT_STATEMENT)) {
+    steps.push(Blockly.BlockSvg.BOTTOM_RIGHT_CORNER);
+  }
+  if (this.nextConnection) {
+    // Move to the right-side of the notch.
+    var notchStart = (
+      Blockly.BlockSvg.NOTCH_WIDTH +
+      Blockly.BlockSvg.NOTCH_START_PADDING +
+      Blockly.BlockSvg.CORNER_RADIUS
+    );
+    steps.push('H', notchStart, ' ');
+    if (Blockly.BlockSvg.NOTCH_SWITCH_ENABLE && (this.nextConnection.check_ || []).includes("switchCase")) {
+      steps.push(Blockly.BlockSvg.NOTCH_SWITCH_PATH_RIGHT);
+    } else {
+      steps.push(Blockly.BlockSvg.NOTCH_PATH_RIGHT);
+    }
+    // Create next block connection.
+    var connectionX = this.RTL ? -Blockly.BlockSvg.NOTCH_WIDTH :
+        Blockly.BlockSvg.NOTCH_WIDTH;
+    this.nextConnection.setOffsetInBlock(connectionX, cursorY);
+    // Include height of notch in block height.
+    this.height += Blockly.BlockSvg.NOTCH_HEIGHT;
+  }
+  // Bottom horizontal line
+  if (!this.edgeShape_) {
+    steps.push('H', Blockly.BlockSvg.CORNER_RADIUS);
+    // Bottom left corner
+    steps.push(Blockly.BlockSvg.BOTTOM_LEFT_CORNER);
+  } else {
+    steps.push('H', this.height / 2);
+  }
+};
+
+/**
+ * Render the left edge of the block.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @param {number} cursorY Height of block.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderDrawLeft_ = function(steps, cursorY) {
+  let scale = this.height / 2
+
+  if (this.outputConnection) {
+    // Scratch-style reporters have output connection y at half block height.
+    this.outputConnection.setOffsetInBlock(0, this.height / 2);
+  }
+  if (this.edgeShape_) {
+    // Draw the left-side edge shape.
+    switch (this.edgeShape_) {
+      case Blockly.OUTPUT_SHAPE_ROUND:
+        // Draw a rounded arc.
+        steps.push('a ' + scale + ' ' + scale + ' 0 0 1 0 -' + scale * 2);
+        break;
+      case Blockly.OUTPUT_SHAPE_HEXAGONAL:
+        // Draw a half-hexagon.
+        steps.push('l ' + -scale + ' ' + -scale +
+          ' l ' + scale + ' ' + -scale);
+        break;
+      case Blockly.OUTPUT_SHAPE_LEAF:
+        // Draw a half-leaf.
+        steps.push(
+          `a ${scale} ${scale} 0 0 1 -${scale} -${scale} ` +
+          `l 0 -${scale * 0.6} ` +
+          `a ${scale * 0.4} ${scale * 0.4} 0 0 1 ${scale * 0.4} -${scale * 0.4}`
+        );
+        break;
+      case Blockly.OUTPUT_SHAPE_PLUS: {
+        // Draw a half-plus.
+        const unit = 6;
+        const remainingHeight = scale * 2 - 36;
+        const remainingWidth = scale  - 20;
+        steps.push(
+          `l -${remainingWidth} 0 ` +
+          `a ${unit} ${unit} 0 0 1 -${unit} -${unit} ` +
+          `a ${unit} ${unit} 0 0 0 -${unit} -${unit} ` +
+          `l -2 0 ` +
+          `a ${unit} ${unit} 0 0 1 -${unit} -${unit} ` +
+          `l 0 -${remainingHeight} ` +
+          `a ${unit} ${unit} 0 0 1 ${unit} -${unit} ` +
+          `l 2 0 ` +
+          `a ${unit} ${unit} 0 0 0 ${unit} -${unit} ` +
+          `a ${unit} ${unit} 0 0 1 ${unit} -${unit} ` +
+          `l ${remainingWidth} 0`
+        );
+        break;
+      }
+      default: {
+        const customShape = Blockly.BlockSvg.CUSTOM_SHAPES.get(this.edgeShape_);
+        if (customShape) {
+          const path = customShape.leftPath(this);
+          if (path && Array.isArray(path)) steps.push(...path);
+          else console.error(`Left Path Function for shape: ${this.edgeShape_} did not return an Array!`);
+        }
+      }
+    }
+  }
+  steps.push('z');
+};
+
+/**
+ * Draw the edge shape (rounded or hexagonal) on the right side of a block with
+ * an output.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @private
+ */
+Blockly.BlockSvg.prototype.drawEdgeShapeRight_ = function(steps) {
+  if (this.edgeShape_ && !this.inputList.find(v => v.type == Blockly.NEXT_STATEMENT)) {
+    // Draw the right-side edge shape.
+    switch (this.edgeShape_) {
+      case Blockly.OUTPUT_SHAPE_ROUND:
+        // Draw a rounded arc.
+        steps.push('a ' + this.edgeShapeWidth_ + ' ' + this.edgeShapeWidth_ +
+          ' 0 0 1 0 ' + this.edgeShapeWidth_ * 2);
+        break;
+      case Blockly.OUTPUT_SHAPE_HEXAGONAL:
+        // Draw a half-hexagon.
+        steps.push('l ' + this.edgeShapeWidth_ + ' ' + this.edgeShapeWidth_ +
+          ' l ' + -this.edgeShapeWidth_ + ' ' + this.edgeShapeWidth_);
+        break;
+      case Blockly.OUTPUT_SHAPE_LEAF:
+        // Draw a half-leaf.
+        steps.push(
+          `a ${this.edgeShapeWidth_} ${this.edgeShapeWidth_} 0 0 1 ${this.edgeShapeWidth_} ${this.edgeShapeWidth_} ` +
+          `l 0 ${this.edgeShapeWidth_ * 0.6} ` +
+          `a ${this.edgeShapeWidth_ * 0.4} ${this.edgeShapeWidth_ * 0.4} 0 0 1 -${this.edgeShapeWidth_ * 0.4} ${this.edgeShapeWidth_ * 0.4}`
+        );
+        break;
+      case Blockly.OUTPUT_SHAPE_PLUS: {
+        // Draw a half-plus.
+        const unit = 6;
+        const remainingHeight = this.edgeShapeWidth_ * 2 - 36;
+        const remainingWidth = this.edgeShapeWidth_ - 20;
+        steps.push(
+          `l ${remainingWidth} 0 ` +
+          `a ${unit} ${unit} 0 0 1 ${unit} ${unit} ` +
+          `a ${unit} ${unit} 0 0 0 ${unit} ${unit} ` +
+          `l 2 0 ` +
+          `a ${unit} ${unit} 0 0 1 ${unit} ${unit} ` +
+          `l 0 ${remainingHeight} ` +
+          `a ${unit} ${unit} 0 0 1 -${unit} ${unit} ` +
+          `l -2 0 ` +
+          `a ${unit} ${unit} 0 0 0 -${unit} ${unit} ` +
+          `a ${unit} ${unit} 0 0 1 -${unit} ${unit} ` +
+          `l -${remainingWidth} 0`
+        );
+        break;
+      }
+      default: {
+        const customShape = Blockly.BlockSvg.CUSTOM_SHAPES.get(this.edgeShape_);
+        if (customShape) {
+          const path = customShape.rightPath(this);
+          if (path && Array.isArray(path)) steps.push(...path);
+          else console.error(`Right Path Function for shape: ${this.edgeShape_} did not return an Array!`);
+        }
+      }
+    }
+  }
+};
+
+/**
+ * Position an new block correctly, so that it doesn't move the existing block
+ * when connected to it.
+ * @param {!Blockly.Block} newBlock The block to position - either the first
+ *     block in a dragged stack or an insertion marker.
+ * @param {!Blockly.Connection} newConnection The connection on the new block's
+ *     stack - either a connection on newBlock, or the last NEXT_STATEMENT
+ *     connection on the stack if the stack's being dropped before another
+ *     block.
+ * @param {!Blockly.Connection} existingConnection The connection on the
+ *     existing block, which newBlock should line up with.
+ */
+Blockly.BlockSvg.prototype.positionNewBlock = function(newBlock, newConnection,
+    existingConnection) {
+  // We only need to position the new block if it's before the existing one,
+  // otherwise its position is set by the previous block.
+  if (newConnection.type == Blockly.NEXT_STATEMENT) {
+    var dx = existingConnection.x_ - newConnection.x_;
+    var dy = existingConnection.y_ - newConnection.y_;
+
+    newBlock.moveBy(dx, dy);
+  }
+};
+
+/**
+ * Draw the outline of a statement input, starting at the top right corner.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @param {number} cursorX The x position of the start of the notch at the top
+ *     of the input.
+ * @param {number} rightEdge The far right edge of the block, which determines
+ *     how wide the statement input is.
+ * @param {!Array.<!Object>} row An object containing information about the
+ *     current row, including its height and whether it should have a notch at
+ *     the bottom.
+ * @private
+ */
+Blockly.BlockSvg.drawStatementInputFromTopRight_ = function(steps, cursorX,
+    rightEdge, row, block) {
+  Blockly.BlockSvg.drawStatementInputTop_(steps, cursorX, row, block);
+  steps.push('v', row.height - 2 * Blockly.BlockSvg.CORNER_RADIUS);
+  Blockly.BlockSvg.drawStatementInputBottom_(steps, rightEdge, row, block);
+};
+
+/**
+ * Draw the top of the outline of a statement input, starting at the top right
+ * corner.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @param {number} cursorX The x position of the start of the notch at the top
+ *     of the input.
+ * @private
+ */
+Blockly.BlockSvg.drawStatementInputTop_ = function(steps, cursorX, row, block) {
+  steps.push(Blockly.BlockSvg.BOTTOM_RIGHT_CORNER);
+  steps.push('H', cursorX + Blockly.BlockSvg.STATEMENT_INPUT_INNER_SPACE +
+    2 * Blockly.BlockSvg.CORNER_RADIUS + block.edgeShapeWidth_);
+  if (Blockly.BlockSvg.NOTCH_SWITCH_ENABLE && row[0].connection && (row[0].connection.check_ || []).includes("switchCase")) {
+    steps.push(Blockly.BlockSvg.NOTCH_SWITCH_PATH_RIGHT);
+  } else {
+    steps.push(Blockly.BlockSvg.NOTCH_PATH_RIGHT);
+  }
+  steps.push('h', '-' + Blockly.BlockSvg.STATEMENT_INPUT_INNER_SPACE);
+  steps.push(Blockly.BlockSvg.INNER_TOP_LEFT_CORNER);
+};
+
+/**
+ * Draw the bottom of the outline of a statement input, starting at the inner
+ * left corner.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @param {number} rightEdge The far right edge of the block, which determines
+ *     how wide the statement input is.
+ * @param {!Array.<!Object>} row An object containing information about the
+ *     current row, including its height and whether it should have a notch at
+ *     the bottom.
+ * @private
+ */
+Blockly.BlockSvg.drawStatementInputBottom_ = function(steps, rightEdge, row, block) {
+  steps.push(Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER);
+  if (row.statementNotchAtBottom) {
+    steps.push('h ', Blockly.BlockSvg.STATEMENT_INPUT_INNER_SPACE);
+    if (Blockly.BlockSvg.NOTCH_SWITCH_ENABLE && row[0].connection && (row[0].connection.check_ || []).includes("switchCase")) {
+      steps.push(Blockly.BlockSvg.NOTCH_SWITCH_PATH_LEFT);
+    } else {
+      steps.push(Blockly.BlockSvg.NOTCH_PATH_LEFT);
+    }
+  }
+  steps.push('H', rightEdge - Blockly.BlockSvg.CORNER_RADIUS);
+};
+
+/**
+ * Render part of the hat and the right side of the define block to fully wrap
+ * the connected statement block.
+ * Scratch-specific.
+ * @param {!Array.<string>} steps Path of block outline.
+ * @param {!Array.<!Array.<!Object>>} inputRows 2D array of objects, each
+ *     containing position information.
+ * @param {!Blockly.Input} input The input that is currently being rendered.
+ * @param {!Array.<!Object>} row An object containing information about the
+ *     current row, including its height and whether it should have a notch at
+ *     the bottom.
+ * @param {number} cursorY The y position of the start of this row.  Used to
+ *     position the following dummy input's fields.
+ * @param {number} cursorX The x position of the start of this row.  Used to
+ *     position the following dummy input's fields.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderDefineBlock_ = function(steps, inputRows,
+    input, row, cursorY, cursorX) {
+  // Following text shows up as a dummy input after the statement input, which
+  // we are forcing to stay inline with the statement input instead of letting
+  // it drop to a new line.
+  var hasFollowingText = row.length == 2;
+
+  // Figure out where the right side of the block is.
+  var rightSide;
+  if (!cursorX) {
+    rightSide = inputRows.rightEdge;
+    if (input.connection && input.connection.targetBlock()) {
+      rightSide = inputRows.statementEdge +
+          input.connection.targetBlock().getHeightWidth().width +
+          Blockly.BlockSvg.DEFINE_BLOCK_PADDING_RIGHT;
+    } else {
+      // Handles the case where block is being rendered as an insertion marker
+      rightSide = Math.max(Blockly.BlockSvg.MIN_BLOCK_X_WITH_STATEMENT, rightSide)
+      + Blockly.BlockSvg.DEFINE_BLOCK_PADDING_RIGHT;
+    }
+    rightSide -= Blockly.BlockSvg.DEFINE_HAT_CORNER_RADIUS;
+
+    if (hasFollowingText) {
+      var followingTextInput = row[1];
+      var fieldStart = rightSide + 3 * Blockly.BlockSvg.SEP_SPACE_X;
+      rightSide += followingTextInput.fieldRow[0].getSize().width;
+      rightSide += 2 * Blockly.BlockSvg.SEP_SPACE_X;
+
+      // Align fields vertically within the row.
+      // In renderFields_, the field is further centered by its own height.
+      // The dummy input's fields did not get laid out normally because we're
+      // forcing them to stay inline with a statement input.
+      var fieldY = cursorY;
+      fieldY += Blockly.BlockSvg.MIN_STATEMENT_INPUT_HEIGHT;
+      this.renderFields_(followingTextInput.fieldRow, fieldStart, fieldY);
+    }
+  } else {
+    rightSide = cursorX;
+  }
+  // Draw the top and the right corner of the hat.
+  steps.push('H', rightSide);
+  steps.push(Blockly.BlockSvg.TOP_RIGHT_CORNER_DEFINE_HAT);
+  row.height += 3 * Blockly.BlockSvg.GRID_UNIT;
+  // Draw the right side of the block around the statement input.
+  steps.push('v', row.height);
+  // row.height will be used to update the cursor in the calling function.
+  row.height += Blockly.BlockSvg.GRID_UNIT;
+
+};
+
+/**
+ * Get some information about the input shape to draw, based on the type of the
+ * connection.
+ * @param {number} shape An enum representing the shape of the connection we're
+ *     drawing around.
+ * @return {!Object} An object containing an SVG path, a string representation
+ *     of the argument type, and a width.
+ * @private
+ */
+Blockly.BlockSvg.getInputShapeInfo_ = function(shape) {
+  var inputShapePath = null;
+  var inputShapeArgType = null;
+  var inputShapeWidth = 0;
+
+  switch (shape) {
+    case Blockly.OUTPUT_SHAPE_PLUS:
+      inputShapePath = Blockly.BlockSvg.INPUT_SHAPE_PLUS;
+      inputShapeWidth = Blockly.BlockSvg.INPUT_SHAPE_PLUS_WIDTH;
+      inputShapeArgType = 'plus';
+      break;
+    case Blockly.OUTPUT_SHAPE_LEAF:
+      inputShapePath = Blockly.BlockSvg.INPUT_SHAPE_LEAF;
+      inputShapeWidth = Blockly.BlockSvg.INPUT_SHAPE_LEAF_WIDTH;
+      inputShapeArgType = 'leaf';
+      break;
+    case Blockly.OUTPUT_SHAPE_HEXAGONAL:
+      inputShapePath = Blockly.BlockSvg.INPUT_SHAPE_HEXAGONAL;
+      inputShapeWidth = Blockly.BlockSvg.INPUT_SHAPE_HEXAGONAL_WIDTH;
+      inputShapeArgType = 'boolean';
+      break;
+    case Blockly.OUTPUT_SHAPE_ROUND:
+      inputShapePath = Blockly.BlockSvg.INPUT_SHAPE_ROUND;
+      inputShapeWidth = Blockly.BlockSvg.INPUT_SHAPE_ROUND_WIDTH;
+      inputShapeArgType = 'round';
+      break;
+    case Blockly.OUTPUT_SHAPE_SQUARE:
+    default: {
+      // this could be a custom shape
+      const customShape = Blockly.BlockSvg.CUSTOM_SHAPES.get(shape);
+      if (shape !== Blockly.OUTPUT_SHAPE_SQUARE && customShape) {
+        inputShapePath = customShape.emptyInputPath;
+        inputShapeWidth = customShape.emptyInputWidth;
+        inputShapeArgType = customShape.name;
+      } else {
+        // If the input connection is not connected, draw a hole shape.
+        inputShapePath = Blockly.BlockSvg.INPUT_SHAPE_SQUARE;
+        inputShapeWidth = Blockly.BlockSvg.INPUT_SHAPE_SQUARE_WIDTH;
+        inputShapeArgType = 'square';
+      }
+      break;
+    }
+  }
+  return {
+    path: inputShapePath,
+    argType: inputShapeArgType,
+    width: inputShapeWidth
+  };
+};
+
+/**
+ * Get the correct cursor position for the given input, based on alignment,
+ * the total size of the block, and the size of the input.
+ * @param {number} cursorX The minimum x value of the cursor.
+ * @param {!Blockly.Input} input The input to align the fields for.
+ * @param {number} rightEdge The maximum width of the block.  Right-aligned
+ *     fields are positioned based on this number.
+ * @return {number} The new cursor position.
+ * @private
+ */
+Blockly.BlockSvg.getAlignedCursor_ = function(cursorX, input, rightEdge) {
+  // Align inline field rows (left/right/centre).
+  if (input.align === Blockly.ALIGN_RIGHT) {
+    cursorX += rightEdge - input.fieldWidth -
+      (2 * Blockly.BlockSvg.SEP_SPACE_X);
+  } else if (input.align === Blockly.ALIGN_CENTRE) {
+    cursorX = Math.max(cursorX, rightEdge / 2 - input.fieldWidth / 2);
+  }
+  return cursorX;
+};
+
+/**
+ * Update all of the connections on this block with the new locaitons calculated
+ * in renderCompute, and move all of the connected blocks based on the new
+ * connection locations.
+ * @private
+ */
+Blockly.BlockSvg.prototype.renderMoveConnections_ = function() {
+  var blockTL = this.getRelativeToSurfaceXY();
+  var branchedReporterTL = blockTL.clone().translate(this.edgeShapeWidth_, 0);
+  // Don't tighten previous or output connections because they are inferior.
+  if (this.previousConnection) {
+    this.previousConnection.moveToOffset(blockTL);
+  }
+  if (this.outputConnection) {
+    this.outputConnection.moveToOffset(blockTL);
+  }
+
+  for (var i = 0; i < this.inputList.length; i++) {
+    var conn = this.inputList[i].connection;
+    if (conn) {
+      conn.moveToOffset(this.inputList[i].type == Blockly.NEXT_STATEMENT ? branchedReporterTL : blockTL);
+      if (conn.isConnected()) {
+        conn.tighten_();
+      }
+    }
+  }
+
+  if (this.nextConnection) {
+    this.nextConnection.moveToOffset(blockTL);
+    if (this.nextConnection.isConnected()) {
+      this.nextConnection.tighten_();
+    }
+  }
+};
+
+/* -= Custom Block Shape API =- */
+// Stores all user-defined custom shapes
+Blockly.BlockSvg.CUSTOM_SHAPES = new Map([
+    /* pre-made shapes */
+    // NOTE: the keys should be numbers, see src/extension-support/block-shape in VM
+    // Reference: boolean shape -> m 16 0 h 16 (rightPath) l 16 16 l -16 16 h -16 (leftPath) l -16 -16 l 16 -16 z
+    [Blockly.OUTPUT_SHAPE_OCTAGONAL, {
+        emptyInputPath: "M 8 0 h 32 l 8 8 l 0 16 l -8 8 h -32 l -8 -8 l 0 -16 l 8 -8 z",
+        emptyInputWidth: 14 * Blockly.BlockSvg.GRID_UNIT,
+        leftPath: (block) => {
+            const scale = block.height / 2;
+            return [`l ${-scale / 2} 0 l ${-scale / 2} ${-scale / 2} l 0 ${-scale} l ${scale / 2} ${-scale / 2} l ${scale / 2} 0`];
+        },
+        rightPath: (block) => {
+            const scale = block.edgeShapeWidth_;
+            return [`l ${scale / 2} 0 l ${scale / 2} ${scale / 2} l 0 ${scale} l ${-scale / 2} ${scale / 2} l ${-scale / 2} 0`];
+        },
+        blockPaddingStart: (_, __, firstInput) => {
+            return Math.max(((firstInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER) - 4) / 2, 0);
+        },
+        blockPaddingEnd: (_, __, lastInput) => {
+            return Math.max(((lastInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER) - 4) / 2, 0);
+        },
+    }],
+    [Blockly.OUTPUT_SHAPE_BUMPED, {
+        emptyInputPath: "M 8 0 h 32 a 1 1 0 0 1 0 16 a 1 1 0 0 1 0 16 h -32 a 1 1 0 0 1 0 -16 a 1 1 0 0 1 0 -16 z",
+        emptyInputWidth: 14 * Blockly.BlockSvg.GRID_UNIT,
+        leftPath: (block) => {
+            const scale = block.height / 2;
+            return [`a 1 1 0 0 1 0 ${-scale} a 1 1 0 0 1 0 ${-scale}`];
+        },
+        rightPath: (block) => {
+            const scale = block.edgeShapeWidth_;
+            return [`a 1 1 0 0 1 0 ${scale} a 1 1 0 0 1 0 ${scale}`];
+        },
+        blockPaddingStart: (_, __, firstInput) => {
+            return Math.max(((firstInput.renderHeight - ScratchBlocks.BlockSvg.MIN_BLOCK_Y_REPORTER) * .5) + 17, 16);
+        },
+        blockPaddingEnd: (_, __, lastInput) => {
+            return Math.max(((lastInput.renderHeight - ScratchBlocks.BlockSvg.MIN_BLOCK_Y_REPORTER) * .5) + 25, 20);
+        },
+    }],
+    [Blockly.OUTPUT_SHAPE_INDENTED, {
+        emptyInputPath: "M 16 0 h 16 h 16 l -16 16 l 16 16 h -16 h -16 h -16 l 16 -16 l -16 -16 z",
+        emptyInputWidth: 12 * Blockly.BlockSvg.GRID_UNIT,
+        leftPath: (block) => {
+            const scale = block.height / 2;
+            return [`h ${-scale} l ${scale} ${-scale} l ${-scale} ${-scale}`];
+        },
+        rightPath: (block) => {
+            const scale = block.edgeShapeWidth_;
+            return [`h ${scale} l ${-scale} ${scale} l ${scale} ${scale} h ${-scale}`];
+        },
+        blockPaddingStart: (_, __, firstInput) => {
+            return Math.max(((firstInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER)) / 2, 0) + 4;
+        },
+        blockPaddingEnd: (_, __, lastInput) => {
+            return Math.max(((lastInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER)) / 2, 0) + 4;
+        },
+    }],
+    [Blockly.OUTPUT_SHAPE_SCRAPPED, {
+        emptyInputPath: "M 16 0 h 16 h 16 l -6 10 l -4 1 l 4 2 v 6 l -4 2 l 4 1 l 6 10 h -16 h -16 h -16 l 6 -10 l 4 -1 l -4 -2 v -6 l 4 -2 l -4 -1 l -6 -10 z",
+        emptyInputWidth: 12 * Blockly.BlockSvg.GRID_UNIT,
+        leftPath: (block) => {
+            const scale = block.height / 2;
+            const s = scale / 16;
+            return [
+                `h ${-16 * s}`,
+                `l ${6 * s} ${-10 * s}`,
+                `l ${4 * s} ${-1 * s}`,
+                `l ${-4 * s} ${-2 * s}`,
+                `v ${-6 * s}`,
+                `l ${4 * s} ${-2 * s}`,
+                `l ${-4 * s} ${-1 * s}`,
+                `l ${-6 * s} ${-10 * s}`,
+            ];
+        },
+        rightPath: (block) => {
+            const scale = block.edgeShapeWidth_;
+            const s = scale / 16;
+            return [
+                `h ${16 * s}`,
+                `l ${-6 * s} ${10 * s}`,
+                `l ${-4 * s} ${1 * s}`,
+                `l ${4 * s} ${2 * s}`,
+                `v ${6 * s}`,
+                `l ${-4 * s} ${2 * s}`,
+                `l ${4 * s} ${1 * s}`,
+                `l ${6 * s} ${10 * s}`,
+                `h ${-16 * s}`,
+            ];
+        },
+        blockPaddingStart: (_, __, firstInput) => {
+            return Math.max(((firstInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER)) / 3, 0);
+        },
+        blockPaddingEnd: (_, __, lastInput) => {
+            return Math.max(((lastInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER)) / 3, 0);
+        },
+    }],
+    [Blockly.OUTPUT_SHAPE_ARROW, {
+        emptyInputPath: "M 16 0 h 16 c 0.059 0 0.1175 0.0014 0.1758 0.0042 c 0.6594 -0.0042 1.7729 -0.0042 3.2858 0.9866 l 13.0645 11.9969 c 0.1287 0.0979 0.2521 0.2057 0.3696 0.3231 c 0.4447 0.4447 0.7494 0.9762 0.9143 1.5401 l 0.0454 0.0755 l -0.0123 0.0452 c 0.0757 0.297 0.1133 0.6017 0.1126 0.9064 c 0.0007 0.3047 -0.0369 0.6093 -0.1126 0.9063 l 0.0123 0.0452 l -0.0454 0.0755 c -0.1649 0.5638 -0.4695 1.0954 -0.9143 1.5401 c -0.1175 0.1175 -0.241 0.2252 -0.3696 0.3231 l -13.0645 11.9969 c -0.9561 0.9699 -3.0641 1.2348 -3.4616 1.2349 h -16 h -12.2464 c -0.6168 0 -1.1976 -0.1543 -1.7058 -0.4265 l -0.0742 -0.0397 l -0.0567 -0.0341 c -0.4474 -0.2641 -0.8331 -0.6217 -1.1301 -1.046 c -0.7213 -0.9079 -0.9437 -2.082 -0.6674 -3.1542 l 0.0166 -0.0623 l 0.024 -0.0822 c 0.167 -0.5518 0.4684 -1.0716 0.9047 -1.5078 l 10.6386 -9.7693 l -10.6386 -9.7693 c -0.4362 -0.4362 -0.7377 -0.9559 -0.9047 -1.5078 l -0.0245 -0.0877 l -0.0161 -0.0568 c -0.3091 -1.1994 0.006 -2.5264 0.9451 -3.4655 c 0.8871 -0.8871 2.217 -0.9908 3.2649 -0.9908 h 11.6706 z",
+        emptyInputWidth: 12 * Blockly.BlockSvg.GRID_UNIT,
+        leftPath: (block) => {
+            const scale = block.height / 2;
+            const s = scale / 16;
+            return [
+                `h ${-12.2464 * s}`,
+                `c ${-0.6168 * s} 0 ${-1.1976 * s} ${-0.1543 * s} ${-1.7058 * s} ${-0.4265 * s}`,
+                `l ${-0.0742 * s} ${-0.0397 * s}`,
+                `l ${-0.0567 * s} ${-0.0341 * s}`,
+                `c ${-0.4474 * s} ${-0.2641 * s} ${-0.8331 * s} ${-0.6217 * s} ${-1.1301 * s} ${-1.046 * s}`,
+                `c ${-0.7213 * s} ${-0.9079 * s} ${-0.9437 * s} ${-2.082 * s} ${-0.6674 * s} ${-3.1542 * s}`,
+                `l ${0.0166 * s} ${-0.0623 * s}`,
+                `l ${0.024 * s} ${-0.0822 * s}`,
+                `c ${0.167 * s} ${-0.5518 * s} ${0.4684 * s} ${-1.0716 * s} ${0.9047 * s} ${-1.5078 * s}`,
+                `l ${10.6386 * s} ${-9.7693 * s}`,
+                `l ${-10.6386 * s} ${-9.7693 * s}`,
+                `c ${-0.4362 * s} ${-0.4362 * s} ${-0.7377 * s} ${-0.9559 * s} ${-0.9047 * s} ${-1.5078 * s}`,
+                `l ${-0.0245 * s} ${-0.0877 * s}`,
+                `l ${-0.0161 * s} ${-0.0568 * s}`,
+                `c ${-0.3091 * s} ${-1.1994 * s} ${0.006 * s} ${-2.5264 * s} ${0.9451 * s} ${-3.4655 * s}`,
+                `c ${0.8871 * s} ${-0.8871 * s} ${2.217 * s} ${-0.9908 * s} ${3.2649 * s} ${-0.9908 * s}`,
+                `h ${11.6706 * s}`,
+            ];
+        },
+        rightPath: (block) => {
+            const scale = block.edgeShapeWidth_;
+            const s = scale / 16;
+            return [
+                `c ${0.059 * s} 0 ${0.1175 * s} ${0.0014 * s} ${0.1758 * s} ${0.0042 * s}`,
+                `c ${0.6594 * s} ${-0.0042 * s} ${1.7729 * s} ${-0.0042 * s} ${3.2858 * s} ${0.9866 * s}`,
+                `l ${13.0645 * s} ${11.9969 * s}`,
+                `c ${0.1287 * s} ${0.0979 * s} ${0.2521 * s} ${0.2057 * s} ${0.3696 * s} ${0.3231 * s}`,
+                `c ${0.4447 * s} ${0.4447 * s} ${0.7494 * s} ${0.9762 * s} ${0.9143 * s} ${1.5401 * s}`,
+                `l ${0.0454 * s} ${0.0755 * s}`,
+                `l ${-0.0123 * s} ${0.0452 * s}`,
+                `c ${0.0757 * s} ${0.297 * s} ${0.1133 * s} ${0.6017 * s} ${0.1126 * s} ${0.9064 * s}`,
+                `c ${0.0007 * s} ${0.3047 * s} ${-0.0369 * s} ${0.6093 * s} ${-0.1126 * s} ${0.9063 * s}`,
+                `l ${0.0123 * s} ${0.0452 * s}`,
+                `l ${-0.0454 * s} ${0.0755 * s}`,
+                `c ${-0.1649 * s} ${0.5638 * s} ${-0.4695 * s} ${1.0954 * s} ${-0.9143 * s} ${1.5401 * s}`,
+                `c ${-0.1175 * s} ${0.1175 * s} ${-0.241 * s} ${0.2252 * s} ${-0.3696 * s} ${0.3231 * s}`,
+                `l ${-13.0645 * s} ${11.9969 * s}`,
+                `c ${-0.9561 * s} ${0.9699 * s} ${-3.0641 * s} ${1.2348 * s} ${-3.4616 * s} ${1.2349 * s}`,
+            ];
+        },
+        blockPaddingStart: (_, __, firstInput) => {
+            return Math.max(((firstInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER)) / 2, 0) + 4;
+        },
+        blockPaddingEnd: (_, __, lastInput) => {
+            return Math.max(((lastInput.renderHeight - Blockly.BlockSvg.MIN_BLOCK_Y_REPORTER)) / 2, 0) + 4;
+        },
+    }],
+    [Blockly.OUTPUT_SHAPE_TICKET, {
+        emptyInputPath: "m 0 0 m 15 0 H 46 z L 2 0 A 2 2 0 0 0 0 2 L 0 8 A 2 2 0 0 0 2 10 L 7 10 c 4 2 4 9 0 11 L 2 21 A 2 2 0 0 0 0 23 L 0 30 A 2 2 0 0 0 2 32 L 46 32 A 2 2 0 0 0 48 30 L 48 23 A 2 2 0 0 0 46 21 L 41 21 c -4 -2 -4 -9 0 -11 L 46 10 A 2 2 0 0 0 48 8 L 48 2 A 2 2 0 0 0 46 0 z",
+        emptyInputWidth: 12 * Blockly.BlockSvg.GRID_UNIT,
+        // 13.4 is the height of the hole
+        leftPath: (block) => {
+            const w = block.edgeShapeWidth_;
+            return [
+                `h-${w - 1}`,
+                `a 2 2 0 0 1 -2 -2`, // 2unit rounded
+                `v-${w - (13.4 / 2) - 4}`,
+                `a 2 2 0 0 1 2 -2`, // 2unit rounded
+                `h10`,
+                `c4 -2 4 -12 0 -${13.4}`,
+                `h-10`,
+                `a 2 2 0 0 1 -2 -2`, // 2unit rounded
+                `v-${w - (13.4 / 2) - 4}`,
+                `a 2 2 0 0 1 2 -2`, // 2unit rounded
+            ];
+        },
+        rightPath: (block) => {
+            const w = block.edgeShapeWidth_;
+            return [
+                `h${w}`,
+                `a 2 2 0 0 1 2 2`, // 2unit rounded
+                `v${w - (13.4 / 2) - 4}`,
+                `a 2 2 0 0 1 -2 2`, // 2unit rounded
+                `h-10`,
+                `c-4 2 -4 12 0 ${13.4}`,
+                `h10`,
+                `a 2 2 0 0 1 2 2`, // 2unit rounded
+                `v${w - (13.4 / 2) - 4}`,
+                `a 2 2 0 0 1 -2 2`, // 2unit rounded
+            ];
+        },
+    }],
+]);
+
+/**
+ * Register a custom block shape
+ * @param {string} name The name used to identify custom shapes
+ * @param {object} shapeInfo All relative information for generating the shape (see below)
+ */
+/*
+shapeInfo entries ==> 
+{
+  emptyInputPath: (string) -- SVG path for the inside of an empty input slot
+  emptyInputWidth: (number) -- (optional) Default width for a empty input slot
+  leftPath: (block) => { return Array } -– Returns an array of SVG path parts for the left side of the block
+  rightPath: (block) => { return Array } –- Returns an array of SVG path parts for the right side of the block
+  blockPadding: (object) -- (optional) Object for block-in-block padding, example format: {
+    internal: {
+      // padding values for each block shape as your block
+      // formatted like each shape in Blockly.BlockSvg.SHAPE_IN_SHAPE_PADDING
+    },
+    external: {
+      // padding values for your block in each block shape
+      // include all keys from Blockly.BlockSvg.SHAPE_IN_SHAPE_PADDING and insert the padding as the value
+    },
+  }
+  blockPaddingStart: (block, otherShape, firstInput, firstField, row) => { return Number } -– Returns a number adding extra padding to the start of the block in 'computeOutputPadding_', used for boolean-like shapes.
+  blockPaddingEnd: (block, otherShape, lastInput, lastField, row) => { return Number } –- Returns a number adding extra padding to the end of the block in 'computeOutputPadding_', used for boolean-like shapes.
+}
+*/
+Blockly.BlockSvg.registerCustomShape = function(name, shapeInfo) {
+  if (!name || typeof shapeInfo !== 'object' || Array.isArray(shapeInfo)) {
+    console.error([
+      `Registration for Shape '${name}' failed`,
+      "Param 2 must be a object containing:",
+      "'emptyInputPath' (string) -- SVG path for the inside of an empty input slot",
+      "'emptyInputWidth' (number) -- (optional) Default width for a empty input slot",
+      "'leftPath' (function) -– Returns an array of SVG path parts for the left side of the block",
+      "'rightPath' (function) –- Returns an array of SVG path parts for the right side of the block",
+      "'blockPadding' (object) -- (optional) Object for block-in-block padding, similar to 'Blockly.BlockSvg.SHAPE_IN_SHAPE_PADDING', 'internal' entry for custom block padding, 'external' entry for other shapes padding",
+      "'blockPaddingStart' (function) -- (optional) Returns a number adding extra padding to the start of the block in 'computeOutputPadding_', used for boolean-like shapes.",
+      "'blockPaddingEnd' (function) -- (optional) Returns a number adding extra padding to the end of the block in 'computeOutputPadding_', used for boolean-like shapes.",
+    ].join("\n"));
+    return;
+  }
+  if (typeof shapeInfo.emptyInputPath !== "string") {
+    console.error(`Registration for Shape '${name}' failed\nNo 'emptyInputPath' entry found in Param 2/invalid SVG path string`);
+    return;
+  }
+  if (typeof shapeInfo.leftPath !== "function") {
+    console.error(`Registration for Shape '${name}' failed\nNo 'leftPath' entry found in Param 2/entry is not a function`);
+    return;
+  }
+  if (typeof shapeInfo.rightPath !== "function") {
+    console.error(`Registration for Shape '${name}' failed\nNo 'rightPath' entry found in Param 2/entry is not a function`);
+    return;
+  }
+
+  name = "custom-" + String(name);
+  shapeInfo.name = name;
+
+  // optional value, this default value is constant for all shapes
+  if (!shapeInfo.emptyInputWidth) shapeInfo.emptyInputWidth = 12 * Blockly.BlockSvg.GRID_UNIT;
+
+  // optional value, padding defaults to DEFAULT_SHAPE_PADDING
+  if (shapeInfo.blockPadding) {
+    const internalPads = shapeInfo.blockPadding.internal;
+    if (typeof internalPads === "object" && !Array.isArray(internalPads)) {
+      Blockly.BlockSvg.SHAPE_IN_SHAPE_PADDING[name] = internalPads;
+    } else {
+      console.warn(`No 'internal' padding object provided in custom shape ${name}, please refer to 'ScratchBlocks.BlockSvg.SHAPE_IN_SHAPE_PADDING', for formatting`);
+    }
+
+    const externalPads = shapeInfo.blockPadding.external;
+    if (typeof externalPads === "object" && !Array.isArray(externalPads)) {
+      const paddingEntries = Object.entries(Blockly.BlockSvg.SHAPE_IN_SHAPE_PADDING);
+      for (const shape of paddingEntries) {
+        if (!externalPads[shape[0]]) continue;
+        shape[1][name] = externalPads[shape[0]];
+      }
+    } else {
+      console.warn(`No 'external' padding object provided in custom shape ${name}, please refer to 'ScratchBlocks.BlockSvg.SHAPE_IN_SHAPE_PADDING', for formatting`);
+    }
+  }
+
+  // optional value, just validating it if it exists
+  if (shapeInfo.blockPaddingStart && typeof shapeInfo.blockPaddingStart !== "function") {
+    console.error(`Registration for Shape '${name}' failed\n'blockPaddingStart' entry found in Param 2/entry is not a function`);
+    return;
+  }
+  if (shapeInfo.blockPaddingEnd && typeof shapeInfo.blockPaddingEnd !== "function") {
+    console.error(`Registration for Shape '${name}' failed\n'blockPaddingEnd' entry found in Param 2/entry is not a function`);
+    return;
+  }
+
+  Blockly.BlockSvg.CUSTOM_SHAPES.set(name, shapeInfo);
+};