scratch-blocks 2.0.1 → 2.0.3

package/src/renderer/cat/render_info.ts

@@ -1,15 +1,12 @@
 /**
- * @license
  * Copyright 2026 Scratch Foundation
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import { RenderInfo as ClassicRenderInfo } from "../render_info";
-
-import { ConstantProvider } from "./constants";
-import { CatScratchRenderer } from "./renderer";
+import { RenderInfo as ClassicRenderInfo } from '../render_info'
+import { ConstantProvider } from './constants'
+import { CatScratchRenderer } from './renderer'
 
 export class RenderInfo extends ClassicRenderInfo {
-  override constants_: ConstantProvider;
-  override renderer_: CatScratchRenderer;
+  declare constants_: ConstantProvider
+  declare renderer_: CatScratchRenderer
 }

package/src/renderer/cat/renderer.ts

@@ -1,34 +1,30 @@
 /**
- * @license
  * Copyright 2026 Scratch Foundation
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
-
-import { ScratchRenderer } from "../renderer";
-
-import { ConstantProvider } from "./constants";
-import { Drawer } from "./drawer";
-import { RenderInfo } from "./render_info";
-import { PathObject } from "./path_object";
+import * as Blockly from 'blockly/core'
+import { ScratchRenderer } from '../renderer'
+import { ConstantProvider } from './constants'
+import { Drawer } from './drawer'
+import { PathObject } from './path_object'
+import { RenderInfo } from './render_info'
 
 export class CatScratchRenderer extends ScratchRenderer {
   override makeConstants_() {
-    return new ConstantProvider();
+    return new ConstantProvider()
   }
 
-  override makeDrawer_(block: Blockly.BlockSvg, info: RenderInfo) {
-    return new Drawer(block, info);
+  override makeDrawer_(block: Blockly.BlockSvg, info: Blockly.blockRendering.RenderInfo) {
+    return new Drawer(block, info as RenderInfo)
   }
 
   override makeRenderInfo_(block: Blockly.BlockSvg): RenderInfo {
-    return new RenderInfo(this, block);
+    return new RenderInfo(this, block)
   }
 
   override makePathObject(root: SVGElement, style: Blockly.Theme.BlockStyle): PathObject {
-    return new PathObject(root, style, this.getConstants());
+    return new PathObject(root, style, this.getConstants())
   }
 }
 
-Blockly.blockRendering.register("scratch_catblocks", CatScratchRenderer);
+Blockly.blockRendering.register('scratch_catblocks', CatScratchRenderer)

package/src/renderer/constants.ts

@@ -1,16 +1,14 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
+import * as Blockly from 'blockly/core'
 
 export class ConstantProvider extends Blockly.zelos.ConstantProvider {
-  REPLACEMENT_GLOW_COLOUR = "#ffffff";
-  SELECTED_GLOW_COLOUR = "#ffffff";
+  REPLACEMENT_GLOW_COLOUR = '#ffffff'
+  SELECTED_GLOW_COLOUR = '#ffffff'
 
-  BOWLER_HAT_HEIGHT = 20;
+  BOWLER_HAT_HEIGHT = 20
 
   /**
    * Sets the visual theme used to render the workspace.
@@ -19,39 +17,26 @@ export class ConstantProvider extends Blockly.zelos.ConstantProvider {
    * styles contain any raw color values, corresponding CSS variables will be
    * created/overridden so that those colors can be dynamically referenced in
    * stylesheets.
-   *
    * @param theme The new theme to apply.
    */
   override setTheme(theme: Blockly.Theme) {
-    const root = document.querySelector(":root") as HTMLElement;
+    const root = document.documentElement
     for (const [key, colour] of Object.entries(theme.blockStyles)) {
-      if (typeof colour !== "object") {
-        const varKey = `--colour-${key}`;
-        root.style.setProperty(varKey, colour);
+      if (typeof colour !== 'object') {
+        const varKey = `--colour-${key}`
+        root.style.setProperty(varKey, colour)
       } else {
         const style = {
-          colourPrimary:
-            "colourQuaternary" in colour
-              ? `${colour.colourQuaternary}`
-              : colour.colourTertiary,
-          colourSecondary:
-            "colourQuaternary" in colour
-              ? `${colour.colourQuaternary}`
-              : colour.colourTertiary,
-          colourTertiary:
-            "colourQuaternary" in colour
-              ? `${colour.colourQuaternary}`
-              : colour.colourTertiary,
-          colourQuaternary:
-            "colourQuaternary" in colour
-              ? `${colour.colourQuaternary}`
-              : colour.colourTertiary,
-          hat: "",
-        };
-        theme.setBlockStyle(`${key}_selected`, style);
+          colourPrimary: 'colourQuaternary' in colour ? `${colour.colourQuaternary}` : colour.colourTertiary,
+          colourSecondary: 'colourQuaternary' in colour ? `${colour.colourQuaternary}` : colour.colourTertiary,
+          colourTertiary: 'colourQuaternary' in colour ? `${colour.colourQuaternary}` : colour.colourTertiary,
+          colourQuaternary: 'colourQuaternary' in colour ? `${colour.colourQuaternary}` : colour.colourTertiary,
+          hat: '',
+        }
+        theme.setBlockStyle(`${key}_selected`, style)
       }
     }
-    super.setTheme(theme);
+    super.setTheme(theme)
   }
 
   /**
@@ -63,31 +48,33 @@ export class ConstantProvider extends Blockly.zelos.ConstantProvider {
    * that input slots inside a Boolean reporter (like `<a = b>`) are still
    * drawn with the rounded shape that matches what they accept, not the
    * hexagonal shape of their parent block's output.
+   * @param connection The connection whose shape to determine.
+   * @returns The shape object for the given connection.
    */
-  override shapeFor(connection: Blockly.RenderedConnection) {
-    let checks = connection.getCheck();
+  override shapeFor(connection: Blockly.RenderedConnection): ReturnType<Blockly.zelos.ConstantProvider['shapeFor']> {
+    let checks = connection.getCheck()
     if (!checks && connection.targetConnection) {
-      checks = connection.targetConnection.getCheck();
+      checks = connection.targetConnection.getCheck()
     }
 
     if (connection.type === Blockly.ConnectionType.OUTPUT_VALUE) {
-      const outputShape = connection.getSourceBlock().getOutputShape();
+      const outputShape = connection.getSourceBlock().getOutputShape()
       if (outputShape !== null) {
         switch (outputShape) {
           case this.SHAPES.HEXAGONAL:
-            return this.HEXAGONAL;
+            return this.HEXAGONAL!
           case this.SHAPES.ROUND:
-            return this.ROUNDED;
+            return this.ROUNDED!
           case this.SHAPES.SQUARE:
-            return this.SQUARED;
+            return this.SQUARED!
         }
       }
     }
 
     // For INPUT_VALUE (and OUTPUT_VALUE fallthrough), use connection checks.
-    if (checks?.includes("Boolean")) return this.HEXAGONAL;
-    if (checks?.includes("Number")) return this.ROUNDED;
-    if (checks?.includes("String")) return this.ROUNDED;
+    if (checks?.includes('Boolean')) return this.HEXAGONAL!
+    if (checks?.includes('Number')) return this.ROUNDED!
+    if (checks?.includes('String')) return this.ROUNDED!
     // For INPUT_VALUE or OUTPUT_VALUE with unrecognized checks, default to
     // ROUNDED. Don't call super.shapeFor() here: the base implementation
     // uses getSourceBlock().getOutputShape(), which would incorrectly return
@@ -96,14 +83,14 @@ export class ConstantProvider extends Blockly.zelos.ConstantProvider {
       connection.type === Blockly.ConnectionType.INPUT_VALUE ||
       connection.type === Blockly.ConnectionType.OUTPUT_VALUE
     ) {
-      return this.ROUNDED;
+      return this.ROUNDED!
     }
-    return super.shapeFor(connection);
+    return super.shapeFor(connection)
   }
 
   override createDom(svg: SVGElement, tagName: string, selector: string) {
-    super.createDom(svg, tagName, selector);
-    this.selectedGlowFilterId = "";
+    super.createDom(svg, tagName, selector)
+    this.selectedGlowFilterId = ''
   }
 
   /**
@@ -112,9 +99,7 @@ export class ConstantProvider extends Blockly.zelos.ConstantProvider {
    * @returns The SVG path string for the bowler hat.
    */
   makeBowlerHatPath(width: number): string {
-    const bowlerHatPath = `a20,20 0 0,1 20,-20 l ${
-      width - 40
-    } 0 a20,20 0 0,1 20,20`;
-    return bowlerHatPath;
+    const bowlerHatPath = `a20,20 0 0,1 20,-20 l ${width - 40} 0 a20,20 0 0,1 20,20`
+    return bowlerHatPath
   }
 }

package/src/renderer/drawer.ts

@@ -1,46 +1,38 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
-import type { RenderInfo } from "./render_info";
-import { ConstantProvider } from "./constants";
+import * as Blockly from 'blockly/core'
+import { ConstantProvider } from './constants'
+import type { RenderInfo } from './render_info'
 
 export class Drawer extends Blockly.zelos.Drawer {
-  constants_: ConstantProvider;
-  info_: RenderInfo;
+  declare constants_: ConstantProvider
+  declare info_: RenderInfo
 
   override drawStatementInput_(row: Blockly.blockRendering.Row) {
     if (this.info_.isBowlerHatBlock()) {
       // Bowler hat blocks have straight sides with no C-shape/indentation for
       // statement blocks.
-      this.drawRightSideRow_(row);
-      this.positionStatementInputConnection_(row);
+      this.drawRightSideRow_(row)
+      this.positionStatementInputConnection_(row)
     } else {
-      super.drawStatementInput_(row);
+      super.drawStatementInput_(row)
     }
   }
 
   override drawRightSideRow_(row: Blockly.blockRendering.Row) {
-    if (
-      this.info_.isBowlerHatBlock() &&
-      Blockly.blockRendering.Types.isSpacer(row)
-    ) {
+    if (this.info_.isBowlerHatBlock() && Blockly.blockRendering.Types.isSpacer(row)) {
       // Multi-row bowler hat blocks are not supported, this may need
       // adjustment to do so.
-      this.outlinePath_ += Blockly.utils.svgPaths.lineOnAxis(
-        "V",
-        row.yPos + row.height
-      );
+      this.outlinePath_ += Blockly.utils.svgPaths.lineOnAxis('V', row.yPos + row.height)
     } else {
-      super.drawRightSideRow_(row);
+      super.drawRightSideRow_(row)
     }
   }
 
   override drawTop_() {
-    super.drawTop_();
+    super.drawTop_()
     // This is a horrible hack, but the superclass' implementation of drawTop_()
     // provides no way to cleanly override a hat's path without copying and
     // pasting the entire implementation here. We know that there will only be
@@ -48,16 +40,16 @@ export class Drawer extends Blockly.zelos.Drawer {
     // replace it with the desired bowler hat path here.
     // If https://github.com/RaspberryPiFoundation/blockly/issues/7292 is
     // resolved, this should be revisited.
-    const replacementTop = this.makeReplacementTop_();
+    const replacementTop = this.makeReplacementTop_()
     if (replacementTop) {
-      const capHatPath = this.constants_.START_HAT.path;
-      this.outlinePath_ = this.outlinePath_.replace(capHatPath, replacementTop);
+      const capHatPath = this.constants_.START_HAT.path
+      this.outlinePath_ = this.outlinePath_.replace(capHatPath, replacementTop)
     }
   }
 
   makeReplacementTop_() {
     if (this.info_.isBowlerHatBlock()) {
-      return this.constants_.makeBowlerHatPath(this.info_.width);
+      return this.constants_.makeBowlerHatPath(this.info_.width)
     }
   }
 
@@ -67,38 +59,30 @@ export class Drawer extends Blockly.zelos.Drawer {
    * For rounded (non-hexagonal) input slots we expand the outline by 1px in
    * every direction so the white highlight stroke sits just outside the input
    * slot's background and remains visible rather than merging with it.
+   * @param measurable The connection measurable to highlight.
+   * @returns The highlight path element, if one was created.
    */
-  override drawConnectionHighlightPath(
-    measurable: Blockly.blockRendering.Connection
-  ) {
-    const conn = measurable.connectionModel;
-    if (
-      conn.type === Blockly.ConnectionType.INPUT_VALUE &&
-      measurable.isDynamicShape
-    ) {
-      const input = measurable as Blockly.blockRendering.InlineInput;
-      const EXPAND_X = 0.5;
-      const EXPAND_Y = 2;
-      const xPos = input.connectionWidth - EXPAND_X;
-      const yPos = -input.height / 2 - EXPAND_Y;
-      const width = input.width - input.connectionWidth * 2 + 2 * EXPAND_X;
-      const height = input.height + 2 * EXPAND_Y;
-      const shape = input.shape as Blockly.blockRendering.DynamicShape;
+  override drawConnectionHighlightPath(measurable: Blockly.blockRendering.Connection) {
+    const conn = measurable.connectionModel
+    if (conn.type === Blockly.ConnectionType.INPUT_VALUE && measurable.isDynamicShape) {
+      const input = measurable as Blockly.blockRendering.InlineInput
+      const EXPAND_X = 0.5
+      const EXPAND_Y = 2
+      const xPos = input.connectionWidth - EXPAND_X
+      const yPos = -input.height / 2 - EXPAND_Y
+      const width = input.width - input.connectionWidth * 2 + 2 * EXPAND_X
+      const height = input.height + 2 * EXPAND_Y
+      const shape = input.shape as Blockly.blockRendering.DynamicShape
       const path =
         Blockly.utils.svgPaths.moveTo(xPos, yPos) +
-        Blockly.utils.svgPaths.lineOnAxis("h", width) +
+        Blockly.utils.svgPaths.lineOnAxis('h', width) +
         shape.pathRightDown(height) +
-        Blockly.utils.svgPaths.lineOnAxis("h", -width) +
+        Blockly.utils.svgPaths.lineOnAxis('h', -width) +
         shape.pathUp(height) +
-        "z";
-      const block = conn.getSourceBlock();
-      return block.pathObject.addConnectionHighlight?.(
-        conn,
-        path,
-        conn.getOffsetInBlock(),
-        block.RTL
-      );
+        'z'
+      const block = conn.getSourceBlock()
+      return block.pathObject.addConnectionHighlight?.(conn, path, conn.getOffsetInBlock(), block.RTL)
     }
-    return super.drawConnectionHighlightPath(measurable);
+    return super.drawConnectionHighlightPath(measurable)
   }
 }

package/src/renderer/path_object.ts

@@ -1,10 +1,8 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
+import * as Blockly from 'blockly/core'
 
 /**
  * An object that handles creating and setting each of the SVG elements
@@ -14,22 +12,18 @@ export class PathObject extends Blockly.zelos.PathObject {
   /**
    * Apply the stored colours to the block's path, taking into account whether
    * the paths belong to a shadow block.
-   *
    * @param block The source block.
    */
   override applyColour(block: Blockly.BlockSvg) {
-    super.applyColour(block);
+    super.applyColour(block)
 
     // These blocks are special in that, while they are technically shadow
     // blocks when contained in a procedure definition/prototype, their parent
     // (the sample procedure caller block embedded in the definition block) is
     // also a shadow, so they need to use normal block colors in order to
     // provide contrast with it.
-    if (
-      block.type === "argument_reporter_string_number" ||
-      block.type === "argument_reporter_boolean"
-    ) {
-      this.svgPath.setAttribute("fill", this.style.colourPrimary);
+    if (block.type === 'argument_reporter_string_number' || block.type === 'argument_reporter_boolean') {
+      this.svgPath.setAttribute('fill', this.style.colourPrimary)
     }
   }
 }

package/src/renderer/render_info.ts

@@ -1,118 +1,101 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
-
-import { BowlerHat } from "./bowler_hat";
-import { ConstantProvider } from "./constants";
+import * as Blockly from 'blockly/core'
+import { BowlerHat } from './bowler_hat'
+import { ConstantProvider } from './constants'
 
 export class RenderInfo extends Blockly.zelos.RenderInfo {
-  constants_: ConstantProvider;
+  declare constants_: ConstantProvider
 
   override populateTopRow_() {
     if (this.isBowlerHatBlock()) {
-      const bowlerHat = this.makeBowlerHat();
-      this.topRow.elements.push(
-        new Blockly.blockRendering.SquareCorner(this.constants_)
-      );
-      this.topRow.elements.push(bowlerHat);
-      this.topRow.elements.push(
-        new Blockly.blockRendering.SquareCorner(this.constants_)
-      );
-      this.topRow.minHeight = 0;
-      this.topRow.capline = bowlerHat.ascenderHeight;
+      const bowlerHat = this.makeBowlerHat()
+      this.topRow.elements.push(new Blockly.blockRendering.SquareCorner(this.constants_))
+      this.topRow.elements.push(bowlerHat)
+      this.topRow.elements.push(new Blockly.blockRendering.SquareCorner(this.constants_))
+      this.topRow.minHeight = 0
+      this.topRow.capline = bowlerHat.ascenderHeight
     } else {
-      super.populateTopRow_();
+      super.populateTopRow_()
     }
   }
 
   override populateBottomRow_() {
-    super.populateBottomRow_();
+    super.populateBottomRow_()
     if (this.isBowlerHatBlock()) {
-      this.bottomRow.minHeight = this.constants_.MEDIUM_PADDING;
+      this.bottomRow.minHeight = this.constants_.MEDIUM_PADDING
     }
   }
 
   override computeBounds_() {
-    super.computeBounds_();
+    super.computeBounds_()
     if (this.isBowlerHatBlock()) {
       // Resize the render info to the same width as the widest part of a
       // bowler hat block.
-      const statementRow = this.rows.find((r) => r.hasStatement);
+      // Bowler hat blocks always have exactly one statement row and one input
+      // element, so these find() calls are guaranteed to succeed.
+      const statementRow = this.rows.find(r => r.hasStatement)!
       this.width =
         statementRow.widthWithConnectedBlocks -
-        statementRow.elements.find((e) =>
-          Blockly.blockRendering.Types.isInput(e)
-        ).width +
-        this.constants_.MEDIUM_PADDING;
+        statementRow.elements.find(e => Blockly.blockRendering.Types.isInput(e))!.width +
+        this.constants_.MEDIUM_PADDING
 
       // The bowler hat's width is the same as the block's width, so it can't
       // be derived from the constants like a normal hat and has to be set here.
-      const hat = this.topRow.elements.find((e) =>
-        Blockly.blockRendering.Types.isHat(e)
-      );
-      hat.width = this.width;
-      this.topRow.measure();
+      // populateTopRow_ always adds a hat element for bowler hat blocks.
+      const hat = this.topRow.elements.find(e => Blockly.blockRendering.Types.isHat(e))!
+      hat.width = this.width
+      this.topRow.measure()
     }
   }
 
   override getInRowSpacing_(
     prev: Blockly.blockRendering.Measurable,
-    next: Blockly.blockRendering.Measurable
+    next: Blockly.blockRendering.Measurable,
   ): number {
     if (
       this.isBowlerHatBlock() &&
-      ((prev && Blockly.blockRendering.Types.isHat(prev)) ||
-        (next && Blockly.blockRendering.Types.isHat(next)))
+      ((prev && Blockly.blockRendering.Types.isHat(prev)) || (next && Blockly.blockRendering.Types.isHat(next)))
     ) {
       // Bowler hat rows have no spacing/gaps, just the hat.
-      return 0;
+      return 0
     }
 
-    return super.getInRowSpacing_(prev, next);
+    return super.getInRowSpacing_(prev, next)
   }
 
-  override getSpacerRowHeight_(
-    prev: Blockly.blockRendering.Row,
-    next: Blockly.blockRendering.Row
-  ): number {
+  override getSpacerRowHeight_(prev: Blockly.blockRendering.Row, next: Blockly.blockRendering.Row): number {
     if (this.isBowlerHatBlock() && prev === this.topRow) {
-      return 0;
+      return 0
     }
 
-    return super.getSpacerRowHeight_(prev, next);
+    return super.getSpacerRowHeight_(prev, next)
   }
 
-  override getElemCenterline_(
-    row: Blockly.blockRendering.Row,
-    elem: Blockly.blockRendering.Measurable
-  ): number {
+  override getElemCenterline_(row: Blockly.blockRendering.Row, elem: Blockly.blockRendering.Measurable): number {
     if (this.isBowlerHatBlock() && Blockly.blockRendering.Types.isField(elem)) {
-      return row.yPos + row.height / 2;
+      return row.yPos + row.height / 2
     } else if (
-      "isScratchExtension" in this.block_ &&
+      'isScratchExtension' in this.block_ &&
       this.block_.isScratchExtension &&
       Blockly.blockRendering.Types.isField(elem) &&
-      (elem as Blockly.blockRendering.Field).field instanceof
-        Blockly.FieldImage &&
-      (elem as Blockly.blockRendering.Field).field ===
-        this.block_.inputList[0].fieldRow[0] &&
+      elem.field instanceof Blockly.FieldImage &&
+      elem.field === this.block_.inputList[0].fieldRow[0] &&
       this.block_.previousConnection
     ) {
       // Vertically center the icon on extension blocks.
-      return super.getElemCenterline_(row, elem) + this.constants_.GRID_UNIT;
+      return super.getElemCenterline_(row, elem) + this.constants_.GRID_UNIT
     }
-    return super.getElemCenterline_(row, elem);
+    return super.getElemCenterline_(row, elem)
   }
 
   isBowlerHatBlock() {
-    return this.block_.hat === "bowler";
+    return this.block_.hat === 'bowler'
   }
 
   makeBowlerHat() {
-    return new BowlerHat(this.constants_);
+    return new BowlerHat(this.constants_)
   }
 }

package/src/renderer/renderer.ts

@@ -1,14 +1,12 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
-import { Drawer } from "./drawer";
-import { RenderInfo } from "./render_info";
-import { ConstantProvider } from "./constants";
-import { PathObject } from "./path_object";
+import * as Blockly from 'blockly/core'
+import { ConstantProvider } from './constants'
+import { Drawer } from './drawer'
+import { PathObject } from './path_object'
+import { RenderInfo } from './render_info'
 
 /**
  * Custom renderer for Scratch-style blocks.
@@ -17,69 +15,58 @@ export class ScratchRenderer extends Blockly.zelos.Renderer {
   /**
    * Get the CSS class name associated with this renderer.
    * Note that all Scratch renderers share the same CSS class name.
-   *
-   * @returns The class name.
+   * @returns The CSS class name shared by all Scratch-style renderers.
    */
   override getClassName(): string {
-    return "scratch-renderer";
+    return 'scratch-renderer'
   }
 
   /**
    * Create a new instance of the renderer's drawer.
-   *
    * @param block The block to render.
-   * @param infoAn object containing all the information needed to render this
+   * @param info An object containing all the information needed to render this
    *     block.
    * @returns The drawer.
    */
-  override makeDrawer_(block: Blockly.BlockSvg, info: RenderInfo): Drawer {
-    return new Drawer(block, info);
+  override makeDrawer_(block: Blockly.BlockSvg, info: Blockly.blockRendering.RenderInfo): Drawer {
+    return new Drawer(block, info as RenderInfo)
   }
 
   /**
    * Create a new instance of the renderer's render info object.
-   *
    * @param block The block to measure.
    * @returns The render info object.
    */
   override makeRenderInfo_(block: Blockly.BlockSvg): RenderInfo {
-    return new RenderInfo(this, block);
+    return new RenderInfo(this, block)
   }
 
   /**
    * Create a new instance of the renderer's constant provider.
-   *
    * @returns The constant provider.
    */
   override makeConstants_(): ConstantProvider {
-    return new ConstantProvider();
+    return new ConstantProvider()
   }
 
   /**
    * Create a new instance of a renderer path object.
-   *
    * @param root The root SVG element.
    * @param style The style object to use for colouring.
-   * @returns The renderer path object.
+   * @returns A new path object configured for the given SVG root and block style.
    */
-  override makePathObject(
-    root: SVGElement,
-    style: Blockly.Theme.BlockStyle
-  ): PathObject {
-    return new PathObject(root, style, this.getConstants());
+  override makePathObject(root: SVGElement, style: Blockly.Theme.BlockStyle): PathObject {
+    return new PathObject(root, style, this.getConstants())
   }
 
   /**
    * Determine whether or not to highlight a connection.
-   *
    * @param connection The connection to determine whether or not to highlight.
    * @returns True if we should highlight the connection.
    */
   override shouldHighlightConnection(connection: Blockly.RenderedConnection): boolean {
-    return (
-      connection.type === Blockly.ConnectionType.INPUT_VALUE
-    );
+    return connection.type === Blockly.ConnectionType.INPUT_VALUE
   }
 }
 
-Blockly.blockRendering.register("scratch_classic", ScratchRenderer);
+Blockly.blockRendering.register('scratch_classic', ScratchRenderer)