activity.js

// Copyright (c) 2014-22 Walter Bender
// Copyright (c) Yash Khandelwal, GSoC'15
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the The GNU Affero General Public
// License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// You should have received a copy of the GNU Affero General Public
// License along with this library; if not, write to the Free Software
// Foundation, 51 Franklin Street, Suite 500 Boston, MA 02110-1335 USA
//
// Note: This code is inspired by the Python Turtle Blocks project
// (https://github.com/walterbender/turtleart), but implemented from
// scratch. -- Walter Bender, October 2014.

/*
   globals

   _, ALTO, analyzeProject, BASS, BIGGERBUTTON, BIGGERDISABLEBUTTON,
   ActivityContext,
   Blocks, Boundary, CARTESIAN, changeImage, closeWidgets,
   COLLAPSEBLOCKSBUTTON, COLLAPSEBUTTON, createDefaultStack,
   createHelpContent, createjs, DATAOBJS, DEFAULTBLOCKSCALE,
   DEFAULTDELAY, define, doBrowserCheck, doBrowserCheck, docByClass,
   doSVG, EMPTYHEAPERRORMSG, EXPANDBUTTON, FILLCOLORS,
   getMacroExpansion, getOctaveRatio, getTemperament, transcribeMidi,
   GOHOMEBUTTON, GOHOMEFADEDBUTTON, GRAND, HelpWidget, HIDEBLOCKSFADEDBUTTON,
   hideDOMLabel, initBasicProtoBlocks, initPalettes,
   INLINECOLLAPSIBLES, jQuery, JSEditor, LanguageBox, ThemeBox, Logo, MSGBLOCK,
   NANERRORMSG, NOACTIONERRORMSG, NOBOXERRORMSG, NOINPUTERRORMSG,
   NOMICERRORMSG, NOSQRTERRORMSG, NOSTRINGERRORMSG, PALETTEFILLCOLORS,
   PALETTESTROKECOLORS, PALETTEHIGHLIGHTCOLORS, HIGHLIGHTSTROKECOLORS,
   Palettes, PasteBox, PlanetInterface, platform, platformColor,
   piemenuKey, POLAR, preparePluginExports, processMacroData,
   processPluginData, processRawPluginData, require, SaveInterface,
   SHOWBLOCKSBUTTON, SMALLERBUTTON, SMALLERDISABLEBUTTON, SOPRANO,
   SPECIALINPUTS, STANDARDBLOCKHEIGHT, StatsWindow, STROKECOLORS,
   TENOR, TITLESTRING, Toolbar, Trashcan, TREBLE, Turtles, TURTLESVG,
   updatePluginObj, ZERODIVIDEERRORMSG, GRAND_G, GRAND_F,
   SHARP, FLAT, buildScale, TREBLE_F, TREBLE_G, GIFAnimator,
   MUSICALMODES, waitForReadiness
 */

/*
   exported

   Activity, LEADING, _THIS_IS_MUSIC_BLOCKS_, _THIS_IS_TURTLE_BLOCKS_,
   globalActivity, hideArrows, doAnalyzeProject
 */
const LEADING = 0;
const BLOCKSCALES = [1, 1.5, 2, 3, 4];
const _THIS_IS_MUSIC_BLOCKS_ = true;
const _THIS_IS_TURTLE_BLOCKS_ = !_THIS_IS_MUSIC_BLOCKS_;

const _ERRORMSGTIMEOUT_ = 15000;
const _MSGTIMEOUT_ = 60000;

// Responsive breakpoint constants
const RESPONSIVE_BREAKPOINT_TABLET = 768;
const RESPONSIVE_BREAKPOINT_MOBILE = 600;

let MYDEFINES = [
    "utils/platformstyle",
    "easeljs.min",
    "tweenjs.min",
    "preloadjs.min",
    "howler",
    "p5.min",
    "p5-sound-adapter",
    "p5.dom.min",
    // 'mespeak',
    "Chart",
    "utils/utils",
    "activity/artwork",
    "widgets/status",
    "widgets/help",
    "utils/munsell",
    "activity/toolbar",
    "activity/trash",
    "activity/boundary",
    "activity/palette",
    "activity/protoblocks",
    "activity/blocks",
    "activity/block",
    "activity/turtledefs",
    "activity/notation",
    "activity/logo",
    "activity/turtle",
    "activity/turtles",
    "activity/turtle-singer",
    "activity/turtle-painter",
    "activity/languagebox",
    "activity/themebox",
    "activity/basicblocks",
    "activity/blockfactory",
    "activity/piemenus",
    "activity/planetInterface",
    "activity/rubrics",
    "activity/macros",
    "activity/SaveInterface",
    "utils/musicutils",
    "utils/synthutils",
    "utils/mathutils",
    "activity/pastebox",
    "prefixfree.min",
    "Tone",
    "activity/js-export/samples/sample",
    "activity/js-export/export",
    "activity/js-export/interface",
    "activity/js-export/constraints",
    "activity/js-export/ASTutils",
    "activity/js-export/generate",
    "activity/js-export/ast2blocklist",
    "activity/js-export/API/GraphicsBlocksAPI",
    "activity/js-export/API/PenBlocksAPI",
    "activity/js-export/API/RhythmBlocksAPI",
    "activity/js-export/API/MeterBlocksAPI",
    "activity/js-export/API/PitchBlocksAPI",
    "activity/js-export/API/IntervalsBlocksAPI",
    "activity/js-export/API/ToneBlocksAPI",
    "activity/js-export/API/OrnamentBlocksAPI",
    "activity/js-export/API/VolumeBlocksAPI",
    "activity/js-export/API/DrumBlocksAPI",
    "activity/js-export/API/DictBlocksAPI",
    "activity/turtleactions/RhythmActions",
    "activity/turtleactions/MeterActions",
    "activity/turtleactions/PitchActions",
    "activity/turtleactions/IntervalsActions",
    "activity/turtleactions/ToneActions",
    "activity/turtleactions/OrnamentActions",
    "activity/turtleactions/VolumeActions",
    "activity/turtleactions/DrumActions",
    "activity/turtleactions/DictActions",
    "activity/blocks/RhythmBlocks",
    "activity/blocks/MeterBlocks",
    "activity/blocks/PitchBlocks",
    "activity/blocks/IntervalsBlocks",
    "activity/blocks/ToneBlocks",
    "activity/blocks/OrnamentBlocks",
    "activity/blocks/VolumeBlocks",
    "activity/blocks/DrumBlocks",
    "activity/blocks/WidgetBlocks",
    "activity/blocks/RhythmBlockPaletteBlocks",
    "activity/blocks/ActionBlocks",
    "activity/blocks/FlowBlocks",
    "activity/blocks/NumberBlocks",
    "activity/blocks/BoxesBlocks",
    "activity/blocks/BooleanBlocks",
    "activity/blocks/HeapBlocks",
    "activity/blocks/DictBlocks",
    "activity/blocks/ExtrasBlocks",
    "activity/blocks/ProgramBlocks",
    "activity/blocks/GraphicsBlocks",
    "activity/blocks/PenBlocks",
    "activity/blocks/MediaBlocks",
    "activity/blocks/SensorsBlocks",
    "activity/blocks/EnsembleBlocks",
    "widgets/widgetWindows",
    "widgets/statistics",
    "widgets/jseditor"
];

if (_THIS_IS_MUSIC_BLOCKS_) {
    const MUSICBLOCKS_EXTRAS = [
        "widgets/modewidget",
        "widgets/meterwidget",
        "widgets/PhraseMakerUtils",
        "widgets/PhraseMakerGrid",
        "widgets/PhraseMakerUI",
        "widgets/PhraseMakerAudio",
        "widgets/phrasemaker",
        "widgets/arpeggio",
        "widgets/aiwidget",
        "widgets/aidebugger",
        "widgets/pitchdrummatrix",
        "widgets/rhythmruler",
        "widgets/pitchstaircase",
        "widgets/temperament",
        "widgets/tempo",
        "widgets/pitchslider",
        "widgets/musickeyboard",
        "widgets/timbre",
        "widgets/oscilloscope",
        "widgets/sampler",
        "widgets/reflection",
        "widgets/legobricks",
        "activity/lilypond",
        "activity/abc",
        "activity/midi",
        "activity/mxml"
    ];
    MYDEFINES = MYDEFINES.concat(MUSICBLOCKS_EXTRAS);
}

// Module-scoped singleton reference to the active Activity instance.
// • Used by plugins (weather.rtp, etc.) that are eval()'d inside this module's
//   closure scope and therefore can close over `globalActivity` directly.
// • External modules (synthutils, etc.) should use ActivityContext.getActivity()
//   instead of reaching through window.* globals.
let globalActivity;

/**
 * Performs analysis on the project using the global activity.
 * @returns {object} - The analysis result.
 */
const doAnalyzeProject = function () {
    return analyzeProject(globalActivity);
};

/**
 * Represents an activity in the application.
 */
class Activity {
    /**
     * Creates an Activity instance.
     */
    constructor() {
        globalActivity = this;

        // Register with ActivityContext – the single authority for the Activity singleton.
        // activity-context.js is declared as a RequireJS dep of this module (loader.js shim),
        // so window.ActivityContext is guaranteed to exist before this constructor runs.
        if (window.ActivityContext && typeof window.ActivityContext.setActivity === "function") {
            window.ActivityContext.setActivity(this);
        }

        this._listeners = [];

        this.cellSize = 55;
        this.searchSuggestions = [];
        this.homeButtonContainer;

        this.msgTimeoutID = null;
        this.msgText = null;
        this.errorMsgTimeoutID = null;
        this.errorMsgText = null;
        this.errorMsgArrow = null;
        this.errorArtwork = {};

        this.cartesianBitmap = null;
        this.polarBitmap = null;
        this.trebleBitmap = null;
        this.trebleSharpBitmap = [null, null, null, null, null, null, null];
        this.trebleFlatBitmap = [null, null, null, null, null, null, null];
        this.grandBitmap = null;
        this.grandSharpBitmap = [null, null, null, null, null, null, null];
        this.grandFlatBitmap = [null, null, null, null, null, null, null];
        this.sopranoBitmap = null;
        this.sopranoSharpBitmap = [null, null, null, null, null, null, null];
        this.sopranoFlatBitmap = [null, null, null, null, null, null, null];
        this.altoBitmap = null;
        this.altoSharpBitmap = [null, null, null, null, null, null, null];
        this.altoFlatBitmap = [null, null, null, null, null, null, null];
        this.tenorBitmap = null;
        this.tenorSharpBitmap = [null, null, null, null, null, null, null];
        this.tenorFlatBitmap = [null, null, null, null, null, null, null];
        this.bassBitmap = null;
        this.bassSharpBitmap = [null, null, null, null, null, null, null];
        this.bassFlatBitmap = [null, null, null, null, null, null, null];

        const ERRORARTWORK = [
            "emptybox",
            "emptyheap",
            "negroot",
            "noinput",
            "zerodivide",
            "notanumber",
            "nostack",
            "notastring",
            "nomicrophone"
        ];

        /* Global bridge functions for inline HTML event handlers.
         * Inline onclick attributes require functions to exist on the global
         * window object. These wrappers safely delegate the calls to the
         * active Activity instance, keeping UI logic within Activity.
         */
        window.hidePrintText = () => {
            if (globalActivity) {
                globalActivity.hidePrintText();
            }
        };

        window.hideErrorText = () => {
            if (globalActivity) {
                globalActivity.hideErrorText();
            }
        };

        this.saveLocally = null;
        this.scrollBlockContainer = false;
        this.blockRefreshCanvas = false;
        this.statsWindow = null;

        this.firstTimeUser = false;
        this.beginnerMode = false;
        this.runMode = "normal";

        // Flag to disable keyboard during loading of MB
        this.keyboardEnableFlag;
        this.inTempoWidget = false;
        this.projectID = null;
        this.storage = localStorage;

        // Flag to indicate whether the user is performing a 2D drag operation.
        this.isDragging = false;

        // Flag to indicate whether user is selecting
        this.isSelecting = false;

        // Flag to indicate the selection mode is on
        this.selectionModeOn = false;

        // Flag to check if the helpful search widget is active or not (for "click" event handler purpose)
        this.isHelpfulSearchWidgetOn = false;

        //Flag to check if any other input box is active or not
        this.isInputON = false;

        // Interval ID for the loading animation (to allow cleanup)
        this.loadAnimationIntervalId = null;

        // Initialize GIF animator
        if (typeof GIFAnimator !== "undefined") {
            this.gifAnimator = new GIFAnimator();
        } else {
            // eslint-disable-next-line no-console
            console.debug("GIFAnimator not yet available in constructor");
            this.gifAnimator = null;
        }

        // Dirty flag for canvas rendering optimization
        // When true, the stage needs to be redrawn on the next animation frame
        this.stageDirty = false;

        this.themes = ["light", "dark"];
        try {
            // Detect system theme preference (using same logic as ThemeBox)
            const getSystemTheme = () => {
                if (
                    window.matchMedia &&
                    window.matchMedia("(prefers-color-scheme: dark)").matches
                ) {
                    return "dark";
                }
                return "light";
            };

            // Use stored preference, fallback to system preference
            const activeTheme = this.storage.themePreference || getSystemTheme();

            for (let i = 0; i < this.themes.length; i++) {
                if (this.themes[i] === activeTheme) {
                    body.classList.add(this.themes[i]);
                } else {
                    body.classList.remove(this.themes[i]);
                }
            }
        } catch (e) {
            console.error("Error accessing themePreference storage:", e);
        }

        this.beginnerMode = true;
        try {
            if (this.storage.beginnerMode === undefined) {
                this.firstTimeUser = true;
            } else if (this.storage.beginnerMode !== null) {
                this.beginnerMode = this.storage.beginnerMode;
                if (typeof this.beginnerMode === "string") {
                    if (this.beginnerMode === "false") {
                        this.beginnerMode = false;
                    }
                }
            }
        } catch (e) {
            // eslint-disable-next-line no-console
            console.error(e);
        }

        try {
            let lang = "en";
            if (this.storage.languagePreference !== undefined) {
                lang = this.storage.languagePreference;
                if (lang.startsWith("ja")) lang = "ja"; // normalize Japanese
                i18next.changeLanguage(lang);
            } else {
                lang = navigator.language;
                if (lang.includes("-")) {
                    lang = lang.slice(0, lang.indexOf("-"));
                }
                i18next.changeLanguage(lang);
            }
        } catch (e) {
            console.error(e);
        }

        this.KeySignatureEnv = ["C", "major", false];
        try {
            if (this.storage.KeySignatureEnv !== undefined) {
                this.KeySignatureEnv = this.storage.KeySignatureEnv.split(",");
                this.KeySignatureEnv[2] = this.KeySignatureEnv[2] === "true";
            }
        } catch (e) {
            // eslint-disable-next-line no-console
            console.error(e);
        }

        /**
         * Initialises major variables and renders default stack.
         * Sets up the initial state and dependencies of the activity.
         */
        this.setupDependencies = () => {
            this.cleanupEventListeners();
            createDefaultStack();
            createHelpContent(this);
            window.scroll(0, 0);

            document.title = TITLESTRING;
            this.canvas = document.getElementById("myCanvas");

            // Set up a file chooser for the doOpen function.
            this.fileChooser = document.getElementById("myOpenFile");
            // Set up a file chooser for the doOpenPlugin function.
            this.pluginChooser = document.getElementById("myOpenPlugin");
            // The file chooser for all files
            this.allFilesChooser = document.getElementById("myOpenAll");
            this.auxToolbar = document.getElementById("aux-toolbar");
            // Error message containers
            this.errorText = document.getElementById("errorText");
            this.errorTextContent = document.getElementById("errorTextContent");
            // Hide Arrow on hiding error message
            this.addEventListener(this.errorText, "click", this._hideArrows);
            // Show and populate the printText div.
            this.printText = document.getElementById("printText");
            this.printTextContent = document.getElementById("printTextContent");

            // Are we running off of a server?
            this.server = true;
            this.turtleBlocksScale = 1;
            this.mousestage = null;
            this.stage = null;
            this.turtles = null;
            this.palettes = null;
            this.blocks = null;
            this.logo = null;
            this.gif = null;
            this.pasteBox = null;
            this.languageBox = null;
            this.themeBox = null;
            this.planet = null;
            window.converter = null;
            this.buttonsVisible = true;
            this.headerContainer = null;
            this.swiping = false;
            this.menuButtonsVisible = false;
            this.scrollBlockContainer = false;
            this.currentKeyCode = 0;
            this.merging = false;
            this.loading = false;
            // On-screen buttons
            this.smallerContainer = null;
            this.largerContainer = null;
            this.resizeDebounce = false;
            this.hideBlocksContainer = null;
            this.collapseBlocksContainer = null;

            this.searchWidget = document.getElementById("search");
            this.searchWidget.style.visibility = "hidden";
            this.searchWidget.placeholder = _("Search for blocks");

            this.helpfulSearchWidget = document.createElement("input");
            this.helpfulSearchWidget.setAttribute("id", "helpfulSearch");
            this.helpfulSearchWidget.style.visibility = "hidden";
            this.helpfulSearchWidget.placeholder = _("Search for blocks");
            this.helpfulSearchWidget.classList.add("ui-autocomplete");
            this.progressBar = document.getElementById("myProgress");
            this.progressBar.style.visibility = "hidden";

            new createjs.DOMElement(document.getElementById("paste"));
            this.paste = document.getElementById("paste");
            this.paste.style.visibility = "hidden";

            this.toolbarHeight = document.getElementById("toolbars").offsetHeight;

            this.helpfulWheelItems = [];

            this.setHelpfulSearchDiv();

            // Late initialization of GIF animator if it was missed in constructor
            if (!this.gifAnimator && typeof GIFAnimator !== "undefined") {
                this.gifAnimator = new GIFAnimator();
            }
        };

        /*
         * Optimized canvas rendering using dirty flag pattern.
         * The stage only updates when:
         * 1. stageDirty flag is set (something changed)
         * 2. Active tweens are running
         * 3. GIF animations are playing
         * This eliminates unnecessary 60fps updates when idle.
         */
        const renderLoop = () => {
            if (this.stage) {
                const hasActiveTweens = createjs.Tween.hasActiveTweens();
                const hasActiveGifs = this.gifAnimator && this.gifAnimator.getActiveCount() > 0;

                if (this.stageDirty || hasActiveTweens || hasActiveGifs) {
                    this.stage.update();
                    this.stageDirty = false;
                }
            }
            requestAnimationFrame(renderLoop);
        };
        requestAnimationFrame(renderLoop);

        /*
         * creates helpfulSearchDiv for search
         */
        this.setHelpfulSearchDiv = () => {
            if (document.getElementById("helpfulSearchDiv")) {
                document
                    .getElementById("helpfulSearchDiv")
                    .parentNode.removeChild(document.getElementById("helpfulSearchDiv"));
            }
            this.helpfulSearchDiv = document.createElement("div");
            this.helpfulSearchDiv.setAttribute("id", "helpfulSearchDiv");

            document.body.appendChild(this.helpfulSearchDiv);

            // Create the div for the close button (cross button)
            const closeButtonDiv = document.createElement("div");
            closeButtonDiv.style.cssText =
                "position: absolute;" + "top: 10px;" + "right: 10px;" + "cursor: pointer;";

            // Create the cross button itself
            const closeButton = document.createElement("button");
            closeButton.textContent = "×";
            closeButton.id = "crossButton";
            document.body.appendChild(closeButton);

            closeButtonDiv.appendChild(closeButton);

            this.helpfulSearchDiv.appendChild(closeButtonDiv);

            // Add event listener to remove the search div from the DOM
            const modeButton = document.getElementById("begIconText");
            this.addEventListener(closeButton, "click", this._hideHelpfulSearchWidget);
            this.addEventListener(modeButton, "click", this._hideHelpfulSearchWidget);

            this.helpfulSearchDiv.appendChild(this.helpfulSearchWidget);
        };

        /*
         * displays helpfulSearchDiv on canvas
         */
        this._displayHelpfulSearchDiv = () => {
            if (!document.getElementById("helpfulSearchDiv")) {
                this.setHelpfulSearchDiv(); // Re-create and append the div if it's not found
            }
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            this.helpfulSearchDiv.style.left =
                helpfulWheelDiv.offsetLeft + 80 * this.getStageScale() + "px";
            this.helpfulSearchDiv.style.top =
                helpfulWheelDiv.offsetTop + 110 * this.getStageScale() + "px";

            const windowWidth = window.innerWidth;
            const windowHeight = window.innerHeight;
            this.helpfulSearchDiv.style.display = "block";
            const menuWidth = this.helpfulSearchDiv.offsetWidth;
            const menuHeight = this.helpfulSearchDiv.offsetHeight;

            if (this.helpfulSearchDiv.offsetLeft + menuWidth > windowWidth) {
                this.helpfulSearchDiv.style.left = windowWidth - menuWidth + "px";
            }
            if (this.helpfulSearchDiv.offsetTop + menuHeight > windowHeight) {
                this.helpfulSearchDiv.style.top = windowHeight - menuHeight + "px";
            }

            this.showHelpfulSearchWidget();
            this.isHelpfulSearchWidgetOn = true;
        };

        // hides helpfulSearchDiv on canvas

        this._hideHelpfulSearchWidget = e => {
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
            }
            if (this.helpfulSearchDiv && this.helpfulSearchDiv.parentNode) {
                this.helpfulSearchDiv.parentNode.removeChild(this.helpfulSearchDiv);
            }
            that.__tick();
        };

        /*
         * Sets up right click functionality opening the context menus
         * (if block is right clicked)
         */
        this.doContextMenus = () => {
            this.addEventListener(
                document,
                "contextmenu",
                event => {
                    event.preventDefault();
                    event.stopPropagation();
                    if (this.beginnerMode) return;
                    if (this.isHelpfulSearchWidgetOn) {
                        this._hideHelpfulSearchWidget();
                    }
                    if (
                        !this.blocks.isCoordinateOnBlock(event.clientX, event.clientY) &&
                        event.target.id === "myCanvas"
                    ) {
                        this._displayHelpfulWheel(event);
                    }
                },
                false
            );
        };

        /*
         * displays helpfulWheel on canvas on right click
         */
        this._displayHelpfulWheel = event => {
            // Cache DOM element reference for performance (7 lookups reduced to 1)
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            helpfulWheelDiv.style.position = "absolute";

            const x = event.clientX;
            const y = event.clientY;

            const canvasLeft = this.canvas.offsetLeft + 28 * this.getStageScale();
            const canvasTop = this.canvas.offsetTop + 6 * this.getStageScale();

            const helpfulWheelLeft = Math.max(
                Math.round(x * this.getStageScale() + canvasLeft) - 150,
                canvasLeft
            );
            const helpfulWheelTop = Math.max(
                Math.round(y * this.getStageScale() + canvasTop) - 150,
                canvasTop
            );

            helpfulWheelDiv.style.left = helpfulWheelLeft + "px";

            helpfulWheelDiv.style.top = helpfulWheelTop + "px";

            const windowWidth = window.innerWidth - 20;
            const windowHeight = window.innerHeight - 20;

            if (helpfulWheelLeft + 350 > windowWidth) {
                helpfulWheelDiv.style.left = windowWidth - 350 + "px";
            }
            if (helpfulWheelTop + 350 > windowHeight) {
                helpfulWheelDiv.style.top = windowHeight - 350 + "px";
            }

            helpfulWheelDiv.style.display = "";

            const wheel = new wheelnav("helpfulWheelDiv", null, 300, 300);
            wheel.colors = platformColor.wheelcolors;
            wheel.slicePathFunction = slicePath().DonutSlice;
            wheel.slicePathCustom = slicePath().DonutSliceCustomization();
            wheel.slicePathCustom.minRadiusPercent = 0.45;
            wheel.slicePathCustom.maxRadiusPercent = 1.0;
            wheel.sliceSelectedPathCustom = wheel.slicePathCustom;
            wheel.sliceInitPathCustom = wheel.slicePathCustom;
            wheel.clickModeRotate = false;
            const wheelItems = this.helpfulWheelItems.filter(ele => ele.display);
            wheel.initWheel(wheelItems.map(ele => ele.icon));
            wheel.createWheel();

            wheel.navItems[0].selected = false;

            wheelItems.forEach((ele, i) => {
                wheel.navItems[i].setTooltip(_(ele.label));
                wheel.navItems[i].navigateFunction = () => ele.fn(this);
            });
            const closeHelpfulWheel = e => {
                const isClickInside = helpfulWheelDiv.contains(e.target);
                if (!isClickInside) {
                    helpfulWheelDiv.style.display = "none";
                    this.removeEventListener(document, "click", closeHelpfulWheel);
                }
            };

            this.addEventListener(document, "click", closeHelpfulWheel);
        };

        /**
         * Sets up plugin and palette boilerplate.
         * This function initializes various properties related to the plugin objects,
         * palette colors, and other settings used throughout the application.
         */
        this.doPluginsAndPaletteCols = () => {
            // Calculate the palette colors.
            for (const p in platformColor.paletteColors) {
                PALETTEFILLCOLORS[p] = platformColor.paletteColors[p][0];
                PALETTESTROKECOLORS[p] = platformColor.paletteColors[p][1];
                PALETTEHIGHLIGHTCOLORS[p] = platformColor.paletteColors[p][2];
                HIGHLIGHTSTROKECOLORS[p] = platformColor.paletteColors[p][1];
            }

            this.pluginObjs = {
                PALETTEPLUGINS: {},
                PALETTEFILLCOLORS: {},
                PALETTESTROKECOLORS: {},
                PALETTEHIGHLIGHTCOLORS: {},
                FLOWPLUGINS: {},
                ARGPLUGINS: {},
                BLOCKPLUGINS: {},
                MACROPLUGINS: {},
                ONLOAD: {},
                ONSTART: {},
                ONSTOP: {}
            };

            // Stacks of blocks saved in local storage
            this.macroDict = {};

            // default values
            this.DEFAULTDELAY = 500; // milleseconds
            this.TURTLESTEP = -1; // Run in step-by-step mode
            this.blockscale = BLOCKSCALES.indexOf(DEFAULTBLOCKSCALE);
            if (this.blockscale === -1) {
                this.blockscale = 1;
            }

            // Used to track mouse state for mouse button block
            this.stageMouseDown = false;
            this.stageX = 0;
            this.stageY = 0;

            // OLPC hardware
            const onXO =
                (screen.width === 1200 && screen.height === 900) ||
                (screen.width === 900 && screen.height === 1200);

            this.cellSize = 55;
            if (onXO) {
                this.cellSize = 75;
            }

            this.onscreenButtons = [];
            this.onscreenMenu = [];

            this.firstRun = true;

            this.pluginsImages = {};
        };

        /**
         * Recenters blocks by updating their position on the screen.
         *
         * This function triggers the `_findBlocks` method on the provided `activity` object,
         * which recalculates the positions of blocks. If the 'helpfulWheelDiv' element is visible,
         * it is hidden, and the `__tick` method is called to update the activity state.
         *
         * @param {Object} activity - The activity instance containing the blocks to recenter.
         * @constructor
         */
        const findBlocks = activity => {
            activity._findBlocks();
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
                activity.__tick();
            }
        };

        /**
         * Ensures blocks stay within canvas boundaries when resized.
         * Ensures that music blocks are responsive to horizontal resizing.
         * Ensures that overall integrity of blocks isn't hampered with.
         */
        function repositionBlocks(activity) {
            const canvasWidth = window.innerWidth;
            const processedBlocks = new Set();

            //Array for storing individual dragGroups (the chunks of code linked together which are not connected)
            const dragGroups = [];

            // Identifying individual dragGroups
            Object.values(activity.blocks.blockList).forEach(block => {
                if (!processedBlocks.has(block.id)) {
                    activity.blocks.findDragGroup(block.id);

                    if (activity.blocks.dragGroup.length > 0) {
                        dragGroups.push([...activity.blocks.dragGroup]); // Store the group into dragGroups
                        activity.blocks.dragGroup.forEach(id => processedBlocks.add(id)); // Process individual groups
                    }
                }
            });

            // Repositioning of dragGroups according to horizontal resizing
            dragGroups.forEach(group => {
                const referenceBlock = activity.blocks.blockList[group[0]];

                // Store initial positions
                if (!referenceBlock.initialPosition) {
                    referenceBlock.initialPosition = {
                        x: referenceBlock.container.x,
                        y: referenceBlock.container.y
                    };
                }

                if (
                    canvasWidth < RESPONSIVE_BREAKPOINT_TABLET &&
                    !referenceBlock.beforeMobilePosition
                ) {
                    referenceBlock.beforeMobilePosition = {
                        x: referenceBlock.container.x,
                        y: referenceBlock.container.y
                    };
                }

                if (
                    canvasWidth >= RESPONSIVE_BREAKPOINT_TABLET &&
                    referenceBlock.beforeMobilePosition
                ) {
                    const dx = referenceBlock.beforeMobilePosition.x - referenceBlock.container.x;
                    const dy = referenceBlock.beforeMobilePosition.y - referenceBlock.container.y;
                    group.forEach(blockId => {
                        const block = activity.blocks.blockList[blockId];
                        block.container.x += dx;
                        block.container.y += dy;
                    });
                    referenceBlock.beforeMobilePosition = null; // Clear stored position
                    //this prevents old groups from affecting new calculations.
                }

                if (
                    canvasWidth < RESPONSIVE_BREAKPOINT_MOBILE &&
                    !referenceBlock.before600pxPosition
                ) {
                    referenceBlock.before600pxPosition = {
                        x: referenceBlock.container.x,
                        y: referenceBlock.container.y
                    };
                }

                if (
                    canvasWidth >= RESPONSIVE_BREAKPOINT_MOBILE &&
                    referenceBlock.before600pxPosition
                ) {
                    const dx = referenceBlock.before600pxPosition.x - referenceBlock.container.x;
                    const dy = referenceBlock.before600pxPosition.y - referenceBlock.container.y;

                    group.forEach(blockId => {
                        const block = activity.blocks.blockList[blockId];
                        block.container.x += dx;
                        block.container.y += dy;
                    });
                    referenceBlock.before600pxPosition = null;
                }

                // Ensure blocks stay within horizontal boundary
                const rightmostX = Math.max(
                    ...group.map(
                        id =>
                            activity.blocks.blockList[id].container.x +
                            activity.blocks.blockList[id].width
                    )
                );

                if (rightmostX > canvasWidth) {
                    const shiftX = Math.max(10, canvasWidth - rightmostX - 10);

                    group.forEach(blockId => {
                        activity.blocks.blockList[blockId].container.x += shiftX;
                    });
                }

                // Ensures that blocks do not go hide behind the search for blocks div
                const leftmostX = Math.min(
                    ...group.map(id => activity.blocks.blockList[id].container.x)
                );
                if (leftmostX < 0) {
                    const shiftX = 100 - leftmostX;

                    group.forEach(blockId => {
                        activity.blocks.blockList[blockId].container.x += shiftX;
                    });
                }
            });

            activity._findBlocks();
        }

        //if any window resize event occurs:
        this._handleRepositionBlocksOnResize = () => repositionBlocks(this);
        this.addEventListener(window, "resize", this._handleRepositionBlocksOnResize);

        /**
         * Finds and organizes blocks within the workspace.
         * Arranges blocks in grid format on wide screens and vertically on narrow screens.
         */
        this._findBlocks = () => {
            if (!this.blocks.visible) {
                this._changeBlockVisibility();
            }

            this.blocks.activeBlock = null;
            hideDOMLabel();
            this.blocks.showBlocks();
            this.blocksContainer.x = 0;
            this.blocksContainer.y = 0;

            const screenWidth = window.innerWidth;
            const isNarrowScreen = screenWidth < RESPONSIVE_BREAKPOINT_MOBILE;
            const minColumnWidth = 400;
            const numColumns = isNarrowScreen ? 1 : Math.floor(screenWidth / minColumnWidth);

            const toppos = this.auxToolbar.style.display === "block" ? 90 + this.toolbarHeight : 90;
            const x = isNarrowScreen
                ? Math.floor(screenWidth / 2)
                : Math.floor(this.canvas.width / 4);
            let y = Math.floor(toppos * this.turtleBlocksScale);
            const verticalSpacing = Math.floor(40 * this.turtleBlocksScale);

            const columnSpacing = (screenWidth / numColumns) * 1.2;
            const columnXPositions = Array.from({ length: numColumns }, (_, i) =>
                Math.floor(i * columnSpacing + columnSpacing / 2)
            );
            const columnYPositions = Array(numColumns).fill(y);

            for (const blk in this.blocks.blockList) {
                if (!this.blocks.blockList[blk].trash) {
                    const myBlock = this.blocks.blockList[blk];

                    // Store original position only once
                    if (!myBlock.originalPosition) {
                        myBlock.originalPosition = {
                            x: myBlock.container.x,
                            y: myBlock.container.y
                        };
                    }

                    if (myBlock.connections[0] === null) {
                        if (isNarrowScreen) {
                            const dx = x - myBlock.container.x;
                            const dy = y - myBlock.container.y;
                            this.blocks.moveBlockRelative(blk, dx, dy);
                            y += myBlock.height + verticalSpacing;
                        } else {
                            const minYIndex = columnYPositions.indexOf(
                                Math.min(...columnYPositions)
                            );
                            const dx = columnXPositions[minYIndex] - myBlock.container.x;
                            const dy = columnYPositions[minYIndex] - myBlock.container.y;
                            this.blocks.moveBlockRelative(blk, dx, dy);
                            columnYPositions[minYIndex] += myBlock.height + verticalSpacing;
                        }
                    }

                    // Making code to make sure that
                    if (myBlock.connections.length > 0) {
                        myBlock.connections.forEach(conn => {
                            if (conn !== null) {
                                const innerBlock = this.blocks.blockList[conn];
                                if (innerBlock) {
                                    innerBlock.container.x =
                                        myBlock.container.x + innerBlock.relativeX;
                                    innerBlock.container.y =
                                        myBlock.container.y + innerBlock.relativeY;
                                }
                            }
                        });
                    }
                }
            }

            repositionBlocks(this);
            this.setHomeContainers(false);
            this.boundary.hide();

            for (let turtle = 0; turtle < this.turtles.turtleList.length; turtle++) {
                const savedPenState = this.turtles.turtleList[turtle].painter.penState;
                this.turtles.turtleList[turtle].painter.penState = false;
                this.turtles.turtleList[turtle].painter.doSetXY(0, 0);
                this.turtles.turtleList[turtle].painter.doSetHeading(0);
                this.turtles.turtleList[turtle].painter.penState = savedPenState;
            }
        };

        /**
         * Finds and organizes blocks within the workspace.
         * Blocks are positioned based on their connections and availability within the canvas area.
         * This method is part of the internal mechanism to ensure that blocks are displayed correctly and efficiently.
         * @constructor
         */
        // Flag to track number of clicks and for alternate mode switching while clicking
        this._isFirstHomeClick = true;

        this._findBlocks = () => {
            // Ensure visibility of blocks
            if (!this.blocks.visible) {
                this._changeBlockVisibility();
            }

            // Reset active block and hide DOM label
            this.blocks.activeBlock = null;
            hideDOMLabel();

            // Show blocks and set initial container position
            this.blocks.showBlocks();
            this.blocksContainer.x = 0;
            this.blocksContainer.y = 0;

            if (this._isFirstHomeClick) {
                // First clicked logic (arrange blocks in rows may have overlapping of blocks)
                let toppos;
                if (this.auxToolbar.style.display === "block") {
                    toppos = 90 + this.toolbarHeight;
                } else {
                    toppos = 90;
                }
                const leftpos = Math.floor(this.canvas.width / 4);

                this.palettes.updatePalettes();
                let x = Math.floor(leftpos * this.turtleBlocksScale);
                let y = Math.floor(toppos * this.turtleBlocksScale);
                let even = true;

                // Position "start" blocks first
                for (const blk in this.blocks.blockList) {
                    if (!this.blocks.blockList[blk].trash) {
                        const myBlock = this.blocks.blockList[blk];
                        if (myBlock.name !== "start") {
                            continue;
                        }
                        if (myBlock.connections[0] === null) {
                            const dx = x - myBlock.container.x;
                            const dy = y - myBlock.container.y;
                            this.blocks.moveBlockRelative(blk, dx, dy);
                            this.blocks.findDragGroup(blk);

                            if (this.blocks.dragGroup.length > 0) {
                                for (let b = 0; b < this.blocks.dragGroup.length; b++) {
                                    const bblk = this.blocks.dragGroup[b];
                                    if (b !== 0) {
                                        this.blocks.moveBlockRelative(bblk, dx, dy);
                                    }
                                }
                            }

                            x += Math.floor(150 * this.turtleBlocksScale);
                            if (x > (this.canvas.width * 7) / 8 / this.turtleBlocksScale) {
                                even = !even;
                                if (even) {
                                    x = Math.floor(leftpos);
                                } else {
                                    x = Math.floor(leftpos + STANDARDBLOCKHEIGHT);
                                }
                                y += STANDARDBLOCKHEIGHT;
                            }
                        }
                    }
                }

                // Position other blocks
                for (const blk in this.blocks.blockList) {
                    if (!this.blocks.blockList[blk].trash) {
                        const myBlock = this.blocks.blockList[blk];
                        if (myBlock.name === "start") {
                            continue;
                        }
                        if (myBlock.connections[0] === null) {
                            const dx = x - myBlock.container.x;
                            const dy = y - myBlock.container.y;
                            this.blocks.moveBlockRelative(blk, dx, dy);
                            this.blocks.findDragGroup(blk);

                            if (this.blocks.dragGroup.length > 0) {
                                for (let b = 0; b < this.blocks.dragGroup.length; b++) {
                                    const bblk = this.blocks.dragGroup[b];
                                    if (b !== 0) {
                                        this.blocks.moveBlockRelative(bblk, dx, dy);
                                    }
                                }
                            }

                            x += Math.floor(150 * this.turtleBlocksScale);
                            if (x > (this.canvas.width * 7) / 8 / this.turtleBlocksScale) {
                                even = !even;
                                if (even) {
                                    x = Math.floor(leftpos);
                                } else {
                                    x = Math.floor(leftpos + STANDARDBLOCKHEIGHT);
                                }
                                y += STANDARDBLOCKHEIGHT;
                            }
                        }
                    }
                }
            } else {
                // Second click logic (arrange blocks in columns this avoid overlapping of blocks)
                let toppos;
                if (this.auxToolbar.style.display === "block") {
                    toppos = 90 + this.toolbarHeight;
                } else {
                    toppos = 90;
                }

                /**
                 * Device type resolution ranges and typical orientation:
                 * Desktop: 1024x768 to 5120x2880 (Landscape primary, Portrait supported)
                 * Tablet: 768x1024 to 2560x1600 (Portrait common, Landscape supported)
                 * Mobile: 320x480 to 1440x3200 (Portrait primary, Landscape supported)
                 * Minimum column width is set to 400px to ensure readability and usability.
                 */

                const screenWidth = window.innerWidth;
                const minColumnWidth = 320;
                const numColumns =
                    screenWidth <= 320 ? 1 : Math.floor(screenWidth / minColumnWidth);

                const baseColumnSpacing = screenWidth / numColumns;
                const columnSpacing = baseColumnSpacing * 1.2;

                const initialY = Math.floor(toppos * this.turtleBlocksScale);
                const baseVerticalSpacing = Math.floor(20 * this.turtleBlocksScale);
                const verticalSpacing = baseVerticalSpacing * 1.2;

                const columnXPositions = Array.from({ length: numColumns }, (_, i) =>
                    Math.floor(i * columnSpacing + columnSpacing / 2)
                );
                const columnYPositions = Array(numColumns).fill(initialY);

                for (const blk in this.blocks.blockList) {
                    if (!this.blocks.blockList[blk].trash) {
                        const myBlock = this.blocks.blockList[blk];
                        if (myBlock.connections[0] === null) {
                            let minYIndex = 0;
                            for (let i = 1; i < numColumns; i++) {
                                if (columnYPositions[i] < columnYPositions[minYIndex]) {
                                    minYIndex = i;
                                }
                            }

                            const dx = columnXPositions[minYIndex] - myBlock.container.x;
                            const dy = columnYPositions[minYIndex] - myBlock.container.y;
                            this.blocks.moveBlockRelative(blk, dx, dy);
                            this.blocks.findDragGroup(blk);

                            if (this.blocks.dragGroup.length > 0) {
                                for (let b = 0; b < this.blocks.dragGroup.length; b++) {
                                    const bblk = this.blocks.dragGroup[b];
                                    if (b !== 0) {
                                        this.blocks.moveBlockRelative(bblk, dx, dy);
                                    }
                                }
                            }
                            columnYPositions[minYIndex] += myBlock.height + verticalSpacing;
                        }
                    }
                }
            }

            // Reset go-home button
            this.setHomeContainers(false);
            this.boundary.hide();

            // Return mice to the center of the screen.
            // Reset turtles' positions to center of the screen
            for (let turtle = 0; turtle < this.turtles.getTurtleCount(); turtle++) {
                const requiredTurtle = this.turtles.getTurtle(turtle);
                const savedPenState = requiredTurtle.painter.penState;
                requiredTurtle.painter.penState = false;
                requiredTurtle.painter.doSetXY(0, 0);
                requiredTurtle.painter.doSetHeading(0);
                requiredTurtle.painter.penState = savedPenState;
            }
            // Alternate mode switching on clicking Home button
            this._isFirstHomeClick = !this._isFirstHomeClick;
        };

        /**
         * Toggles the visibility of the home button container.
         *
         * Depending on the state provided, this method will either hide or show the home button container.
         * If the home button container is not initialized, the function will exit early.
         *
         * @param {boolean} homeState - If true, shows the container; if false, hides it.
         * @constructor
         */
        this.setHomeContainers = homeState => {
            if (this.homeButtonContainer === null || this.homeButtonContainer === undefined) {
                return;
            }

            if (homeState) {
                changeImage(this.homeButtonContainer.children[0], GOHOMEFADEDBUTTON, GOHOMEBUTTON);
            } else {
                changeImage(this.homeButtonContainer.children[0], GOHOMEBUTTON, GOHOMEFADEDBUTTON);
            }
        };

        /**
         * Saves the artwork for an individual help block.
         * The process involves clearing the block list, generating the help blocks,
         * and saving them as SVG files.
         *
         * @param {string} name - The name of the help block.
         * @param {number} delay - The delay before executing the save process (in milliseconds).
         */
        this.__saveHelpBlock = (name, delay) => {
            // Save the artwork for an individual help block.
            // (1) clear the block list
            // (2) generate the help blocks
            // (3) save the blocks as svg

            const that = this;
            setTimeout(() => {
                that.sendAllToTrash(false, true);
                setTimeout(() => {
                    const message = that.blocks.protoBlockDict[name].helpString;
                    if (message.length < 4) {
                        // If there is nothing specified, just load the block.
                        const obj = that.palettes.getProtoNameAndPalette(name);
                        const protoblk = obj[0];
                        const paletteName = obj[1];
                        const protoName = obj[2];
                        // eslint-disable-next-line no-prototype-builtins
                        if (that.blocks.protoBlockDict.hasOwnProperty(protoName)) {
                            that.palettes.dict[paletteName].makeBlockFromSearch(
                                protoblk,
                                protoName,
                                newBlock => {
                                    that.blocks.moveBlock(newBlock, 0, 0);
                                }
                            );
                        }
                    } else if (typeof message[3] === "string") {
                        // If it is a string, load the macro associated with this block.
                        const blocksToLoad = getMacroExpansion(that, message[3], 0, 0);
                        that.blocks.loadNewBlocks(blocksToLoad);
                    } else {
                        // Load the block.
                        const blocksToLoad = message[3];
                        that.blocks.loadNewBlocks(blocksToLoad);
                    }

                    setTimeout(() => {
                        // eslint-disable-next-line no-console
                        console.log("Saving help artwork: " + name + "_block.svg");
                        const svg = "data:image/svg+xml;utf8," + that.printBlockSVG();
                        that.save.download("svg", svg, name + "_block.svg");
                    }, 500);
                }, 500);
            }, delay + 1000);
        };

        this._saveHelpBlocks = () => {
            // Save the artwork for every help block.
            const blockHelpList = [];
            for (const key in this.blocks.protoBlockDict) {
                if (
                    this.blocks.protoBlockDict[key].helpString !== undefined &&
                    this.blocks.protoBlockDict[key].helpString.length !== 0
                ) {
                    blockHelpList.push(key);
                }
            }

            let i = 0;
            for (const name in blockHelpList) {
                this.__saveHelpBlock(blockHelpList[name], i * 2000);
                i += 1;
            }

            this.sendAllToTrash(true, true);
        };

        const extractSVGInner = svgString => {
            const parser = new DOMParser();
            const doc = parser.parseFromString(svgString, "image/svg+xml");
            const svgEl = doc.querySelector("svg");
            if (!svgEl) return "";

            // Remove drop shadow filters safely
            svgEl.querySelectorAll("[filter]").forEach(el => {
                el.removeAttribute("filter");
            });

            return svgEl.innerHTML;
        };

        /**
         * @returns {SVG} returns SVG of blocks
         */
        this.printBlockSVG = () => {
            this.blocks.activeBlock = null;
            let startCounter = 0;
            let svg = "";
            let xMax = 0;
            let yMax = 0;
            let parts;
            for (let i = 0; i < this.blocks.blockList.length; i++) {
                if (this.blocks.blockList[i].ignore()) {
                    continue;
                }

                if (this.blocks.blockList[i].container.x + this.blocks.blockList[i].width > xMax) {
                    xMax = this.blocks.blockList[i].container.x + this.blocks.blockList[i].width;
                }

                if (this.blocks.blockList[i].container.y + this.blocks.blockList[i].height > yMax) {
                    yMax = this.blocks.blockList[i].container.y + this.blocks.blockList[i].height;
                }

                const rawSVG = this.blocks.blockList[i].collapsed
                    ? this.blocks.blockCollapseArt[i]
                    : this.blocks.blockArt[i];

                if (this.blocks.blockList[i].isCollapsible()) {
                    svg += "<g>";
                }

                svg +=
                    '<g transform="translate(' +
                    this.blocks.blockList[i].container.x +
                    ", " +
                    this.blocks.blockList[i].container.y +
                    ')">';

                if (!SPECIALINPUTS.includes(this.blocks.blockList[i].name)) {
                    svg += extractSVGInner(rawSVG);
                } else {
                    // Safer SVG manipulation using DOM instead of string splitting
                    const parser = new DOMParser();
                    const doc = parser.parseFromString(rawSVG, "image/svg+xml");

                    // remove dropshadow filter if present
                    const filtered = doc.querySelector('[style*="filter:url(#dropshadow)"]');
                    if (filtered) {
                        filtered.style.filter = "";
                    }

                    // Find correct tspan to inject value (matches previous behaviour)
                    let target = null;

                    // 1) Prefer empty tspan (most block SVGs reserve this for value)
                    target = Array.from(doc.querySelectorAll("text tspan")).find(
                        t => !t.textContent || t.textContent.trim() === ""
                    );

                    // 2) Otherwise fallback to last tspan
                    if (!target) {
                        const tspans = doc.querySelectorAll("text tspan");
                        if (tspans.length) target = tspans[tspans.length - 1];
                    }

                    // 3) Final fallback to text node
                    if (!target) {
                        target = doc.querySelector("text");
                    }

                    if (target) {
                        const val = this.blocks.blockList[i].value;
                        target.textContent = typeof val === "string" ? _(val) : val;
                    }

                    // serialize without outer <svg> wrapper (matches previous behavior)
                    let serialized = new XMLSerializer().serializeToString(doc.documentElement);

                    // remove outer svg tags because original code skipped them
                    serialized = serialized.replace(/^<svg[^>]*>/, "").replace(/<\/svg>$/, "");

                    svg += serialized;
                }

                svg += "</g>";

                if (this.blocks.blockList[i].isCollapsible()) {
                    let y;
                    if (INLINECOLLAPSIBLES.includes(this.blocks.blockList[i].name)) {
                        y = this.blocks.blockList[i].container.y + 4;
                    } else {
                        y = this.blocks.blockList[i].container.y + 12;
                    }

                    svg +=
                        '<g transform="translate(' +
                        this.blocks.blockList[i].container.x +
                        ", " +
                        y +
                        ') scale(0.5 0.5)">';
                    if (this.blocks.blockList[i].collapsed) {
                        parts = EXPANDBUTTON.split("><");
                    } else {
                        parts = COLLAPSEBUTTON.split("><");
                    }

                    for (let p = 2; p < parts.length - 1; p++) {
                        svg += "<" + parts[p] + ">";
                    }

                    svg += "</g>";
                }

                if (this.blocks.blockList[i].name === "start") {
                    const x = this.blocks.blockList[i].container.x + 110;
                    const y = this.blocks.blockList[i].container.y + 12;
                    svg += '<g transform="translate(' + x + ", " + y + ') scale(0.4 0.4)">';

                    parts = TURTLESVG.replace(/fill_color/g, FILLCOLORS[startCounter])
                        .replace(/stroke_color/g, STROKECOLORS[startCounter])
                        .split("><");

                    startCounter += 1;
                    if (startCounter > 9) {
                        startCounter = 0;
                    }

                    for (let p = 2; p < parts.length - 1; p++) {
                        svg += "<" + parts[p] + ">";
                    }

                    svg += "</g>";
                }

                if (this.blocks.blockList[i].isCollapsible()) {
                    svg += "</g>";
                }
            }

            svg += "</svg>";

            return (
                '<svg xmlns="http://www.w3.org/2000/svg" width="' +
                xMax +
                '" height="' +
                yMax +
                '">' +
                encodeURIComponent(svg)
            );
        };

        /**
         * @returns {PNG} returns PNG of block artwork
         */
        this.printBlockPNG = async () => {
            // Setps to convert the SVG to PNG of BlockArtwork
            // Step 1: Generate the SVG content
            // Step 2: Create a Canvas element
            // Step 3: Convert SVG to an Image object
            // Step 4: Draw SVG on the Canvas and export as PNG

            const svgContent = this.printBlockSVG();
            const canvas = document.createElement("canvas");
            const ctx = canvas.getContext("2d");
            const parser = new DOMParser();
            const svgDoc = parser.parseFromString(decodeURIComponent(svgContent), "image/svg+xml");
            const svgElement = svgDoc.documentElement;
            const width = parseInt(svgElement.getAttribute("width"), 10);
            const height = parseInt(svgElement.getAttribute("height"), 10);
            canvas.width = width;
            canvas.height = height;
            const img = new Image();
            const svgBlob = new Blob([decodeURIComponent(svgContent)], {
                type: "image/svg+xml;charset=utf-8"
            });
            const url = URL.createObjectURL(svgBlob);
            return new Promise((resolve, reject) => {
                img.onload = () => {
                    ctx.drawImage(img, 0, 0);
                    URL.revokeObjectURL(url);
                    const pngDataUrl = canvas.toDataURL("image/png");
                    resolve(pngDataUrl);
                };
                img.onerror = err => {
                    URL.revokeObjectURL(url);
                    reject(err);
                };
                img.src = url;
            });
        };

        const midiImportBlocks = midi => {
            if (document.getElementById("import-midi")) return;

            const modal = document.createElement("div");
            modal.classList.add("modalBox");
            modal.id = "import-midi";
            const title = document.createElement("h2");
            title.textContent = _("Import MIDI");
            title.classList.add("modal-title");
            modal.appendChild(title);

            const container = document.createElement("div");
            container.classList.add("message-container");
            const message = document.createElement("p");
            message.textContent = _("Set the max blocks to generate :");
            message.classList.add("modal-message");
            container.appendChild(message);

            const select = document.createElement("select");
            select.classList.add("block-count-dropdown");

            // 12 choices for block generation (100 to 1200)
            for (let i = 1; i <= 12; i++) {
                const option = document.createElement("option");
                option.value = i * 100;
                option.textContent = i * 100;
                select.appendChild(option);
            }

            container.appendChild(select);
            modal.appendChild(container);

            const importConfirm = document.createElement("button");
            importConfirm.classList.add("confirm-button");
            importConfirm.textContent = _("Confirm");
            importConfirm.addEventListener("click", () => {
                const maxNoteBlocks = select.value;
                transcribeMidi(midi, maxNoteBlocks);
                document.body.removeChild(modal);
            });
            modal.appendChild(importConfirm);

            const cancelBtn = document.createElement("button");
            cancelBtn.classList.add("cancel-button");
            cancelBtn.textContent = _("Cancel");
            cancelBtn.addEventListener("click", () => {
                document.body.removeChild(modal);
            });
            modal.appendChild(cancelBtn);

            document.body.appendChild(modal);
        };

        /*
         * Clears "canvas"
         */
        const renderClearConfirmation = clearCanvasAction => {
            if (document.getElementById("clear-confirm")) return;
            // Create a custom modal for confirmation
            const modal = document.createElement("div");
            modal.classList.add("modalBox");
            modal.id = "clear-confirm";
            const title = document.createElement("h2");
            title.textContent = _("Clear Workspace");
            title.classList.add("modal-title");

            modal.appendChild(title);
            const message = document.createElement("p");
            message.textContent = _("Are you sure you want to clear the workspace?");
            message.classList.add("modal-message");
            modal.appendChild(message);

            const buttonContainer = document.createElement("div");
            buttonContainer.classList.add("clear-button-container");

            const confirmBtn = document.createElement("button");
            confirmBtn.classList.add("confirm-button");
            confirmBtn.textContent = _("Confirm");
            confirmBtn.style.backgroundColor = platformColor.blueButton;
            confirmBtn.style.color = "white";
            confirmBtn.style.border = "none";
            confirmBtn.style.borderRadius = "4px";
            confirmBtn.style.padding = "8px 16px";
            confirmBtn.style.fontWeight = "bold";
            confirmBtn.style.cursor = "pointer";
            confirmBtn.style.marginRight = "16px";
            this.addEventListener(confirmBtn, "click", () => {
                document.body.removeChild(modal);
                clearCanvasAction();
            });

            const cancelBtn = document.createElement("button");
            cancelBtn.classList.add("cancel-button");
            cancelBtn.textContent = _("Cancel");
            cancelBtn.style.backgroundColor = "#f1f1f1";
            cancelBtn.style.color = "black";
            cancelBtn.style.border = "none";
            cancelBtn.style.borderRadius = "4px";
            cancelBtn.style.padding = "8px 16px";
            cancelBtn.style.fontWeight = "bold";
            cancelBtn.style.cursor = "pointer";
            this.addEventListener(cancelBtn, "click", () => {
                document.body.removeChild(modal);
            });

            buttonContainer.appendChild(confirmBtn);
            buttonContainer.appendChild(cancelBtn);
            modal.appendChild(buttonContainer);
            document.body.appendChild(modal);
        };

        this._allClear = (noErase, skipConfirmation = false) => {
            const clearCanvasAction = () => {
                this.blocks.activeBlock = null;
                hideDOMLabel();

                // Stop all GIF animations and clear overlay canvas (Issue #4907)
                if (this.gifAnimator) {
                    this.gifAnimator.stopAll();
                    const overlayCanvas = document.getElementById("overlayCanvas");
                    if (overlayCanvas) {
                        const ctx = overlayCanvas.getContext("2d");
                        ctx.clearRect(0, 0, overlayCanvas.width, overlayCanvas.height);
                    }
                }

                this.logo.boxes = {};
                this.logo.time = 0;
                this.hideMsgs();
                this.hideGrids();
                this.turtles.setBackgroundColor(-1);
                this.logo.svgOutput = "";
                this.logo.notationOutput = "";

                // Clear the recording buffer (Issue #2330)
                this.logo.recordingBuffer.hasData = false;
                this.logo.recordingBuffer.notationOutput = "";
                this.logo.recordingBuffer.notationNotes = {};
                this.logo.recordingBuffer.notationStaging = {};
                this.logo.recordingBuffer.notationDrumStaging = {};

                for (let turtle = 0; turtle < this.turtles.getTurtleCount(); turtle++) {
                    this.logo.turtleHeaps[turtle] = [];
                    this.logo.turtleDicts[turtle] = {};
                    this.logo.notation.notationStaging[turtle] = [];
                    this.logo.notation.notationDrumStaging[turtle] = [];
                    if (noErase === undefined || !noErase) {
                        this.turtles.getTurtle(turtle).painter.doClear(true, true, true);
                    }
                }

                this.blocksContainer.x = 0;
                this.blocksContainer.y = 0;

                const table = document.getElementById("myTable");
                if (table !== null) {
                    table.remove();
                }

                // Cache DOM element reference for performance
                const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
                if (helpfulWheelDiv.style.display !== "none") {
                    helpfulWheelDiv.style.display = "none";
                    this.__tick();
                }
            };

            if (skipConfirmation) {
                clearCanvasAction();
            } else {
                renderClearConfirmation(clearCanvasAction);
            }
        };
        /**
         * Sets up play button functionality; runs Music Blocks.
         * @param env {specifies environment}
         */
        const doFastButton = (activity, env) => {
            activity.runMode = "normal";
            activity._doFastButton(env);
        };

        this._doFastButton = env => {
            this._onResize();
            this.blocks.activeBlock = null;
            hideDOMLabel();

            const currentDelay = this.logo.turtleDelay;
            this.logo.turtleDelay = 0;
            this.logo.synth.resume();
            const widgetTitle = document.getElementsByClassName("wftTitle");
            for (let i = 0; i < widgetTitle.length; i++) {
                if (widgetTitle[i].innerHTML === "tempo") {
                    if (this.logo.tempo.isMoving) {
                        this.logo.tempo.pause();
                    }

                    this.logo.tempo.resume();
                    break;
                }
            }

            if (!this.turtles.running()) {
                if (!this.turtles.isShrunk()) {
                    this.blocks.hideBlocks();
                    this.showBlocksAfterRun = true;
                }

                this.logo.runLogoCommands(null, env);
            } else {
                if (currentDelay !== 0) {
                    // Keep playing at full speed.
                    this.logo.step();
                } else {
                    // Stop and restart.
                    document.getElementById("stop").style.color = "white";
                    this.logo.doStopTurtles();

                    const that = this;
                    setTimeout(() => {
                        document.getElementById("stop").style.color = "#ea174c";
                        that.logo.runLogoCommands(null, env);
                    }, 500);
                }
            }
        };

        let isExecuting = false; // Flag variable to track execution status

        /**
         * Sets up a record button functionality for the given activity.
         * @param {object} activity - The activity context.
         */
        const doRecordButton = activity => {
            /**
             * Executes the record button functionality if execution is not already in progress.
             */
            if (isExecuting) {
                return; // Exit the function if execution is already in progress
            }

            if (!activity || typeof activity._doRecordButton !== "function") {
                console.warn("doRecordButton called without valid activity context");
                isExecuting = false;
                return;
            }

            isExecuting = true; // Set the flag to indicate execution has started
            activity._doRecordButton();
        };

        /**
         * Functionality for the record button.
         * @private
         */
        this._doRecordButton = () => {
            const that = this;
            const start = document.getElementById("record"),
                recInside = document.getElementById("rec_inside");
            let mediaRecorder;
            const clickEvent = new Event("click");
            let flag = 0;
            let currentStream = null;
            let audioDestination = null;

            /**
             * Records the screen using the browser's media devices API.
             * @returns {Promise<MediaStream>} A promise resolving to the recorded media stream.
             */

            async function recordScreen() {
                const mode = localStorage.getItem("musicBlocksRecordMode");

                if (mode === "canvas") {
                    return await recordCanvasOnly();
                } else {
                    return await recordScreenWithTools();
                }
            }

            async function recordCanvasOnly() {
                flag = 1;
                const canvas = document.getElementById("myCanvas");
                if (!canvas) {
                    throw new Error("Canvas element not found");
                }

                // Get the toolbar height to exclude from recording
                const toolbar = document.getElementById("toolbars");
                const toolbarHeight = toolbar ? toolbar.offsetHeight : 0;

                // Get canvas dimensions
                const canvasRect = canvas.getBoundingClientRect();

                // Get the actual canvas dimensions
                const canvasWidth = canvas.width;
                const canvasHeight = canvas.height;

                // Calculate the visible area (excluding toolbar)
                const visibleHeight = canvasHeight - toolbarHeight;

                // Create a clean recording canvas
                const recordCanvas = document.createElement("canvas");
                recordCanvas.width = canvasWidth;
                recordCanvas.height = canvasHeight;
                const recordCtx = recordCanvas.getContext("2d");

                // Set background to match the canvas (white/light gray)
                recordCtx.fillStyle = "#f5f5f5"; // Adjust this color to match your canvas background
                let animationFrameId;

                // Function to continuously copy canvas content
                const copyFrame = () => {
                    // Fill background
                    recordCtx.fillRect(0, 0, canvasWidth, canvasHeight);

                    // Draw only the visible portion of the canvas (skip the toolbar area)
                    recordCtx.drawImage(
                        canvas,
                        0,
                        toolbarHeight, // Source x, y (skip toolbar)
                        canvasWidth,
                        visibleHeight, // Source width, height
                        0,
                        0, // Destination x, y
                        canvasWidth,
                        visibleHeight // Destination width, height
                    );

                    // Continue if still recording
                    if (flag === 1) {
                        animationFrameId = requestAnimationFrame(copyFrame);
                    }
                };

                // Start copying frames
                copyFrame();

                // Capture the canvas stream directly at 30fps
                const canvasStream = recordCanvas.captureStream(30);

                // Add audio track if available
                const Tone = that.logo.synth.tone;
                if (Tone && Tone.context) {
                    const dest = Tone.context.createMediaStreamDestination();
                    Tone.Destination.connect(dest);
                    audioDestination = dest;
                    const audioTrack = dest.stream.getAudioTracks()[0];
                    if (audioTrack) {
                        canvasStream.addTrack(audioTrack);
                    }
                }
                currentStream = canvasStream;

                // Clean up animation frame when recording stops
                canvasStream.getTracks()[0].addEventListener("ended", () => {
                    if (animationFrameId) {
                        cancelAnimationFrame(animationFrameId);
                    }
                });

                return canvasStream;
            }
            async function recordScreenWithTools() {
                flag = 1;

                try {
                    return await navigator.mediaDevices.getDisplayMedia({
                        preferCurrentTab: "True",
                        systemAudio: "include",
                        audio: "True",
                        video: { mediaSource: "tab" },
                        bandwidthProfile: {
                            video: {
                                clientTrackSwitchOffControl: "auto",
                                contentPreferencesMode: "auto"
                            }
                        },
                        preferredVideoCodecs: "auto"
                    });
                } catch (error) {
                    console.error("Screen capture failed:", error);
                    flag = 0;
                    throw error;
                }
            }

            /**
             * Saves the recorded chunks as a video file.
             * @param {Blob[]} recordedChunks - The recorded video chunks.
             */
            function saveFile(recordedChunks) {
                flag = 1;
                recInside.classList.remove("blink");
                // Prevent zero-byte files
                if (!recordedChunks || recordedChunks.length === 0) {
                    alert(_("Recorded file is empty. File not saved."));
                    flag = 0;
                    recording();
                    doRecordButton();
                    return;
                }
                const blob = new Blob(recordedChunks, {
                    type: "video/webm"
                });
                if (blob.size === 0) {
                    alert(_("Recorded file is empty. File not saved."));
                    flag = 0;
                    recording();
                    doRecordButton();
                    return;
                }
                // Clean up stream after recording
                if (currentStream) {
                    currentStream.getTracks().forEach(track => track.stop());
                    currentStream = null;
                }
                if (audioDestination && audioDestination.stream) {
                    audioDestination.stream.getTracks().forEach(track => track.stop());
                    audioDestination = null;
                }
                mediaRecorder = null;
                // Prompt to save file
                const filename = window.prompt(_("Enter file name"));
                if (filename === null || filename.trim() === "") {
                    alert(_("File save canceled"));
                    flag = 0;
                    recording();
                    doRecordButton();
                    return; // Exit without saving the file
                }
                const downloadLink = document.createElement("a");
                downloadLink.href = URL.createObjectURL(blob);
                downloadLink.download = `${filename}.webm`;
                document.body.appendChild(downloadLink);
                downloadLink.click();
                URL.revokeObjectURL(blob);
                document.body.removeChild(downloadLink);
                flag = 0;
                // Allow multiple recordings
                recording();
                doRecordButton();
                that.textMsg(_("Recording stopped. File saved."));
            }
            /**
             * Stops the recording process.
             */
            function stopRec() {
                flag = 0;

                if (mediaRecorder && typeof mediaRecorder.stop === "function") {
                    mediaRecorder.stop();
                }

                // Clean up the recording canvas stream
                if (currentStream) {
                    currentStream.getTracks().forEach(track => track.stop());
                }
                const node = document.createElement("p");
                node.textContent = "Stopped recording";
                document.body.appendChild(node);
            }

            /**
             * Creates a media recorder instance.
             * @param {MediaStream} stream - The media stream to be recorded.
             * @param {string} mimeType - The MIME type of the recording.
             * @returns {MediaRecorder} The created media recorder instance.
             */
            function createRecorder(stream, mimeType) {
                flag = 1;
                recInside.classList.add("blink");
                that.textMsg(_("Recording started. Click stop to finish."));
                start.removeEventListener("click", createRecorder, true);
                let recordedChunks = [];
                mediaRecorder = new MediaRecorder(stream);
                stream.oninactive = function () {
                    // eslint-disable-next-line no-console
                    console.log("Recording is ready to save");
                    stopRec();
                    flag = 0;
                };

                mediaRecorder.onstop = function () {
                    saveFile(recordedChunks);
                    recordedChunks = [];
                    flag = 0;
                    recInside.setAttribute("fill", "#ffffff");
                };

                mediaRecorder.ondataavailable = function (e) {
                    if (e.data.size > 0) {
                        recordedChunks.push(e.data);
                    }
                };

                mediaRecorder.start(200);
                setTimeout(() => {
                    // eslint-disable-next-line no-console
                    console.log("Resizing for Record", that.canvas.height);
                    that._onResize();
                }, 500);
                return mediaRecorder;
            }

            /**
             * Handles the recording process.
             */
            function recording() {
                // Remove any previous handler to avoid multiple triggers
                if (start._recordHandler) {
                    start.removeEventListener("click", start._recordHandler);
                }
                const handler = async function handler() {
                    try {
                        const stream = await recordScreen();
                        const mimeType = "video/webm";
                        mediaRecorder = createRecorder(stream, mimeType);
                        if (flag == 1) {
                            start.removeEventListener("click", handler);
                            // Add stop handler
                            const stopHandler = function stopHandler() {
                                if (mediaRecorder && mediaRecorder.state === "recording") {
                                    mediaRecorder.stop();
                                    mediaRecorder = new MediaRecorder(stream);
                                    recInside.classList.remove("blink");
                                    flag = 0;
                                    // Clean up stream
                                    if (currentStream) {
                                        currentStream.getTracks().forEach(track => track.stop());
                                    }
                                    if (audioDestination && audioDestination.stream) {
                                        audioDestination.stream
                                            .getTracks()
                                            .forEach(track => track.stop());
                                    }
                                }
                                start.removeEventListener("click", stopHandler);
                                // Re-enable recording for next time
                                recording();
                            };
                            start.addEventListener("click", stopHandler);
                        }
                        recInside.setAttribute("fill", "red");
                    } catch (error) {
                        console.error("Recording failed:", error);
                        that.textMsg(_("Recording failed: ") + error.message);
                        flag = 0;
                        // Re-enable recording button
                        recording();
                    }
                };
                start.addEventListener("click", handler);
                start._recordHandler = handler;
            }

            // Start recording process if not already executing
            if (flag == 0 && isExecuting) {
                recording();
                start.dispatchEvent(clickEvent);
            }
        };

        /*
         * Runs Music Blocks at a slower rate
         */
        const doSlowButton = activity => {
            activity.runMode = "slow";
            activity._doSlowButton();
        };

        /**
         * Executes slow button functionality.
         * Resets active block, hides DOM labels, adjusts turtle delay, resumes synth, and runs or steps logo commands.
         * @private
         */
        this._doSlowButton = () => {
            this.blocks.activeBlock = null;
            hideDOMLabel();

            this.logo.turtleDelay = DEFAULTDELAY;
            this.logo.synth.resume();

            if (!this.turtles.running()) {
                this.logo.runLogoCommands();
            } else {
                this.logo.step();
            }
        };

        /*
         * Runs music blocks step by step
         */
        const doStepButton = activity => {
            activity.runMode = "step";
            activity._doStepButton();
        };

        /**
         * Executes step button functionality.
         * Resets active block, hides DOM labels, adjusts turtle delay, resumes synth, and runs or steps logo commands.
         * @private
         */
        this._doStepButton = () => {
            this.blocks.activeBlock = null;
            hideDOMLabel();

            const turtleCount = Object.keys(this.logo.stepQueue).length;
            this.logo.synth.resume();

            if (turtleCount === 0 || this.logo.turtleDelay !== this.TURTLESTEP) {
                // Either we haven't set up a queue or we are
                // switching modes.
                this.logo.turtleDelay = this.TURTLESTEP;
                // Queue and take first step.
                if (!this.turtles.running()) {
                    this.logo.runLogoCommands();
                    document.getElementById("stop").style.color =
                        this.toolbar.stopIconColorWhenPlaying;
                }
                this.logo.step();
            } else {
                const noBlocks = Object.keys(this.logo.stepQueue).every(
                    key => this.logo.stepQueue[key].length === 0
                );
                if (noBlocks) {
                    this.logo.doStopTurtles();
                    document.getElementById("stop").style.color = "white";
                    return;
                }
                this.logo.turtleDelay = this.TURTLESTEP;
                this.logo.step();
            }
        };

        /**
         * Stops running of music blocks; stops all mid-way synths.
         * @param onblur {when object loses focus}
         */
        const doHardStopButton = (activity, onblur) => {
            activity._doHardStopButton(onblur);
        };

        /**
         * Stops running of music blocks and stops all mid-way synths.
         * @param {boolean} onblur - Indicates if the function is triggered by loss of focus.
         * @private
         */
        this._doHardStopButton = onblur => {
            this.blocks.activeBlock = null;
            hideDOMLabel();

            if (onblur === undefined) {
                onblur = false;
            }

            if (onblur && _THIS_IS_MUSIC_BLOCKS_) {
                return;
            }

            this.logo.doStopTurtles();

            const widgetTitle = document.getElementsByClassName("wftTitle");
            for (let i = 0; i < widgetTitle.length; i++) {
                if (widgetTitle[i].innerHTML === "tempo") {
                    if (this.logo.tempo.isMoving) {
                        this.logo.tempo.pause();
                    }
                    break;
                }
            }
        };

        /*
         * Switches between beginner/advanced mode
         */
        const doSwitchMode = activity => {
            // Update toolbar
            activity.toolbar.renderSaveIcons(
                activity.save.saveHTML.bind(activity.save),
                doSVG,
                activity.save.saveSVG.bind(activity.save),
                activity.save.saveMIDI.bind(activity.save),
                activity.save.savePNG.bind(activity.save),
                activity.save.saveWAV.bind(activity.save),
                activity.save.saveLilypond.bind(activity.save),
                activity.save.afterSaveLilypondLY.bind(activity.save),
                activity.save.saveAbc.bind(activity.save),
                activity.save.saveMxml.bind(activity.save),
                activity.save.saveBlockArtwork.bind(activity.save),
                activity.save.saveBlockArtworkPNG.bind(activity.save)
            );

            // Regenerate palettes
            if (activity.regeneratePalettes) {
                activity.regeneratePalettes();
            }

            // Update record button and dropdown visibility
            if (activity.toolbar && typeof activity.toolbar.updateRecordButton === "function") {
                activity.toolbar.updateRecordButton(() => doRecordButton(activity));
            }

            // Force immediate canvas refresh
            activity.refreshCanvas();
        };

        /*
         * Initialises the functionality of the horizScrollIcon
         */
        const setScroller = activity => {
            activity._setScroller();
            activity._setupBlocksContainerEvents();
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
            }
        };

        /**
         * Initializes the functionality of the horizontal scroll icon.
         * Toggles horizontal scrolling and updates corresponding UI elements.
         * @private
         */
        this._setScroller = () => {
            this.blocks.activeBlock = null;
            this.scrollBlockContainer = !this.scrollBlockContainer;
            const enableHorizScrollIcon = document.getElementById("enableHorizScrollIcon");
            const disableHorizScrollIcon = document.getElementById("disableHorizScrollIcon");
            if (this.scrollBlockContainer && !this.beginnerMode) {
                enableHorizScrollIcon.style.display = "none";
                disableHorizScrollIcon.style.display = "block";

                this.helpfulWheelItems.forEach(ele => {
                    if (ele.label === "Enable horizontal scrolling") ele.display = false;
                    else if (ele.label === "Disable horizontal scrolling") ele.display = true;
                });
                activity.textMsg("Horizontal scrolling enabled.", 3000);
            } else {
                enableHorizScrollIcon.style.display = "block";
                disableHorizScrollIcon.style.display = "none";

                this.helpfulWheelItems.forEach(ele => {
                    if (ele.label === "Enable horizontal scrolling") ele.display = true;
                    else if (ele.label === "Disable horizontal scrolling") ele.display = false;
                });
                activity.textMsg("Horizontal scrolling disabled.", 3000);
            }
        };

        /**
         * Displays loading animation with random messages.
         * @private
         */
        this.doLoadAnimation = () => {
            const messages = {
                load_messages: [
                    _("Catching mice"),
                    _("Cleaning the instruments"),
                    _("Testing key pieces"),
                    _("Sight-reading"),
                    _("Combining math and music"),
                    _("Generating more blocks"),
                    _("Do Re Mi Fa Sol La Ti Do"),
                    _("Tuning string instruments"),
                    _("Pressing random keys")
                ]
            };

            document.getElementById("load-container").style.display = "block";

            let counter = 0;

            const changeText = () => {
                const randomLoadMessage =
                    messages.load_messages[
                        Math.floor(Math.random() * messages.load_messages.length)
                    ];
                document.getElementById("messageText").innerHTML = randomLoadMessage + "...";
                counter++;
                if (counter >= messages.load_messages.length) {
                    counter = 0;
                }
            };

            this.loadAnimationIntervalId = setInterval(changeText, 2000);
        };

        /**
         * Stops the loading animation and clears the interval.
         * This prevents the interval from running indefinitely in the background.
         */
        this.stopLoadAnimation = () => {
            if (this.loadAnimationIntervalId !== null) {
                clearInterval(this.loadAnimationIntervalId);
                this.loadAnimationIntervalId = null;
            }
            const loadContainer = document.getElementById("load-container");
            if (loadContainer) {
                loadContainer.style.display = "none";
            }
        };

        /**
         * Increases the size of blocks in the activity.
         * @param {object} activity - The activity object.
         */
        const doLargerBlocks = async activity => {
            await activity._doLargerBlocks();
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
                activity.__tick();
            }
        };

        this._doLargerBlocks = async () => {
            this.blocks.activeBlock = null;

            if (!this.resizeDebounce) {
                if (this.blockscale < BLOCKSCALES.length - 1) {
                    this.resizeDebounce = true;
                    this.blockscale += 1;
                    this.clearCache();
                    await this.blocks.setBlockScale(BLOCKSCALES[this.blockscale]);
                    this.blocks.checkBounds();
                    this.refreshCanvas();
                }

                const that = this;
                setTimeout(() => {
                    that.resizeDebounce = false;
                }, 200);
            }

            await this.setSmallerLargerStatus();
            await this.stage.update();
        };

        /**
         * Decreases the size of blocks in the activity.
         * @param {object} activity - The activity object.
         */
        const doSmallerBlocks = async activity => {
            await activity._doSmallerBlocks();
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
                activity.__tick();
            }
        };

        /**
         * Manages the resizing of blocks to handle larger size.
         */
        this._doSmallerBlocks = async () => {
            this.blocks.activeBlock = null;

            if (!this.resizeDebounce) {
                if (this.blockscale > 0) {
                    this.resizeDebounce = true;
                    this.blockscale -= 1;
                    this.clearCache();
                    await this.blocks.setBlockScale(BLOCKSCALES[this.blockscale]);
                    this.blocks.checkBounds();
                    this.refreshCanvas();
                }

                const that = this;
                setTimeout(() => {
                    that.resizeDebounce = false;
                }, 200);
            }

            await this.setSmallerLargerStatus();
            await this.stage.update();
        };

        /*
         * If either the block size has reached its minimum or maximum,
         * then the icons to make them smaller/bigger will be hidden.
         * Sets the status of the smaller and larger block icons based on the current block size.
         */
        this.setSmallerLargerStatus = async () => {
            if (BLOCKSCALES[this.blockscale] < DEFAULTBLOCKSCALE) {
                await changeImage(
                    this.smallerContainer.children[0],
                    SMALLERBUTTON,
                    SMALLERDISABLEBUTTON
                );
            } else {
                await changeImage(
                    this.smallerContainer.children[0],
                    SMALLERDISABLEBUTTON,
                    SMALLERBUTTON
                );
            }

            if (BLOCKSCALES[this.blockscale] === 4) {
                await changeImage(
                    this.largerContainer.children[0],
                    BIGGERBUTTON,
                    BIGGERDISABLEBUTTON
                );
            } else {
                await changeImage(
                    this.largerContainer.children[0],
                    BIGGERDISABLEBUTTON,
                    BIGGERBUTTON
                );
            }
        };

        /**
         * Deletes a plugin palette from local storage based on the active palette.
         * @param {object} activity - The activity object.
         */
        const deletePlugin = activity => {
            activity._deletePlugin();
        };

        /**
         * Deletes a plugin palette from local storage.
         */
        this._deletePlugin = () => {
            if (this.palettes.activePalette !== null) {
                const obj = JSON.parse(this.storage.plugins);

                if (this.palettes.activePalette in obj["PALETTEPLUGINS"]) {
                    delete obj["PALETTEPLUGINS"][this.palettes.activePalette];
                }
                if (this.palettes.activePalette in obj["PALETTEFILLCOLORS"]) {
                    delete obj["PALETTEFILLCOLORS"][this.palettes.activePalette];
                }
                if (this.palettes.activePalette in obj["PALETTESTROKECOLORS"]) {
                    delete obj["PALETTESTROKECOLORS"][this.palettes.activePalette];
                }
                if (this.palettes.activePalette in obj["PALETTEHIGHLIGHTCOLORS"]) {
                    delete obj["PALETTEHIGHLIGHTCOLORS"][this.palettes.activePalette];
                }
                for (
                    let i = 0;
                    i < this.palettes.dict[this.palettes.activePalette].protoList.length;
                    i++
                ) {
                    const name =
                        this.palettes.dict[this.palettes.activePalette].protoList[i]["name"];
                    if (name in obj["FLOWPLUGINS"]) {
                        // eslint-disable-next-line no-console
                        console.log("deleting " + name);
                        delete obj["FLOWPLUGINS"][name];
                    }
                    if (name in obj["BLOCKPLUGINS"]) {
                        // eslint-disable-next-line no-console
                        console.log("deleting " + name);
                        delete obj["BLOCKPLUGINS"][name];
                    }
                    if (name in obj["ARGPLUGINS"]) {
                        // eslint-disable-next-line no-console
                        console.log("deleting " + name);
                        delete obj["ARGPLUGINS"][name];
                    }
                }
                if (this.palettes.activePalette in obj["MACROPLUGINS"]) {
                    delete obj["MACROPLUGINS"][this.palettes.activePalette];
                }
                if (this.palettes.activePalette in obj["ONLOAD"]) {
                    delete obj["ONLOAD"][this.palettes.activePalette];
                }
                if (this.palettes.activePalette in obj["ONSTART"]) {
                    delete obj["ONSTART"][this.palettes.activePalette];
                }
                if (this.palettes.activePalette in obj["ONSTOP"]) {
                    delete obj["ONSTOP"][this.palettes.activePalette];
                }

                this.storage.plugins = JSON.stringify(obj);
                this.textMsg(
                    this.palettes.activePalette + " " + _("plugins will be removed upon restart.")
                );
            }
        };

        /*
         * Hides all grids (Cartesian/polar/treble/et al.)
         */
        this.hideGrids = () => {
            this.turtles.setGridLabel(_("show Cartesian"));
            this._hideCartesian();
            this._hidePolar();
            if (_THIS_IS_MUSIC_BLOCKS_) {
                this._hideTreble();
                this._hideGrand();
                this._hideSoprano();
                this._hideAlto();
                this._hideTenor();
                this._hideBass();
            }
        };

        /*
         * Renders Cartesian/Polar/Treble/et al. grids
         */
        this._doCartesianPolar = () => {
            switch (this.turtles.currentGrid) {
                case 1:
                    this._hideCartesian();
                    break;
                case 2:
                    this._hideCartesian();
                    this._hidePolar();
                    break;
                case 3:
                    this._hidePolar();
                    break;
                case 4:
                    this._hideTreble();
                    break;
                case 5:
                    this._hideGrand();
                    break;
                case 6:
                    this._hideSoprano();
                    break;
                case 7:
                    this._hideAlto();
                    break;
                case 8:
                    this._hideTenor();
                    break;
                case 9:
                    this._hideBass();
                    break;
            }

            switch (this.turtles.gridWheel.selectedNavItemIndex) {
                case 1:
                    this._showCartesian();
                    break;
                case 2:
                    this._showCartesian();
                    this._showPolar();
                    break;
                case 3:
                    this._showPolar();
                    break;
                case 4:
                    this._showTreble();
                    break;
                case 5:
                    this._showGrand();
                    break;
                case 6:
                    this._showSoprano();
                    break;
                case 7:
                    this._showAlto();
                    break;
                case 8:
                    this._showTenor();
                    break;
                case 9:
                    this._showBass();
                    break;
            }
            this.turtles.currentGrid = this.turtles.gridWheel.selectedNavItemIndex;
            this.update = true;
        };

        /*
         * Sets up block actions with regards to different mouse events
         */
        this._setupBlocksContainerEvents = () => {
            const moving = false;
            const that = this;
            let lastCoords = { x: 0, y: 0, delta: 0 };

            /**
             * Closes any open menus and labels.
             */
            const closeAnyOpenMenusAndLabels = () => {
                [
                    "wheelDiv",
                    "contextWheelDiv",
                    "helpfulWheelDiv",
                    "textLabel",
                    "numberLabel"
                ].forEach(id => {
                    const elem = document.getElementById(id);
                    if (elem) elem.style.display = "none";
                });
            };

            /**
             * Normalizes wheel event data across different browsers.
             * @param {WheelEvent} event - The wheel event object.
             * @returns {Object} - Normalized pixelX and pixelY values.
             */
            const normalizeWheel = event => {
                const PIXEL_STEP = 10;
                const LINE_HEIGHT = 40;
                const PAGE_HEIGHT = 800;

                let sX = 0,
                    sY = 0, // spinX, spinY
                    pX = 0,
                    pY = 0; // pixelX, pixelY

                // Determine scroll values based on different event properties
                if ("detail" in event) sY = event.detail;
                if ("wheelDelta" in event) sY = -event.wheelDelta / 120;
                if ("wheelDeltaY" in event) sY = -event.wheelDeltaY / 120;
                if ("wheelDeltaX" in event) sX = -event.wheelDeltaX / 120;

                // side scrolling on FF with DOMMouseScroll
                // Handle horizontal scrolling on Firefox
                if ("axis" in event && event.axis === event.HORIZONTAL_AXIS) {
                    sX = sY;
                    sY = 0;
                }

                pX = sX * PIXEL_STEP;
                pY = sY * PIXEL_STEP;

                // Determine delta values based on deltaMode
                if ("deltaY" in event) pY = event.deltaY;
                if ("deltaX" in event) pX = event.deltaX;

                // Adjust pixel values based on deltaMode
                if ((pX || pY) && event.deltaMode) {
                    if (event.deltaMode === 1) {
                        // ff uses deltamode = 1
                        pX *= LINE_HEIGHT;
                        pY *= LINE_HEIGHT;
                    } else {
                        // delta in PAGE units
                        pX *= PAGE_HEIGHT;
                        pY *= PAGE_HEIGHT;
                    }
                }

                // Fall-back if spin cannot be determined
                if (pX && !sX) sX = pX < 1 ? -1 : 1;
                if (pY && !sY) sY = pY < 1 ? -1 : 1;

                return { pixelX: pX, pixelY: pY };
            };

            // Assuming you have defined 'that' and 'closeAnyOpenMenusAndLabels' elsewhere in your code

            const myCanvas = document.getElementById("myCanvas");
            const initialTouches = [
                [null, null],
                [null, null]
            ]; // Array to track two fingers (Y and X coordinates)

            /**
             * Handles touch start event on the canvas.
             * @param {TouchEvent} event - The touch event object.
             */
            myCanvas.addEventListener("touchstart", event => {
                if (event.touches.length === 2) {
                    for (let i = 0; i < 2; i++) {
                        initialTouches[i][0] = event.touches[i].clientY;
                        initialTouches[i][1] = event.touches[i].clientX;
                    }
                }
            });

            /**
             * Handles touch move event on the canvas.
             * @param {TouchEvent} event - The touch event object.
             */
            myCanvas.addEventListener("touchmove", event => {
                if (event.touches.length === 2) {
                    for (let i = 0; i < 2; i++) {
                        const touchY = event.touches[i].clientY;
                        const touchX = event.touches[i].clientX;

                        if (initialTouches[i][0] !== null && initialTouches[i][1] !== null) {
                            const deltaY = touchY - initialTouches[i][0];
                            const deltaX = touchX - initialTouches[i][1];

                            if (deltaY !== 0) {
                                closeAnyOpenMenusAndLabels();
                                that.blocksContainer.y -= deltaY;
                            }

                            if (that.scrollBlockContainer && deltaX !== 0) {
                                closeAnyOpenMenusAndLabels();
                                that.blocksContainer.x -= deltaX;
                            }

                            initialTouches[i][0] = touchY;
                            initialTouches[i][1] = touchX;
                        }
                    }

                    that.refreshCanvas();
                }
            });

            /**
             * Handles touch end event on the canvas.
             */
            myCanvas.addEventListener("touchend", () => {
                for (let i = 0; i < 2; i++) {
                    initialTouches[i][0] = null;
                    initialTouches[i][1] = null;
                }
            });

            /**
             * Handles wheel event on the canvas.
             * @param {WheelEvent} event - The wheel event object.
             */
            const __wheelHandler = event => {
                const data = normalizeWheel(event);
                const delY = data.pixelY;
                const delX = data.pixelX;

                if (event.ctrlKey) {
                    event.preventDefault();
                    delY < 0 ? doLargerBlocks(that) : doSmallerBlocks(that);
                } else {
                    closeAnyOpenMenusAndLabels();
                    if (that.scrollBlockContainer) {
                        // Horizontal scrolling enabled (Advanced)
                        if (delY !== 0) that.blocksContainer.y -= delY;
                        if (delX !== 0) that.blocksContainer.x -= delX;
                    } else {
                        // Vertical scrolling only (Beginner / Default)
                        if (event.axis === event.VERTICAL_AXIS && delY !== 0) {
                            that.blocksContainer.y -= delY;
                        }
                    }
                }

                that.refreshCanvas();
            };

            this.addEventListener(
                document.getElementById("myCanvas"),
                "wheel",
                __wheelHandler,
                false
            );

            /**
             * Handles stage mouse up event.
             * @param {MouseEvent} event - The mouse event object.
             */
            const __stageMouseUpHandler = event => {
                that.stageMouseDown = false;
                that.moving = false;

                if (that.stage.getObjectUnderPoint() === null && lastCoords.delta < 4) {
                    that.stageX = event.stageX;
                    that.stageY = event.stageY;
                }
            };

            /**
             * Handles mouse movement on the stage.
             * @param {object} event - The mouse event object.
             */
            this.stage.on("stagemousemove", event => {
                that.stageX = event.stageX;
                that.stageY = event.stageY;
            });

            /**
             * Handles mouse down event on the stage.
             * @param {object} event - The mouse event object.
             */
            this.stage.on("stagemousedown", event => {
                that.stageMouseDown = true;
                if ((that.stage.getObjectUnderPoint() !== null) | that.turtles.running()) {
                    that.stage.removeAllEventListeners("stagemouseup");
                    that.stage.on("stagemouseup", __stageMouseUpHandler);
                    return;
                }

                that.moving = true;
                lastCoords = {
                    x: event.stageX,
                    y: event.stageY,
                    delta: 0
                };

                hideDOMLabel();

                that.stage.removeAllEventListeners("stagemousemove");
                that.stage.on("stagemousemove", event => {
                    that.stageX = event.stageX;
                    that.stageY = event.stageY;

                    if (!that.moving) return;

                    // if we are moving the block container, deselect the active block.
                    // Deselect active block if moving the block container
                    that.blocks.activeBlock = null;

                    // eslint-disable-next-line max-len
                    const delta =
                        Math.abs(event.stageX - lastCoords.x) +
                        Math.abs(event.stageY - lastCoords.y);

                    if (that.scrollBlockContainer) {
                        that.blocksContainer.x += event.stageX - lastCoords.x;
                    }

                    that.blocksContainer.y += event.stageY - lastCoords.y;
                    lastCoords = {
                        x: event.stageX,
                        y: event.stageY,
                        delta: lastCoords.delta + delta
                    };

                    that.refreshCanvas();
                });

                that.stage.removeAllEventListeners("stagemouseup");
                that.stage.on("stagemouseup", __stageMouseUpHandler);
            });
        };

        /**
         * Sets up scrolling functionality in palette and across canvas
         * Retrieves the scale of the stage.
         * @returns {number} - The scale of the stage.
         */
        this.getStageScale = () => {
            return this.turtleBlocksScale;
        };

        /**
         * Retrieves the X coordinate of the stage.
         * @returns {number} - The X coordinate of the stage.
         */
        this.getStageX = () => {
            return this.turtles.screenX2turtleX(this.stageX / this.turtleBlocksScale);
        };

        /**
         * Retrieves the Y coordinate of the stage.
         * @returns {number} - The Y coordinate of the stage.
         */
        this.getStageY = () => {
            return this.turtles.screenY2turtleY(
                (this.stageY - this.toolbarHeight) / this.turtleBlocksScale
            );
        };

        /**
         * Retrieves the mouse down state of the stage.
         * @returns {boolean} - The mouse down state of the stage.
         */
        this.getStageMouseDown = () => {
            return this.stageMouseDown;
        };

        /**
         * Creates and renders a grid on the stage.
         * @param {string} imagePath - The path of the grid image.
         * @returns {object} - The created grid object.
         */
        this._createGrid = imagePath => {
            const img = new Image();
            img.src = imagePath;
            const container = new createjs.Container();
            this.stage.addChild(container);

            const bitmap = new createjs.Bitmap(img);
            container.addChild(bitmap);
            // Do NOT cache the bitmap here. Each cached grid allocates a
            // 1200x900x4 = ~4.3 MB backing canvas, and with 8 grids that
            // totals ~35 MB even though at most 1 grid is visible at a time.
            // Instead, we cache lazily in _show*() and uncache in _hide*().

            bitmap.x = (this.canvas.width - 1200) / 2;
            bitmap.y = (this.canvas.height - 900) / 2;
            bitmap.scaleX = bitmap.scaleY = bitmap.scale = 1;
            bitmap.visible = false;

            return bitmap;
        };

        /**
         * Creates and renders a message container.
         * @param {string} fillColor - The fill color of the message container.
         * @param {string} strokeColor - The stroke color of the message container.
         * @param {function} callback - The callback function assigned to the message container.
         * @param {number} y - The position on the canvas.
         */
        this._createMsgContainer = (fillColor, strokeColor, callback, y) => {
            const container = new createjs.Container();
            this.stage.addChild(container);
            container.x = this.canvas.width / 2;
            container.y = y;
            container.visible = false;

            const img = new Image();
            const svgData = MSGBLOCK.replace("fill_color", fillColor).replace(
                "stroke_color",
                strokeColor
            );

            const that = this;

            img.onload = () => {
                const msgBlock = new createjs.Bitmap(img);
                container.addChild(msgBlock);
                const text = new createjs.Text("your message here", "20px Arial", "#000000");
                container.addChild(text);
                text.textAlign = "center";
                text.textBaseline = "alphabetic";
                text.x = 500;
                text.y = 30;

                const bounds = container.getBounds();
                container.cache(bounds.x, bounds.y, bounds.width, bounds.height);

                const hitArea = new createjs.Shape();
                hitArea.graphics.beginFill("#FFF").drawRect(0, 0, 1000, 42);
                hitArea.x = 0;
                hitArea.y = 0;
                container.hitArea = hitArea;

                container.on("click", () => {
                    container.visible = false;
                    // On the possibility that there was an error
                    // arrow associated with this container
                    if (that.errorMsgArrow !== null) {
                        that.errorMsgArrow.removeAllChildren(); // Hide the error arrow.
                    }

                    that.update = true;
                });

                callback(text);
                that.msgText = text;
            };

            img.src = "data:image/svg+xml;base64," + window.btoa(base64Encode(svgData));
        };

        /*
         * Creates and renders error message containers with appropriate artwork.
         * Some error messages have special artwork.
         */
        this._createErrorContainers = () => {
            for (let i = 0; i < ERRORARTWORK.length; i++) {
                const name = ERRORARTWORK[i];
                this._makeErrorArtwork(name);
            }
        };

        /**
         * Initialize an idle watcher that throttles the application's framerate
         * when the application is inactive and no music is playing.
         * This significantly reduces CPU usage and improves battery life.
         */
        this._initIdleWatcher = () => {
            const IDLE_THRESHOLD = 5000; // 5 seconds
            const ACTIVE_FPS = 60;
            const IDLE_FPS = 1;

            let lastActivity = Date.now();
            this.isAppIdle = false;

            // Wake up function - restores full framerate
            const resetIdleTimer = () => {
                lastActivity = Date.now();
                if (this.isAppIdle) {
                    this.isAppIdle = false;
                    createjs.Ticker.framerate = ACTIVE_FPS;
                    // Force immediate redraw for responsiveness
                    if (this.stage) this.stage.update();
                }
            };

            // Track user activity
            window.addEventListener("mousemove", resetIdleTimer);
            window.addEventListener("mousedown", resetIdleTimer);
            window.addEventListener("keydown", resetIdleTimer);
            window.addEventListener("touchstart", resetIdleTimer);
            window.addEventListener("wheel", resetIdleTimer);

            // Periodic check for idle state
            setInterval(() => {
                // Check if music/code is playing
                const isMusicPlaying = this.logo?._alreadyRunning || false;

                if (!isMusicPlaying && Date.now() - lastActivity > IDLE_THRESHOLD) {
                    if (!this.isAppIdle) {
                        this.isAppIdle = true;
                        createjs.Ticker.framerate = IDLE_FPS;
                        console.log("⚡ Idle mode: Throttling to 1 FPS to save battery");
                    }
                } else if (this.isAppIdle && isMusicPlaying) {
                    // Music started playing - wake up immediately
                    resetIdleTimer();
                }
            }, 1000);
        };

        /**
         * Renders an error message with appropriate artwork.
         * @param {string} name - The name specifying the SVG to be rendered.
         */
        this._makeErrorArtwork = name => {
            const container = new createjs.Container();
            this.stage.addChild(container);
            container.x = this.canvas.width / 2;
            container.y = 80;
            this.errorArtwork[name] = container;
            this.errorArtwork[name].name = name;
            this.errorArtwork[name].visible = false;

            const img = new Image();
            img.onload = () => {
                const artwork = new createjs.Bitmap(img);
                container.addChild(artwork);
                const text = new createjs.Text("", "20px Sans", "#000000");
                container.addChild(text);
                text.x = 70;
                text.y = 10;

                const bounds = container.getBounds();
                container.cache(bounds.x, bounds.y, bounds.width, bounds.height);

                const hitArea = new createjs.Shape();
                hitArea.graphics.beginFill("#FFF").drawRect(0, 0, bounds.width, bounds.height);
                hitArea.x = 0;
                hitArea.y = 0;
                container.hitArea = hitArea;

                const that = this;
                container.on("click", () => {
                    container.visible = false;
                    // On the possibility that there was an error
                    // arrow associated with this container
                    if (that.errorMsgArrow !== null && that.errorMsgArrow !== undefined) {
                        that.errorMsgArrow.removeAllChildren(); // Hide the error arrow.
                    }
                    that.update = true;
                });
            };

            img.src = "images/" + name + ".svg";
        };

        /*
          Prepare a list of blocks for the search bar autocompletion.
         */
        this.prepSearchWidget = () => {
            //searchWidget.style.visibility = "hidden";
            this.searchBlockPosition = [100, 100];

            this.searchSuggestions = [];
            this.deprecatedBlockNames = [];

            // Guard: blocks may not be initialized yet during early loading
            if (!this.blocks || !this.blocks.protoBlockDict) {
                console.debug("prepSearchWidget: blocks not yet initialized, skipping");
                return;
            }

            for (const i in this.blocks.protoBlockDict) {
                const block = this.blocks.protoBlockDict[i];
                const blockLabel = block.staticLabels.join(" ");
                const artwork = block.palette.model.makeBlockInfo(0, block, block.name, block.name)[
                    "artwork64"
                ];
                if (blockLabel || block.extraSearchTerms !== undefined) {
                    if (block.deprecated) {
                        this.deprecatedBlockNames.push(blockLabel);
                    } else {
                        if (blockLabel.length === 0) {
                            // Swap in a preferred name when there is no label.
                            let label = _(block.name);
                            switch (block.name) {
                                case "scaledegree2":
                                    label = _("scale degree");
                                    break;
                                case "voicename":
                                    label = _("voice name");
                                    break;
                                case "invertmode":
                                    label = _("invert mode");
                                    break;
                                case "outputtools":
                                    label = _("output tools");
                                    break;
                                case "customNote":
                                    label = _("custom note");
                                    break;
                                case "accidentalname":
                                    label = _("accidental name");
                                    break;
                                case "eastindiansolfege":
                                    label = _("east indian solfege");
                                    break;
                                case "notename":
                                    label = _("note name");
                                    break;
                                case "temperamentname":
                                    label = _("temperament name");
                                    break;
                                case "modename":
                                    label = _("mode name");
                                    break;
                                case "chordname":
                                    label = _("chord name");
                                    break;
                                case "intervalname":
                                    label = _("interval name");
                                    break;
                                case "filtertype":
                                    label = _("filter type");
                                    break;
                                case "oscillatortype":
                                    label = _("oscillator type");
                                    break;
                                case "audiofile":
                                    label = _("audio file");
                                    break;
                                case "noisename":
                                    label = _("noise name");
                                    break;
                                case "drumname":
                                    label = _("drum name");
                                    break;
                                case "effectsname":
                                    label = _("effects name");
                                    break;
                                case "wrapmode":
                                    label = _("wrap mode");
                                    break;
                                case "loadFile":
                                    label = _("load file");
                                    break;
                            }
                            this.searchSuggestions.push({
                                label: label,
                                value: block.name,
                                specialDict: block,
                                artwork: artwork
                            });
                        } else {
                            this.searchSuggestions.push({
                                label: blockLabel,
                                value: block.name,
                                specialDict: block,
                                artwork: artwork
                            });
                        }
                        if (block.extraSearchTerms !== undefined) {
                            for (let i = 0; i < block.extraSearchTerms.length; i++) {
                                this.searchSuggestions.push({
                                    label: block.extraSearchTerms[i],
                                    value: block.name,
                                    specialDict: block,
                                    artwork: artwork
                                });
                            }
                        }
                    }
                }
            }

            this.searchSuggestions = this.searchSuggestions.reverse();
        };

        /*
         * Hides search widget
         */
        this.hideSearchWidget = () => {
            // Hide the jQuery search results widget.
            const obj = docByClass("ui-menu");
            if (obj.length > 0) {
                obj[0].style.visibility = "hidden";
            }

            this.searchWidget.style.visibility = "hidden";
            this.searchWidget.idInput_custom = "";
        };

        /*
         * Shows search widget
         */
        this.showSearchWidget = () => {
            // Bring widget to top.
            this.searchWidget.style.zIndex = 1001;
            this.searchWidget.style.border = "2px solid lightblue";
            if (this.helpfulSearchDiv) {
                this._hideHelpfulSearchWidget();
            }
            if (this.searchWidget.style.visibility === "visible") {
                this.hideSearchWidget();
            } else {
                const obj = docByClass("ui-menu");
                if (obj.length > 0) {
                    obj[0].style.visibility = "visible";
                }

                this.searchWidget.value = null;
                this.searchWidget.style.visibility = "visible";
                this.searchWidget.style.left =
                    this.palettes.getSearchPos()[0] * this.turtleBlocksScale * 1.5 + "px";
                this.searchWidget.style.top =
                    this.palettes.getSearchPos()[1] * this.turtleBlocksScale * 0.95 + "px";

                this.searchBlockPosition = [100, 100];
                this.prepSearchWidget();

                const that = this;
                const closeListener = e => {
                    if (
                        document.getElementById("search").style.visibility === "visible" &&
                        (e.target === document.getElementById("search") ||
                            document.getElementById("search").contains(e.target))
                    ) {
                        //do nothing when clicked in the input field
                    } else if (
                        document.getElementById("ui-id-1") &&
                        document.getElementById("ui-id-1").style.display === "block" &&
                        (e.target === document.getElementById("ui-id-1") ||
                            document.getElementById("ui-id-1").contains(e.target))
                    ) {
                        //do nothing when clicked on the menu
                    } else if (document.getElementsByTagName("tr")[2].contains(e.target)) {
                        //do nothing when clicked on the search row
                    } else {
                        // this will hide the search bar if someone clicks on menu items
                        that.hideSearchWidget();
                        document.removeEventListener("mousedown", closeListener);
                    }
                };
                document.addEventListener("mousedown", closeListener);

                // Give the browser time to update before selecting
                // focus.
                setTimeout(() => {
                    that.searchWidget.focus();
                    that.doSearch();
                }, 500);
            }
        };

        /*
         * Uses JQuery to add autocompleted search suggestions
         */
        this.doSearch = () => {
            // Guard: ensure searchWidget exists before proceeding
            if (!this.searchWidget) {
                console.debug("doSearch: searchWidget not yet initialized, skipping");
                return;
            }

            const $j = window.jQuery;
            if (this.searchSuggestions.length === 0) {
                this.prepSearchWidget();
            }

            const that = this;
            const $search = $j("#search");

            if (!$search.data("autocomplete-init")) {
                $search.autocomplete({
                    source: that.searchSuggestions,
                    appendTo: "body",
                    select: (event, ui) => {
                        event.preventDefault();
                        that.searchWidget.value = ui.item.label;
                        that.searchWidget.idInput_custom = ui.item.value;
                        that.searchWidget.protoblk = ui.item.specialDict;
                        that.doSearch();
                        if (event.keyCode === 13) this.searchWidget.style.visibility = "visible";
                    },
                    focus: event => {
                        event.preventDefault();
                    }
                });

                const instance = $search.autocomplete("instance");
                if (instance) {
                    instance._renderItem = (ul, item) => {
                        const li = $j("<li></li>");

                        const img = document.createElement("img");
                        img.src = item.artwork || "";
                        img.height = 20;
                        img.style.cursor = "grab";

                        // Drag-and-drop: mirrors the palette drag pattern in
                        // palette.js _showMenuItems(). Keep both in sync.
                        img.ondragstart = () => false;

                        const down = event => {
                            // Stop jQuery UI autocomplete from handling this
                            event.stopPropagation();
                            event.stopImmediatePropagation();
                            event.preventDefault();

                            const posit = img.style.position;
                            const zInd = img.style.zIndex;
                            img.style.position = "absolute";
                            img.style.zIndex = 10000;

                            // Close the autocomplete dropdown
                            $j("#search").autocomplete("close");

                            document.body.appendChild(img);

                            const moveAt = (pageX, pageY) => {
                                img.style.left = pageX - img.offsetWidth / 2 + "px";
                                img.style.top = pageY - img.offsetHeight / 2 + "px";
                            };

                            const onMouseMove = e => {
                                e.preventDefault();
                                let x, y;
                                if (e.type === "touchmove") {
                                    x = e.touches[0].clientX;
                                    y = e.touches[0].clientY;
                                } else {
                                    x = e.pageX;
                                    y = e.pageY;
                                }
                                moveAt(x, y);
                            };
                            onMouseMove(event);

                            document.addEventListener("touchmove", onMouseMove, { passive: false });
                            document.addEventListener("mousemove", onMouseMove);

                            const up = () => {
                                document.body.style.cursor = "default";
                                document.removeEventListener("mousemove", onMouseMove);
                                document.removeEventListener("touchmove", onMouseMove);

                                const x = parseInt(img.style.left);
                                const y = parseInt(img.style.top);

                                img.style.position = posit;
                                img.style.zIndex = zInd;
                                if (img.parentNode === document.body) {
                                    document.body.removeChild(img);
                                }

                                if (isNaN(x) && isNaN(y)) return;

                                const protoblk = item.specialDict;
                                const paletteName = protoblk.palette.name;
                                const protoName = item.value;

                                that.palettes.dict[paletteName].makeBlockFromSearch(
                                    protoblk,
                                    protoName,
                                    newBlock => {
                                        that.blocks.moveBlock(
                                            newBlock,
                                            (x || that.blocksContainer.x + 100) -
                                                that.blocksContainer.x,
                                            (y || that.blocksContainer.y + 100) -
                                                that.blocksContainer.y
                                        );
                                    }
                                );
                            };

                            document.addEventListener("mouseup", up, { once: true });
                            document.addEventListener("touchend", up, { once: true });
                        };

                        // Capture phase fires BEFORE jQuery UI's event delegation
                        li[0].addEventListener("mousedown", down, true);
                        li[0].addEventListener("touchstart", down, {
                            capture: true,
                            passive: false
                        });

                        li.append(img);
                        li.append("<a> " + item.label + "</a>");

                        return li.appendTo(
                            ul.css({
                                "z-index": 35000,
                                "max-height": "200px",
                                "overflow-y": "auto"
                            })
                        );
                    };
                }
                $search.data("autocomplete-init", true);
            }

            const searchInput = this.searchWidget.idInput_custom;
            if (!searchInput || searchInput.length <= 0) {
                if (this.searchWidget.value && this.searchWidget.value.length > 0) {
                    $search.autocomplete("search", this.searchWidget.value);
                }
                return;
            }

            const protoblk = this.searchWidget.protoblk;
            const paletteName = protoblk.palette.name;
            const protoName = protoblk.name;

            // eslint-disable-next-line no-prototype-builtins
            if (this.blocks.protoBlockDict.hasOwnProperty(protoName)) {
                this.palettes.dict[paletteName].makeBlockFromSearch(
                    protoblk,
                    protoName,
                    newBlock => {
                        that.blocks.moveBlock(
                            newBlock,
                            100 + that.searchBlockPosition[0] - that.blocksContainer.x,
                            that.searchBlockPosition[1] - that.blocksContainer.y
                        );
                    }
                );

                // Move the position of the next newly created block.
                this.searchBlockPosition[0] += STANDARDBLOCKHEIGHT;
                this.searchBlockPosition[1] += STANDARDBLOCKHEIGHT;
            } else if (this.deprecatedBlockNames.indexOf(searchInput) > -1) {
                this.errorMsg(_("This block is deprecated."));
            } else {
                this.errorMsg(_("Block cannot be found."));
            }

            this.searchWidget.value = "";
            this.update = true;
        };

        //To create a sampler widget
        this.makeSamplerWidget = (sampleName, sampleData) => {
            const samplerStack = [
                [
                    0,
                    "sampler",
                    300 - this.blocksContainer.x,
                    300 - this.blocksContainer.y,
                    [null, 1, 8]
                ],
                [1, "settimbre", 0, 0, [0, 2, 6, 7]],
                [2, ["customsample", { value: ["", "", "do", 4] }], 0, 0, [1, 3, 4, 5]],
                [3, ["audiofile", { value: [sampleName, sampleData] }], 0, 0, [2]],
                [4, ["solfege", { value: "do" }], 0, 0, [2]],
                [5, ["number", { value: 4 }], 0, 0, [2]],
                [6, "vspace", 0, 0, [1, null]],
                [7, "hidden", 0, 0, [1, null]],
                [8, "hiddennoflow", 0, 0, [0, null]]
            ];
            this.blocks.loadNewBlocks(samplerStack);
        };

        /*
         * Handles keyboard shortcuts in MB
         */
        this.__keyPressed = event => {
            // First, check if the pitch slider is open
            if (window.widgetWindows.isOpen("slider") === true) {
                // If the event is an arrow key, let the PitchSlider handle it
                if (
                    event.keyCode === 37 ||
                    event.keyCode === 38 ||
                    event.keyCode === 39 ||
                    event.keyCode === 40
                ) {
                    // Simply prevent default behavior here
                    // The actual pitch slider handling is done in the PitchSlider class
                    event.preventDefault();
                    event.stopPropagation();
                    return false;
                }
            }

            if (window.widgetWindows.isOpen("JavaScript Editor") === true) return;
            if (!this.keyboardEnableFlag) {
                return;
            }
            if (document.getElementById("labelDiv").classList.contains("hasKeyboard")) {
                return;
            }
            // Skip hotkeys when value bar is visible (prevents accidental block creation)
            if (this.printText && this.printText.classList.contains("show")) {
                return;
            }

            if (this.keyboardEnableFlag) {
                if (
                    document.getElementById("BPMInput") !== null &&
                    document.getElementById("BPMInput").classList.contains("hasKeyboard")
                ) {
                    return;
                }
                if (
                    document.getElementById("musicratio1") !== null &&
                    document.getElementById("musicratio1").classList.contains("hasKeyboard")
                ) {
                    return;
                }
                if (
                    document.getElementById("musicratio2") !== null &&
                    document.getElementById("musicratio2").classList.contains("hasKeyboard")
                ) {
                    return;
                }
                if (
                    document.getElementById("dissectNumber") !== null &&
                    document.getElementById("dissectNumber").classList.contains("hasKeyboard")
                ) {
                    return;
                }
                if (
                    document.getElementById("timbreName") !== null &&
                    document.getElementById("timbreName").classList.contains("hasKeyboard")
                ) {
                    return;
                }
            }
            // const BACKSPACE = 8;
            const TAB = 9;
            if (event.keyCode === TAB) {
                // Prevent browser from grabbing TAB key
                event.preventDefault();
                return false;
            }
            const ESC = 27;
            // const ALT = 18;
            // const CTRL = 17;
            // const SHIFT = 16;
            const RETURN = 13;
            const SPACE = 32;
            const HOME = 36;
            const END = 35;
            const PAGE_UP = 33;
            const PAGE_DOWN = 34;
            const KEYCODE_LEFT = 37;
            const KEYCODE_RIGHT = 39;
            const KEYCODE_UP = 38;
            const KEYCODE_DOWN = 40;
            const DEL = 46;
            const V = 86;
            const disableKeys =
                document.getElementById("lilypondModal").style.display === "block" ||
                this.searchWidget.style.visibility === "visible" ||
                this.helpfulSearchWidget.style.visibility === "visible" ||
                this.isInputON ||
                document.getElementById("samplerPrompt") ||
                document.getElementById("planet-iframe").style.display === "" ||
                document.getElementById("paste").style.visibility === "visible" ||
                document.getElementById("wheelDiv").style.display === "" ||
                this.turtles.running();
            const widgetTitle = document.getElementsByClassName("wftTitle");
            for (let i = 0; i < widgetTitle.length; i++) {
                if (widgetTitle[i].innerHTML === "tempo") {
                    this.inTempoWidget = true;
                    break;
                }
            }
            if (
                (event.altKey && !disableKeys) ||
                event.keyCode == 13 ||
                event.key == "/" ||
                event.key == "\\"
            ) {
                switch (event.keyCode) {
                    case 66: // 'B'
                        this.textMsg("Alt-B " + _("Saving block artwork"));
                        this.save.saveBlockArtwork();
                        break;
                    case 67: // 'C'
                        this.textMsg("Alt-C " + _("Copy"));
                        this.blocks.prepareStackForCopy();
                        break;
                    case 69: // 'E'
                        this.textMsg("Alt-E " + _("Erase"));
                        this._allClear(false);
                        break;
                    case 82: {
                        // 'R or ENTER'
                        this.textMsg("Alt-R " + _("Play"));
                        const stopbtn = document.getElementById("stop");
                        if (stopbtn) {
                            stopbtn.style.color = platformColor.stopIconcolor;
                        }
                        this._doFastButton();
                        break;
                    }
                    case 13: {
                        // 'R or ENTER'
                        if (this.isInputON) return;

                        if (this.searchWidget.style.visibility === "visible") {
                            return;
                        }
                        if (document.getElementById("paste").style.visibility === "visible") {
                            this.pasted();
                            document.getElementById("paste").style.visibility = "hidden";
                            return;
                        }
                        this.textMsg("Enter " + _("Play"));
                        const stopbt = document.getElementById("stop");
                        if (stopbt) {
                            stopbt.style.color = platformColor.stopIconcolor;
                        }
                        this._doFastButton();
                        break;
                    }
                    case 83: // 'S'
                        this.textMsg("Alt-S " + _("Stop"));
                        this.logo.doStopTurtles();
                        break;
                    case 86: // 'V'
                        // this.textMsg("Alt-V " + _("Paste"));
                        this.blocks.pasteStack();
                        break;
                    case 72: // 'H' save block help
                        this.textMsg("Alt-H " + _("Save block help"));
                        this._saveHelpBlocks();
                        break;
                    case 191:
                        if (
                            event.key == "/" &&
                            !this.beginnerMode &&
                            disableHorizScrollIcon.style.display == "block"
                        ) {
                            this.blocksContainer.x += this.canvas.width / 10;
                            this.stage.update();
                        }
                    // fall through
                    case 220:
                        if (
                            event.key == "\\" &&
                            !this.beginnerMode &&
                            disableHorizScrollIcon.style.display == "block"
                        ) {
                            this.blocksContainer.x -= this.canvas.width / 10;
                            this.stage.update();
                        }
                }
            } else if (event.ctrlKey) {
                switch (event.keyCode) {
                    case V:
                        // this.textMsg("Ctl-V " + _("Paste"));
                        this.pasteBox.createBox(this.turtleBlocksScale, 200, 200);
                        this.pasteBox.show();
                        document.getElementById("paste").style.left =
                            (this.pasteBox.getPos()[0] + 10) * this.turtleBlocksScale + "px";
                        document.getElementById("paste").style.top =
                            (this.pasteBox.getPos()[1] + 10) * this.turtleBlocksScale + "px";
                        document.getElementById("paste").focus();
                        document.getElementById("paste").style.visibility = "visible";
                        this.update = true;
                        break;
                }
            } else if (event.shiftKey && !disableKeys) {
                switch (event.keyCode) {
                    case SPACE:
                        event.preventDefault();
                        if (this.turtleContainer.scaleX === 1) {
                            this.turtles.setStageScale(0.5);
                        } else {
                            this.turtles.setStageScale(1);
                        }
                        break;
                }
            } else {
                if (
                    document.getElementById("paste").style.visibility === "visible" &&
                    event.keyCode === RETURN
                ) {
                    if (document.getElementById("paste").value.length > 0) {
                        this.pasted();
                    }
                } else if (event.keyCode === SPACE) {
                    // Check if any widget window is open
                    const hasOpenWidget = Object.values(window.widgetWindows.openWindows).some(
                        w => w
                    );
                    if (this.turtles.running()) {
                        event.preventDefault();
                        this._doHardStopButton();
                    } else if (!disableKeys && !hasOpenWidget) {
                        event.preventDefault();
                        const stopbtn = document.getElementById("stop");
                        if (stopbtn) {
                            stopbtn.style.color = platformColor.stopIconcolor;
                        }
                        this._doFastButton();
                    }
                } else if (!disableKeys) {
                    switch (event.keyCode) {
                        case END:
                            this.textMsg("END " + _("Jumping to the bottom of the page."));
                            this.blocksContainer.y =
                                -this.blocks.bottomMostBlock() + this.canvas.height / 2;
                            this.stage.update();
                            break;
                        case PAGE_UP:
                            this.textMsg("PAGE_UP " + _("Scrolling up."));
                            this.blocksContainer.y += this.canvas.height / 2;
                            this.stage.update();
                            break;
                        case PAGE_DOWN:
                            this.textMsg("PAGE_DOWN " + _("Scrolling down."));
                            this.blocksContainer.y -= this.canvas.height / 2;
                            this.stage.update();
                            break;
                        case DEL:
                            this.textMsg("DEL " + _("Extracting block"));
                            this.blocks.extract();
                            break;
                        case KEYCODE_UP:
                            if (this.inTempoWidget) {
                                this.logo.tempo.speedUp(0);
                            } else {
                                if (this.blocks.activeBlock !== null) {
                                    this.textMsg("UP ARROW " + _("Moving block up."));
                                    this.blocks.moveStackRelative(
                                        this.blocks.activeBlock,
                                        0,
                                        -STANDARDBLOCKHEIGHT / 2
                                    );
                                    this.blocks.blockMoved(this.blocks.activeBlock);
                                    this.blocks.adjustDocks(this.blocks.activeBlock, true);
                                } else if (this.palettes.activePalette !== null) {
                                    this.palettes.activePalette.scrollEvent(STANDARDBLOCKHEIGHT, 1);
                                } else {
                                    this.blocksContainer.y += 20;
                                }
                                this.stage.update();
                            }
                            break;
                        case KEYCODE_DOWN:
                            if (this.inTempoWidget) {
                                this.logo.tempo.slowDown(0);
                            } else {
                                if (this.blocks.activeBlock !== null) {
                                    this.textMsg("DOWN ARROW " + _("Moving block down."));
                                    this.blocks.moveStackRelative(
                                        this.blocks.activeBlock,
                                        0,
                                        STANDARDBLOCKHEIGHT / 2
                                    );
                                    this.blocks.blockMoved(this.blocks.activeBlock);
                                    this.blocks.adjustDocks(this.blocks.activeBlock, true);
                                } else if (this.palettes.activePalette !== null) {
                                    this.palettes.activePalette.scrollEvent(
                                        -STANDARDBLOCKHEIGHT,
                                        1
                                    );
                                } else {
                                    this.blocksContainer.y -= 20;
                                }
                                this.stage.update();
                            }
                            break;
                        case KEYCODE_LEFT:
                            if (!this.inTempoWidget) {
                                if (this.blocks.activeBlock !== null) {
                                    this.textMsg("LEFT ARROW " + _("Moving block left."));
                                    this.blocks.moveStackRelative(
                                        this.blocks.activeBlock,
                                        -STANDARDBLOCKHEIGHT / 2,
                                        0
                                    );
                                    this.blocks.blockMoved(this.blocks.activeBlock);
                                    this.blocks.adjustDocks(this.blocks.activeBlock, true);
                                } else if (this.scrollBlockContainer) {
                                    this.blocksContainer.x += 20;
                                }
                                this.stage.update();
                            }
                            break;
                        case KEYCODE_RIGHT:
                            if (!this.inTempoWidget) {
                                if (this.blocks.activeBlock !== null) {
                                    this.textMsg("RIGHT ARROW " + _("Moving block right."));
                                    this.blocks.moveStackRelative(
                                        this.blocks.activeBlock,
                                        STANDARDBLOCKHEIGHT / 2,
                                        0
                                    );
                                    this.blocks.blockMoved(this.blocks.activeBlock);
                                    this.blocks.adjustDocks(this.blocks.activeBlock, true);
                                } else if (this.scrollBlockContainer) {
                                    this.blocksContainer.x -= 20;
                                }
                                this.stage.update();
                            }
                            break;
                        case HOME:
                            this.textMsg("HOME " + _("Jump to home position."));
                            if (this.palettes.mouseOver) {
                                const dy = Math.max(55 - this.palettes.buttons["rhythm"].y, 0);
                                this.palettes.menuScrollEvent(1, dy);
                                this.palettes.hidePaletteIconCircles();
                            } else if (this.palettes.activePalette !== null) {
                                this.palettes.activePalette.scrollEvent(
                                    -this.palettes.activePalette.scrollDiff,
                                    1
                                );
                            } else {
                                // Bring all the blocks "home".
                                this._findBlocks();
                            }
                            this.stage.update();
                            break;
                        case TAB:
                            break;
                        case ESC:
                            if (this.searchWidget.style.visibility === "visible") {
                                this.textMsg("ESC " + _("Hide blocks"));
                                this.searchWidget.style.visibility = "hidden";
                            }
                            break;
                        case RETURN:
                            this.textMsg("Return " + _("Play"));
                            if (this.inTempoWidget) {
                                if (this.logo.tempo.isMoving) {
                                    this.logo.tempo.pause();
                                }
                                this.logo.tempo.resume();
                            }
                            if (
                                this.blocks.activeBlock === null ||
                                !SPECIALINPUTS.includes(
                                    this.blocks.blockList[this.blocks.activeBlock].name
                                )
                            ) {
                                this.logo.runLogoCommands();
                            }
                            break;
                        default:
                            break;
                    }
                }

                // Always store current key so as not to mask it from
                // the keyboard block.
                this.currentKeyCode = event.keyCode;
            }
        };

        /**
         * @returns currentKeyCode
         */
        this.getCurrentKeyCode = () => {
            return this.currentKeyCode;
        };

        /*
         * Sets current key code to 0
         */
        this.clearCurrentKeyCode = () => {
            this.currentKey = "";
            this.currentKeyCode = 0;
        };

        /*
         * Handles resizing for MB.
         * Detects width/height changes and closes any menus before actual resize.
         * Repositions containers/palette/home buttons
         */
        this._onResize = force => {
            if (!force) {
                if (this.saveLocally !== null) {
                    this.saveLocally();
                }
            }
            if (!this.stage) {
                return;
            }

            // Skip resize when the tab is hidden — canvas reports 0×0
            // and any layout work would corrupt positions.
            if (document.hidden) {
                return;
            }

            const $j = window.jQuery;
            let w = 0,
                h = 0;
            if (typeof platform !== "undefined" && !platform.androidWebkit) {
                w = window.innerWidth;
                h = window.innerHeight;
            } else {
                w = window.outerWidth;
                h = window.outerHeight;
            }

            this._clientWidth = document.body.clientWidth;
            this._clientHeight = document.body.clientHeight;
            this._innerWidth = window.innerWidth;
            this._innerHeight = window.innerHeight;
            this._outerWidth = window.outerWidth;
            this._outerHeight = window.outerHeight;

            // Guard against zero or invalid dimensions to prevent
            // division-by-zero and ResizeObserver loop errors
            if (w <= 0 || h <= 0) {
                return;
            }

            if (document.getElementById("labelDiv").classList.contains("hasKeyboard")) {
                return;
            }

            const smallSide = Math.min(w, h);
            let mobileSize;
            if (smallSide < this.cellSize * 9) {
                mobileSize = false;
                /*
                if (w < this.cellSize * 10) {
                    this.turtleBlocksScale = smallSide / (this.cellSize * 11);
                } else {
                    this.turtleBlocksScale = Math.max(smallSide / (this.cellSize * 11), 0.75);
                }
                */
            } else {
                mobileSize = false;
                /*
                if (w / 1200 > h / 900) {
                    this.turtleBlocksScale = w / 1200;
                } else {
                    this.turtleBlocksScale = h / 900;
                }
                */
            }

            this.turtleBlocksScale = 1.0;

            this.stage.scaleX = this.turtleBlocksScale;
            this.stage.scaleY = this.turtleBlocksScale;

            this.stage.canvas.width = w;
            this.stage.canvas.height = h;

            this.turtles.doScale(w, h, this.turtleBlocksScale);

            this.boundary.setScale(w, h, this.turtleBlocksScale);
            this.trashcan.resizeEvent(this.turtleBlocksScale);

            // We need to reposition the palette buttons
            this._setupPaletteMenu();

            // Reposition coordinate grids.
            const newX = this.canvas.width / (2 * this.turtleBlocksScale) - 600;
            const newY = this.canvas.height / (2 * this.turtleBlocksScale) - 450;
            this.cartesianBitmap.x = newX;
            this.cartesianBitmap.y = newY;
            this.polarBitmap.x = newX;
            this.polarBitmap.y = newY;
            this.trebleBitmap.x = newX;
            this.trebleBitmap.y = newY;
            this.grandBitmap.x = newX;
            this.grandBitmap.y = newY;
            this.sopranoBitmap.x = newX;
            this.sopranoBitmap.y = newY;
            this.altoBitmap.x = newX;
            this.altoBitmap.y = newY;
            this.tenorBitmap.x = newX;
            this.tenorBitmap.y = newY;
            this.bassBitmap.x = newX;
            this.bassBitmap.y = newY;
            // The accidental overlays
            for (let i = 0; i < 7; i++) {
                this.grandSharpBitmap[i].x = newX;
                this.grandFlatBitmap[i].x = newX;
                this.trebleSharpBitmap[i].x = newX;
                this.trebleFlatBitmap[i].x = newX;
                this.sopranoSharpBitmap[i].x = newX;
                this.sopranoFlatBitmap[i].x = newX;
                this.altoSharpBitmap[i].x = newX;
                this.altoFlatBitmap[i].x = newX;
                this.tenorSharpBitmap[i].x = newX;
                this.tenorFlatBitmap[i].x = newX;
                this.bassSharpBitmap[i].x = newX;
                this.bassFlatBitmap[i].x = newX;
            }
            // Position the sharps and flats
            this.grandSharpBitmap[0].y = newY;
            this.grandSharpBitmap[1].y = this.canvas.height / (2 * this.turtleBlocksScale) - 412.5;
            this.grandSharpBitmap[2].y = this.canvas.height / (2 * this.turtleBlocksScale) - 462.5;
            this.grandSharpBitmap[3].y = this.canvas.height / (2 * this.turtleBlocksScale) - 425;
            this.grandSharpBitmap[4].y = this.canvas.height / (2 * this.turtleBlocksScale) - 387.5;
            this.grandSharpBitmap[5].y = this.canvas.height / (2 * this.turtleBlocksScale) - 437.5;
            this.grandSharpBitmap[6].y = this.canvas.height / (2 * this.turtleBlocksScale) - 400;
            this.grandFlatBitmap[0].y = newY;
            this.grandFlatBitmap[1].y = this.canvas.height / (2 * this.turtleBlocksScale) - 487.5;
            this.grandFlatBitmap[2].y = this.canvas.height / (2 * this.turtleBlocksScale) - 437.5;
            this.grandFlatBitmap[3].y = this.canvas.height / (2 * this.turtleBlocksScale) - 475;
            this.grandFlatBitmap[4].y = this.canvas.height / (2 * this.turtleBlocksScale) - 425;
            this.grandFlatBitmap[5].y = this.canvas.height / (2 * this.turtleBlocksScale) - 462.5;
            this.grandFlatBitmap[6].y = this.canvas.height / (2 * this.turtleBlocksScale) - 412.5;

            for (let i = 0; i < 7; i++) {
                this.trebleSharpBitmap[i].y = this.grandSharpBitmap[i].y;
                this.trebleFlatBitmap[i].y = this.grandFlatBitmap[i].y;
                this.sopranoSharpBitmap[i].y = this.grandSharpBitmap[i].y;
                this.sopranoFlatBitmap[i].y = this.grandFlatBitmap[i].y;
                this.altoSharpBitmap[i].y = this.grandSharpBitmap[i].y;
                this.altoFlatBitmap[i].y = this.grandFlatBitmap[i].y;
                this.tenorSharpBitmap[i].y = this.grandSharpBitmap[i].y;
                this.tenorFlatBitmap[i].y = this.grandFlatBitmap[i].y;
                this.bassSharpBitmap[i].y = this.grandSharpBitmap[i].y;
                this.bassFlatBitmap[i].y = this.grandFlatBitmap[i].y;
            }

            // Some accidentals on the Soprano staff shift by an octave.
            this.sopranoSharpBitmap[4].y -= 87.5;
            this.sopranoSharpBitmap[6].y -= 87.5;
            this.sopranoFlatBitmap[0].y -= 87.5;
            this.sopranoFlatBitmap[2].y -= 87.5;
            this.sopranoFlatBitmap[4].y -= 87.5;
            this.sopranoFlatBitmap[6].y -= 87.5;

            for (let i = 0; i < 7; i++) {
                this.sopranoSharpBitmap[i].y += 87.5;
                this.sopranoFlatBitmap[i].y += 87.5;
            }

            for (let i = 0; i < 7; i++) {
                this.altoSharpBitmap[i].y += 87.5;
                this.altoFlatBitmap[i].y += 87.5;
            }

            // Some accidentals on the tenor staff shift by an octave.
            this.tenorSharpBitmap[0].y += +87.5;
            this.tenorSharpBitmap[2].y += 87.5;

            for (let i = 0; i < 7; i++) {
                this.tenorSharpBitmap[i].y += 87.5;
                this.tenorFlatBitmap[i].y += 87.5;
            }

            for (let i = 0; i < 7; i++) {
                this.bassSharpBitmap[i].y += 175;
                this.bassFlatBitmap[i].y += 175;
            }

            this.update = true;

            // Hide tooltips on mobile
            if (typeof platform !== "undefined" && platform.mobile) {
                // palettes.setMobile(true);
                // palettes.hide();
                this.toolbar.disableTooltips($j);
            } else {
                this.palettes.setMobile(false);
            }

            for (let turtle = 0; turtle < this.turtles.getTurtleCount(); turtle++) {
                this.turtles.getTurtle(turtle).painter.doClear(false, false, true);
            }

            const artcanvas = document.getElementById("overlayCanvas");
            // Workaround for #795.5
            if (mobileSize) {
                artcanvas.width = w * 2;
                artcanvas.height = h * 2;
            } else {
                artcanvas.width = w;
                artcanvas.height = h;
            }

            this.blocks.checkBounds();
        };

        const container = document.getElementById("canvasContainer");
        const canvas = document.getElementById("myCanvas");
        const overCanvas = document.getElementById("canvas");
        const canvasHolder = document.getElementById("canvasHolder");
        const defaultWidth = 1600;
        const defaultHeight = 900;

        function handleResize() {
            // Skip resize when the tab is hidden to prevent 0×0 canvas
            if (document.hidden) {
                return;
            }

            const isMaximized =
                window.innerWidth === window.screen.width &&
                window.innerHeight === window.screen.height;
            if (isMaximized) {
                container.style.width = defaultWidth + "px";
                container.style.height = defaultHeight + "px";
                canvas.width = defaultWidth;
                canvas.height = defaultHeight;
                overCanvas.width = canvas.width;
                overCanvas.height = canvas.width;
                canvasHolder.width = defaultWidth;
                canvasHolder.height = defaultHeight;
            } else {
                const windowWidth = window.innerWidth;
                const windowHeight = window.innerHeight;

                // Guard against zero or invalid dimensions
                if (windowWidth <= 0 || windowHeight <= 0) {
                    return;
                }

                container.style.width = windowWidth + "px";
                container.style.height = windowHeight + "px";
                canvas.width = windowWidth;
                canvas.height = windowHeight;
                overCanvas.width = canvas.width;
                overCanvas.height = canvas.width;
                canvasHolder.width = canvas.width;
                canvasHolder.height = canvas.height;
            }
            document.getElementById("hideContents").click();
            that.refreshCanvas();
        }

        let resizeTimeout;
        this._handleWindowResize = () => {
            clearTimeout(resizeTimeout);
            resizeTimeout = setTimeout(() => {
                handleResize();
                this._setupPaletteMenu();
            }, 200);
        };
        this.addEventListener(window, "resize", this._handleWindowResize);
        this._handleOrientationChangeResize = handleResize;
        this.addEventListener(window, "orientationchange", this._handleOrientationChangeResize);

        // When the user returns to the Music Blocks tab after it was
        // hidden, re-apply the correct dimensions.  While the tab was
        // hidden the resize guards above intentionally skipped any
        // layout work, so we need to catch up now.
        this._handleVisibilityChange = () => {
            if (!document.hidden && this.stage) {
                // Use a short delay to let the browser finish
                // exposing the tab and reporting real dimensions.
                setTimeout(() => {
                    handleResize();
                    this._onResize(false);
                }, 250);
            }
        };
        this.addEventListener(document, "visibilitychange", this._handleVisibilityChange);

        const that = this;
        const resizeCanvas_ = () => {
            try {
                that._onResize(false);
                document.getElementById("hideContents").click();
            } catch (error) {
                // eslint-disable-next-line no-console
                console.error("An error occurred in resizeCanvas_:", error);
            }
        };

        resizeCanvas_();
        this._handleOrientationChangeResizeCanvas = resizeCanvas_;
        this.addEventListener(
            window,
            "orientationchange",
            this._handleOrientationChangeResizeCanvas
        );

        /*
         * Restore last stack pushed to trashStack back onto canvas.
         * Hides palettes before update
         * Repositions blocks about trash area
         */
        const restoreTrash = activity => {
            if (
                !activity.blocks ||
                !activity.blocks.trashStacks ||
                activity.blocks.trashStacks.length === 0
            ) {
                activity.textMsg(_("Trash can is empty."), 3000);
                return;
            }

            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
                activity.__tick();
            }
        };

        const restoreTrashPop = activity => {
            if (
                !activity.blocks ||
                !activity.blocks.trashStacks ||
                activity.blocks.trashStacks.length === 0
            ) {
                activity.textMsg(_("Trash can is empty."), 3000);
                return;
            }
            this._restoreTrashById(this.blocks.trashStacks[this.blocks.trashStacks.length - 1]);
            activity.textMsg(_("Item restored from the trash."), 3000);

            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
                activity.__tick();
            }
        };

        this._restoreTrashById = blockId => {
            const blockIndex = this.blocks.trashStacks.indexOf(blockId);
            if (blockIndex === -1) return; // Block not found in trash

            this.blocks.trashStacks.splice(blockIndex, 1); // Remove from trash

            for (const name in this.palettes.dict) {
                this.palettes.dict[name].hideMenu(true);
            }
            this.blocks.activeBlock = null;
            this.refreshCanvas();

            const dx = 0;
            const dy = -this.cellSize * 3; // Reposition

            // Restore drag group
            this.blocks.findDragGroup(blockId);
            for (let b = 0; b < this.blocks.dragGroup.length; b++) {
                const blk = this.blocks.dragGroup[b];
                this.blocks.blockList[blk].trash = false;
                this.blocks.moveBlockRelative(blk, dx, dy);

                // Re-cache the container if it was uncached to save
                // memory in sendStackToTrash().
                const block = this.blocks.blockList[blk];
                if (block.container && !block.container.bitmapCache) {
                    block.container.cache(
                        0,
                        0,
                        Math.max(block.width, 1),
                        Math.max(block.height, 1)
                    );
                }

                this.blocks.blockList[blk].show();
            }

            this.blocks.raiseStackToTop(blockId);
            const restoredBlock = this.blocks.blockList[blockId];

            if (restoredBlock.name === "start" || restoredBlock.name === "drum") {
                const turtle = restoredBlock.value;
                this.turtles.getTurtle(turtle).inTrash = false;
                this.turtles.getTurtle(turtle).container.visible = true;
            } else if (restoredBlock.name === "action") {
                const actionArg = this.blocks.blockList[restoredBlock.connections[1]];
                if (actionArg !== null) {
                    let label;
                    const oldName = actionArg.value;
                    restoredBlock.trash = true;
                    const uniqueName = this.blocks.findUniqueActionName(oldName);
                    restoredBlock.trash = false;

                    if (uniqueName !== actionArg) {
                        actionArg.value = uniqueName;
                        label =
                            uniqueName.length > 8 ? uniqueName.substr(0, 7) + "..." : uniqueName;
                        actionArg.text.text = label;

                        if (actionArg.label !== null) {
                            actionArg.label.value = uniqueName;
                        }
                        actionArg.container.updateCache();
                        for (let b = 0; b < this.blocks.dragGroup.length; b++) {
                            const me = this.blocks.blockList[this.blocks.dragGroup[b]];
                            if (
                                ["nameddo", "nameddoArg", "namedcalc", "namedcalcArg"].includes(
                                    me.name
                                ) &&
                                me.privateData === oldName
                            ) {
                                me.privateData = uniqueName;
                                me.value = uniqueName;
                                label =
                                    uniqueName.length > 8
                                        ? uniqueName.substr(0, 7) + "..."
                                        : uniqueName;
                                me.text.text = label;
                                me.overrideName = label;
                                me.regenerateArtwork();
                                me.container.updateCache();
                            }
                        }
                    }

                    // Re-add the action to the palette
                    const actionName = actionArg.value;
                    this.blocks.newNameddoBlock(
                        actionName,
                        this.blocks.actionHasReturn(blockId),
                        this.blocks.actionHasArgs(blockId)
                    );
                    this.palettes.updatePalettes("action");
                }
            }
            activity.textMsg(_("Item restored from the trash."), 3000);

            this.refreshCanvas();
        };

        // Add event listener for trash icon click
        document.getElementById("restoreIcon").addEventListener("click", () => {
            this._renderTrashView();
        });

        // Store the click handler reference for proper cleanup
        let trashViewClickHandler = null;

        // function to hide trashView from canvas
        function handleClickOutsideTrashView(trashView) {
            // Remove existing listener to prevent duplicates
            if (trashViewClickHandler) {
                document.removeEventListener("click", trashViewClickHandler);
            }

            let firstClick = true;
            trashViewClickHandler = event => {
                if (firstClick) {
                    firstClick = false;
                    return;
                }
                if (!trashView.contains(event.target) && event.target !== trashView) {
                    trashView.style.display = "none";
                    // Clean up listener when trashView is hidden
                    document.removeEventListener("click", trashViewClickHandler);
                    trashViewClickHandler = null;
                }
            };
            document.addEventListener("click", trashViewClickHandler);
        }

        this._renderTrashView = () => {
            if (
                !activity.blocks ||
                !activity.blocks.trashStacks ||
                activity.blocks.trashStacks.length === 0
            ) {
                return;
            }
            const trashList = document.getElementById("trashList");
            const trashView = document.createElement("div");
            trashView.id = "trashView";
            trashView.classList.add("trash-view");

            // Sticky icons
            const buttonContainer = document.createElement("div");
            buttonContainer.classList.add("button-container");

            const restoreLastIcon = document.createElement("a");
            restoreLastIcon.id = "restoreLastIcon";
            restoreLastIcon.classList.add("restore-last-icon");
            restoreLastIcon.innerHTML = '<i class="material-icons md-48">restore_from_trash</i>';
            restoreLastIcon.addEventListener("click", () => {
                this._restoreTrashById(this.blocks.trashStacks[this.blocks.trashStacks.length - 1]);
                trashView.classList.add("hidden");
            });

            const restoreAllIcon = document.createElement("a");
            restoreAllIcon.id = "restoreAllIcon";
            restoreAllIcon.classList.add("restore-all-icon");
            restoreAllIcon.innerHTML = '<i class="material-icons md-48">delete_sweep</i>';
            restoreAllIcon.addEventListener("click", () => {
                while (this.blocks.trashStacks.length > 0) {
                    this._restoreTrashById(this.blocks.trashStacks[0]);
                }
                trashView.classList.add("hidden");
            });
            restoreLastIcon.setAttribute("title", _("Restore last item"));
            restoreAllIcon.setAttribute("title", _("Restore all items"));

            buttonContainer.appendChild(restoreLastIcon);
            buttonContainer.appendChild(restoreAllIcon);
            trashView.appendChild(buttonContainer);

            // Render trash items
            this.blocks.trashStacks.forEach(blockId => {
                const block = this.blocks.blockList[blockId];
                const listItem = document.createElement("div");
                listItem.classList.add("trash-item");

                const svgData = block.artwork;
                const encodedData = "data:image/svg+xml;utf8," + encodeURIComponent(svgData);

                const img = document.createElement("img");
                img.src = encodedData;
                img.alt = "Block Icon";
                img.classList.add("trash-item-icon");

                const textNode = document.createTextNode(block.name);

                listItem.appendChild(img);
                listItem.appendChild(textNode);
                listItem.dataset.blockId = blockId;

                listItem.addEventListener("mouseover", () => listItem.classList.add("hover"));
                listItem.addEventListener("mouseout", () => listItem.classList.remove("hover"));
                listItem.addEventListener("click", () => {
                    this._restoreTrashById(blockId);
                    trashView.classList.add("hidden");
                });
                handleClickOutsideTrashView(trashView);

                trashView.appendChild(listItem);
            });

            const existingView = document.getElementById("trashView");
            if (existingView) {
                trashList.replaceChild(trashView, existingView);
            } else {
                trashList.appendChild(trashView);
            }
        };

        /*
         * Open aux menu
         */
        this._openAuxMenu = () => {
            if (!this.turtles.running() && this.toolbarHeight === 0) {
                this._showHideAuxMenu(false);
            }
        };

        /*
         * Toggles Aux menu visibility and positioning
         */
        const showHideAuxMenu = (activity, resize) => {
            activity._showHideAuxMenu(resize);
        };

        this._showHideAuxMenu = resize => {
            const cellsize = 55;
            let dy;

            // function to increase or decrease the "top" property of the top-right corner buttons

            const topRightButtons = document.querySelectorAll("#buttoncontainerTOP .tooltipped");
            const gridElement = document.getElementById("Grid");
            const btnY = gridElement ? gridElement.getBoundingClientRect().top : 70 + LEADING + 6;

            this.changeTopButtonsPosition = value => {
                topRightButtons.forEach(child => {
                    child.style.top = `${btnY + value}px`;
                });
            };

            if (!resize && this.toolbarHeight === 0) {
                dy = cellsize + LEADING + 5;

                this.toolbarHeight = dy;
                this.palettes.deltaY(dy);
                this.turtles.deltaY(dy);
                this.blocksContainer.y += dy;
                this.changeTopButtonsPosition(dy);

                this.cartesianBitmap.y += dy;
                this.polarBitmap.y += dy;
                this.trebleBitmap.y += dy;
                this.grandBitmap.y += dy;
                this.sopranoBitmap.y += dy;
                this.altoBitmap.y += dy;
                this.tenorBitmap.y += dy;
                this.bassBitmap.y += dy;
                this.blocks.checkBounds();
            } else {
                dy = this.toolbarHeight;
                this.toolbarHeight = 0;

                this.turtles.deltaY(-dy);
                this.palettes.deltaY(-dy);
                this.blocksContainer.y -= dy;
                this.changeTopButtonsPosition(-dy);

                this.cartesianBitmap.y -= dy;
                this.polarBitmap.y -= dy;
                this.trebleBitmap.y -= dy;
                this.grandBitmap.y -= dy;
                this.sopranoBitmap.y -= dy;
                this.altoBitmap.y -= dy;
                this.tenorBitmap.y -= dy;
                this.bassBitmap.y -= dy;
            }

            this.refreshCanvas();
        };

        /*
         * Hides aux menu
         */
        this.hideAuxMenu = () => {
            if (this.toolbarHeight > 0) {
                this._showHideAuxMenu(false);
                this.menuButtonsVisible = false;
            }
        };

        /**
         * Hide the palettes before update, then deletes everything/sends all to trash.
         * @param {boolean} addStartBlock {if true adds a new start block to new project instance}
         * @param {boolean} doNotSave     {if true discards any changes to project}
         * @param {boolean} closeAllWidgets  {if true close all open widgets}
         */
        this.sendAllToTrash = (addStartBlock, doNotSave, closeAllWidgets = true) => {
            // Return to home position after loading new blocks.
            this.blocksContainer.x = 0;
            this.blocksContainer.y = 0;
            for (const name in this.blocks.palettes.dict) {
                this.palettes.dict[name].hideMenu(true);
            }

            hideDOMLabel();
            this.refreshCanvas();

            let actionBlockCounter = 0;
            const dx = 0;
            const dy = this.cellSize * 3;
            for (const blk in this.blocks.blockList) {
                // If this block is at the top of a stack, push it
                // onto the trashStacks list.
                if (this.blocks.blockList[blk].connections[0] === null) {
                    this.blocks.trashStacks.push(blk);
                }

                if (
                    this.blocks.blockList[blk].name === "start" ||
                    this.blocks.blockList[blk].name === "drum"
                ) {
                    const turtle = this.blocks.blockList[blk].value;
                    if (!this.blocks.blockList[blk].trash && turtle !== null) {
                        this.turtles.getTurtle(turtle).inTrash = true;
                        this.turtles.getTurtle(turtle).container.visible = false;
                    }
                } else if (this.blocks.blockList[blk].name === "action") {
                    if (!this.blocks.blockList[blk].trash) {
                        this.blocks.deleteActionBlock(this.blocks.blockList[blk]);
                        actionBlockCounter += 1;
                    }
                }

                this.blocks.blockList[blk].trash = true;
                this.blocks.moveBlockRelative(blk, dx, dy);
                this.blocks.blockList[blk].hide();
            }

            if (addStartBlock) {
                this.blocks.loadNewBlocks(DATAOBJS);
                this._allClear(false);
            } else if (!doNotSave) {
                // Overwrite session data too.
                this.saveLocally();
            }

            // Wait for palette to clear (#891)
            // We really need to signal when each palette item is deleted
            const that = this;
            setTimeout(() => {
                that.stage.dispatchEvent("trashsignal");
            }, 100 * actionBlockCounter); // 1000

            this.update = true;

            // Close any open widgets.
            if (closeAllWidgets) {
                closeWidgets();
            }
        };

        /*
         * Toggles block/palette visibility
         */
        const changeBlockVisibility = activity => {
            activity._changeBlockVisibility();
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
                activity.__tick();
            }
        };

        this._changeBlockVisibility = () => {
            hideDOMLabel();

            if (this.blocks.visible) {
                this.blocks.hideBlocks();
                this.showBlocksAfterRun = false;
                this.palettes.hide();
                changeImage(
                    this.hideBlocksContainer.children[0],
                    SHOWBLOCKSBUTTON,
                    HIDEBLOCKSFADEDBUTTON
                );
            } else {
                changeImage(
                    this.hideBlocksContainer.children[0],
                    HIDEBLOCKSFADEDBUTTON,
                    SHOWBLOCKSBUTTON
                );
                this.blocks.showBlocks();
                this.palettes.show();
            }
        };

        /*
         * Toggles collapsible stacks (if collapsed stacks expand and vice versa)
         */
        const toggleCollapsibleStacks = activity => {
            activity._toggleCollapsibleStacks();
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
                activity.__tick();
            }
        };

        this._toggleCollapsibleStacks = () => {
            hideDOMLabel();

            if (this.blocks.visible) {
                this.blocks.toggleCollapsibles();
            }
        };

        /*
         * When turtle stops running restore stop button to normal state
         */
        this.onStopTurtle = () => {
            // TODO: plugin support
        };

        /*
         * When turtle starts running change stop button to running state
         */
        this.onRunTurtle = () => {
            // TODO: plugin support
        };

        /*
         * Clears cache for all blocks
         */
        this.clearCache = () => {
            this.blocks.blockList.forEach(block => {
                // Skip trashed blocks — they are hidden and their backing
                // canvases are freed in sendStackToTrash(). Re-caching them
                // here would waste ~0.5–2 MB per trashed block.
                if (block.trash) return;

                if (block.container) {
                    block.container.uncache();
                    block.container.cache();
                }
                if (block.bitmap) {
                    block.bitmap.uncache();
                    block.bitmap.cache();
                }
            });
        };

        /*
         * Updates all canvas elements by marking stage as dirty.
         * The actual render will happen on the next animation frame.
         */
        this.refreshCanvas = () => {
            if (this.blockRefreshCanvas) {
                return;
            }

            this.blockRefreshCanvas = true;
            // Mark stage as needing update
            this.stageDirty = true;
            this.update = true;

            const that = this;
            setTimeout(() => {
                that.blockRefreshCanvas = false;
                that.stageDirty = true;
            }, 5);
        };

        /*
         * This sets the dirty flag so the stage re-renders on the next
         * animation frame when an event handler indicates a change has happened.
         */
        this.__tick = event => {
            if (this.update || createjs.Tween.hasActiveTweens()) {
                this.update = false;
                this.stageDirty = true;
            }
        };

        /*
         * Marks the stage as needing a redraw on the next animation frame.
         * Call this whenever visual changes occur that need to be rendered.
         */
        this.markStageDirty = () => {
            this.stageDirty = true;
        };

        /*
         * Opens samples on planet after closing all sub menus.
         */
        const doOpenSamples = that => {
            that._doOpenSamples();
        };

        this._doOpenSamples = () => {
            if (document.getElementById("palette").style.display !== "none")
                document.getElementById("palette").style.display = "none";
            this.toolbar.closeAuxToolbar(showHideAuxMenu);
            this.planet.openPlanet();
            if (document.getElementById("buttoncontainerBOTTOM").style.display !== "none")
                document.getElementById("buttoncontainerBOTTOM").style.display = "none";
            if (document.getElementById("buttoncontainerTOP").style.display !== "none")
                document.getElementById("buttoncontainerTOP").style.display = "none";
        };

        /*
         * Uploads MB file to Planet
         */
        this.doUploadToPlanet = () => {
            this.planet.openPlanet();
        };

        /*
         * Opens piemenu for selecting master key signature
         */
        const chooseKeyMenu = that => {
            piemenuKey(that);
            // Cache DOM element reference for performance
            const helpfulWheelDiv = document.getElementById("helpfulWheelDiv");
            if (helpfulWheelDiv.style.display !== "none") {
                helpfulWheelDiv.style.display = "none";
            }
        };

        /*
         * @param merge {if specified the selected file's blocks merge into current project}
         *  Loads/merges existing MB file
         */
        const doLoad = (that, merge) => {
            that.toolbar.closeAuxToolbar(showHideAuxMenu);
            if (merge === undefined) {
                merge = false;
            }

            if (merge) {
                that.merging = true;
            } else {
                that.merging = false;
            }

            document.querySelector("#myOpenFile").focus();
            document.querySelector("#myOpenFile").click();
            window.scroll(0, 0);
            doHardStopButton(that);
            that._allClear(true, true);
        };

        window.prepareExport = this.prepareExport;

        /**
         * Runs music blocks project.
         * @param env {specifies environment}
         */
        this.runProject = env => {
            document.removeEventListener("finishedLoading", this.runProject);

            const that = this;
            setTimeout(() => {
                that._changeBlockVisibility();
                that._doFastButton(env);
            }, 5000);
        };

        const standardDurations = [
            { value: "1/1", duration: 1 },
            { value: "1/2", duration: 0.5 },
            { value: "1/4", duration: 0.25 },
            { value: "1/8", duration: 0.125 },
            { value: "1/16", duration: 0.0625 },
            { value: "1/32", duration: 0.03125 },
            { value: "1/64", duration: 0.015625 },
            { value: "1/128", duration: 0.0078125 }
        ];

        this.getClosestStandardNoteValue = function (duration) {
            let closest = standardDurations[0];
            let minDiff = Math.abs(duration - closest.duration);

            for (let i = 1; i < standardDurations.length; i++) {
                let diff = Math.abs(duration - standardDurations[i].duration);
                if (diff < minDiff) {
                    closest = standardDurations[i];
                    minDiff = diff;
                }
            }

            return closest.value.split("/").map(Number);
        };

        /**
         * Loads MB project from Planet.
         * @param  projectID {Planet project ID}
         * @param  flags     {parameters}
         * @param  env       {specifies environment}
         */
        const loadProject = (activity, projectID, flags, env) => {
            activity._loadProject(projectID, flags, env);
        };

        const loadStart = async that => {
            const __afterLoad = async () => {
                if (!that.turtles.running()) {
                    that.stage.update(event);
                    for (let turtle = 0; turtle < that.turtles.getTurtleCount(); turtle++) {
                        that.logo.turtleHeaps[turtle] = [];
                        that.logo.turtleDicts[turtle] = {};
                        that.logo.notation.notationStaging[turtle] = [];
                        that.logo.notation.notationDrumStaging[turtle] = [];
                        that.turtles.getTurtle(turtle).painter.doClear(true, true, false);
                    }
                    if (_THIS_IS_MUSIC_BLOCKS_) {
                        const imgUrl =
                            "data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?> <svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" id="svg1121" version="1.1" viewBox="0 0 34.131249 14.552089" height="55.000019" width="129"> <defs id="defs1115"> <clipPath id="clipPath4337" clipPathUnits="userSpaceOnUse"> <rect y="552" x="588" height="1436" width="1900" id="rect4339" style="fill:#a3b5c4;fill-opacity:1;stroke:none;stroke-width:15;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> </clipPath> </defs> <metadata id="metadata1118"> <rdf:RDF> <cc:Work rdf:about=""> <dc:format>image/svg+xml</dc:format> <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage" /> <dc:title></dc:title> </cc:Work> </rdf:RDF> </metadata> <g transform="matrix(1.086782,0,0,1.086782,-1.5473245,-1.305799)" id="g1812"> <ellipse transform="matrix(0.01046099,0,0,0.01046099,1.0167389,-6.2048529)" clip-path="url(#clipPath4337)" ry="768" rx="748" cy="1476" cx="1540" id="path4333" style="display:inline;fill:#a3b5c4;fill-opacity:1;stroke:none;stroke-width:15;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <ellipse ry="1.7826859" rx="1.6939216" cy="8.8343534" cx="16.446739" id="path4256" style="display:inline;fill:#c9dad8;fill-opacity:1;stroke:#c9dad8;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4328" d="m 17.630266,13.48709 0.32547,0.392044 0.34766,0.27369 0.310676,0.110955 0.236705,-0.05178 0.140544,-0.184926 0.19972,0.08137 0.155338,0.04438 0.613954,-0.421632 0.421631,-0.251499 c 0,0 0.887645,-0.0074 1.605157,-0.554777 0.717513,-0.547381 0.495602,-0.650939 0.495602,-0.650939 l -0.03699,-0.429029 -0.539984,-0.717513 -0.554777,-0.569571 -0.229309,-0.147941 c 0,0 -0.02219,-0.04438 -0.07397,-0.04438 -0.05178,0 -0.244103,-0.07397 -0.517793,0.04438 -0.273691,0.118353 -0.466014,0.170132 -0.843263,0.384646 -0.377248,0.214514 -0.710115,0.421631 -0.835865,0.495602 -0.12575,0.07397 -0.7471,0.429028 -0.7471,0.429028 l -0.09616,0.658336 z" style="display:inline;fill:#f8f8f8;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.01046099px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" /> <path id="path4330" d="m 18.081485,13.117239 c 0,0 1.017202,0.219808 1.490613,-0.13525 0.68255,-0.674097 1.655893,-1.154731 1.870355,-1.745308 0.108257,-0.298116 0.09265,-0.372377 -0.08018,-0.637191 -0.784085,-1.1169523 -2.186023,0.483563 -2.186023,0.483563 l -1.220511,1.042983 z" style="display:inline;fill:#c9dad8;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.01046099px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" /> <path id="path4281" d="m 18.923638,11.911166 c 0,0 -2.262073,0.360073 -1.245807,1.631426 1.016268,1.271354 1.33159,0.468415 1.33159,0.468415 0,0 0.237364,0.284021 0.550221,-0.01289 0.312857,-0.29691 0.801657,-0.486563 0.801657,-0.486563 0,0 0.833419,-0.08158 1.728851,-0.640345 0.895432,-0.558769 0.02545,-1.494644 0.02545,-1.494644 0,0 -0.704002,-0.914305 -1.191158,-1.062004 -0.487155,-0.147699 -1.260206,-0.205963 -1.260206,-0.205963 z" style="display:inline;fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path5926" d="m 16.889165,3.9907067 c -0.205925,0.00902 -0.490584,0.016452 -0.682434,0.094306 -0.36351,0.1131625 -0.784019,0.3065916 -1.102039,0.4145197 C 14.805707,4.6009993 14.528383,4.8675841 14.442515,4.7707676 14.31485,4.6268244 14.224353,4.595363 14.045689,4.497559 13.801781,4.399505 13.873773,4.4448272 13.660866,4.3863283 13.513681,4.3458871 13.44829,4.2882958 13.047954,4.3023567 c -0.216087,0.00759 -0.47351,0.00804 -0.660081,0.089725 -0.374615,0.1640178 -0.299,0.2484757 -0.538572,0.4900252 -0.165108,0.1664709 -0.223029,0.5749831 -0.282041,0.818858 -0.06939,0.2867776 -0.0547,0.6010393 -0.02031,0.9674031 0.02761,0.2941965 0.09173,0.4973939 0.249388,0.759063 0.135084,0.2241989 0.324561,0.2835828 0.54659,0.4972893 0.07774,0.07483 0.368398,-0.038965 0.48488,-0.015104 0.108709,0.02227 -0.04817,0.2167088 -0.0532,0.2453834 -0.0538,0.2395169 -0.110503,0.087771 -0.0806,0.6274261 0.348123,2.0266892 1.005089,-1.0672647 0.326649,0.6686194 -0.05298,0.135564 -0.437594,0.3888068 -0.503368,0.5868538 -0.01267,0.165109 0.197835,0.19408 0.318997,0.178049 0.06266,0.480395 0.124982,1.042048 0.522242,1.372439 0.120177,0.106402 0.286652,0.09447 0.429317,0.126443 0.221641,0.268128 0.448668,0.557066 0.784087,0.689774 0.283845,0.148435 0.624913,0.051 0.896138,0.233065 0.712925,0.360901 1.59437,0.227424 2.240307,-0.214367 0.239736,-0.02584 0.501243,0.05119 0.751391,0.02222 0.575898,-0.02006 1.167207,-0.240005 1.523962,-0.711502 0.0729,-0.066 0.102081,-0.17814 0.168803,-0.240635 0.06616,0.0833 0.201079,0.165289 0.285653,0.05502 0.193072,-0.253436 0.223413,-0.595104 0.327145,-0.882559 0.08658,0.03641 0.0842,0.265734 0.19082,0.175968 0.08858,-0.27751 0.231055,-0.589554 0.157487,-0.875103 C 21.094968,9.8641514 20.994799,9.7109879 20.959751,9.6709914 21.06973,9.6649214 21.392146,9.6074124 21.364226,9.434279 21.284902,9.2640651 20.930324,9.0580893 20.78147,8.9636893 20.627489,7.0823629 20.831941,7.9730043 20.374475,6.5721668 20.286693,6.296366 20.179582,6.0253908 20.039149,5.7673778 19.814155,5.3540076 19.50363,4.9739075 19.050031,4.6605328 18.694157,4.4866157 18.779167,4.4124578 18.416319,4.2842118 18.040916,4.114893 17.923126,4.1144294 17.706217,4.0495514 17.421993,4.0042382 17.176226,3.9934611 16.889165,3.9907067 Z m -0.416777,3.7702345 c 0.258005,0.00976 0.429259,0.254814 0.527501,0.468441 -0.04651,0.1209123 -0.217613,0.1803318 -0.314316,0.2708005 -0.05227,0.030898 -0.195057,0.1419829 -0.07397,0.1762583 0.167574,-0.00801 0.341125,-0.101776 0.502363,-0.081253 0.0388,0.3136927 0.01038,0.7255031 -0.295939,0.9021495 -0.316884,0.082827 -0.562053,-0.2121416 -0.676829,-0.471618 -0.147096,-0.3666902 -0.185934,-0.8428431 0.07651,-1.1669988 0.06531,-0.068268 0.160011,-0.1063475 0.254678,-0.09778 z m 2.859244,2.5757878 c -0.07673,0.184758 -0.230659,0.330156 -0.407011,0.413252 -0.05539,0.150705 0.04004,0.35438 0.0297,0.483234 -0.04907,-0.160357 -0.0016,-0.361426 -0.108875,-0.496757 -0.07018,-0.02271 -0.147747,-0.0281 -0.211741,-0.07206 0.212794,0.117717 0.49561,0.03924 0.604766,-0.182094 0.02934,-0.03762 0.08159,-0.145575 0.09316,-0.145571 z m -0.965372,0.141988 c 0.04566,0.03409 0.204897,0.162857 0.07744,0.06785 -0.01641,-0.01138 -0.09019,-0.07086 -0.07744,-0.06785 z" style="display:inline;fill:#c9dad8;fill-opacity:1;stroke:none;stroke-width:0.05230495;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4257" d="m 18.562292,4.3406543 c 0,0 -0.01823,-0.1260925 0.05503,-0.2630911 0.107065,-0.2002118 0.364043,-0.4099485 0.661951,-0.5965291 0.390579,-0.2446202 0.878105,-0.4015772 1.457653,0.035985 0.150331,0.1135008 0.27512,0.3561849 0.43652,0.5462458 0,0 0.443822,0.5325871 0.05918,1.7900829 C 20.847978,7.110845 20.24142,6.5338754 20.24142,6.5338754 Z" style="display:inline;fill:#c9dad8;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.01046099px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" /> <path id="path4259" d="m 15.544962,4.3156298 c 0.674016,0.862017 2.224945,3.3646467 2.552481,2.1357471 0.20922,-0.9101061 0.01532,-2.3025973 0.01532,-2.3025973 0,0 -1.252038,-0.4658857 -2.567802,0.1668502 z" style="display:inline;fill:#899bb0;fill-opacity:1;fill-rule:evenodd;stroke:#899bb0;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4276" d="m 14.55326,9.3192563 c 0,0 -0.167376,0.052305 1.098404,0.3347517 1.26578,0.2824467 1.621453,-0.6695034 1.621453,-0.6695034 0,0 1.035638,-1.5168436 2.144503,-0.3033687 0,0 0.282447,0.3033687 0.784575,0.2929077 0,0 0.313829,-0.1778368 0.575354,-0.010461 0.261525,0.1673759 0.491667,0.3242907 0.491667,0.3242907 0,0 0.387056,0.3661347 -0.292908,0.3556737 0,0 0.4289,0.1046099 -0.08369,1.339007 l -0.146454,-0.334752 c 0,0 -0.20922,1.401773 -0.575354,0.868262 0,0 -0.168567,0.284042 -0.549335,0.538111 -0.461704,0.308073 -1.20062,0.579034 -1.882846,0.335382 0,0 -0.929436,1.023563 -2.512402,0.121125 0,0 -0.871728,0.166552 -1.457543,-0.816781 0,0 -0.805496,0.198759 -0.95195,-1.495922 0,0 -0.679965,0.04184 -0.04184,-0.543971 0.63812,-0.5858155 1.203014,-0.4602836 1.203014,-0.4602836 z" style="display:inline;fill:#f8f8f8;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.01046099px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" /> <path id="path4365" d="m 13.538544,5.3179276 c -0.01698,0.00333 -0.295429,0.00411 -0.542614,-0.1287894 -0.126298,-0.067906 -0.247026,-0.1270069 -0.29127,-0.1859807 -0.03564,-0.047508 0.0041,-0.1114587 -0.06685,-0.053022 -0.949852,0.7828116 -0.485867,2.0489157 0.391518,2.3817499 0,0 0.16803,-0.930502 1.084571,-1.9878057" style="display:inline;fill:#f8f8f8;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.01046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4367" d="m 18.969129,4.5514697 c 0,0 0.961615,0.6805271 1.19832,1.6125543 0,0 1.153939,-1.7309068 -0.07397,-2.4262282 0,0 -0.207118,0.79888 -1.124351,0.8136739 z" style="display:inline;fill:#f8f8f8;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.01046099px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" /> <path id="path4215" d="m 12.838685,10.209018 c 0.144399,1.761682 0.938601,1.472882 0.938601,1.472882 0.63536,1.0108 1.429561,0.82308 1.429561,0.82308 1.371802,0.837522 2.527003,-0.101079 2.527003,-0.101079 1.934963,0.31768 2.411483,-0.924162 2.411483,-0.924162 0.375441,0.577601 0.606481,-0.808641 0.606481,-0.808641 0.05776,-0.11552 0.144401,0.34656 0.144401,0.34656 0.462079,-1.2129605 0.08324,-1.377833 0.08324,-1.377833 1.010801,0.02888 -0.203626,-0.702874 -0.203626,-0.702874 -0.02553,-1.0590654 -0.02508,-1.3292131 -0.390054,-2.3334378 0.809797,0.2163877 0.811057,-0.9606589 0.94917,-1.2297877 0.199919,-0.5390245 -0.0356,-1.5044904 -0.679641,-1.9195323 -0.265411,-0.1710387 -0.6002,-0.2486009 -1.002486,-0.1643198 -0.302755,0.1390128 -0.69254,0.3949895 -0.907628,0.6086619 -0.193613,0.1923395 -0.219649,0.3032114 -0.195442,0.415557" style="fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4227" d="m 12.838685,10.211495 c 0,0 -0.909721,0.0986 0.25992,-0.8111179 0,0 0.49096,-0.4187608 1.472881,-0.05776" style="fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4229" d="M 12.904904,9.565553 C 12.505653,8.7738548 12.670797,8.1656037 12.850244,7.958294" style="fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4201" d="m 14.581303,4.8227692 c 0,0 1.795749,-1.4517066 3.967207,-0.5150309" style="display:inline;fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path style="display:inline;fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" d="M 12.913527,7.8996581 C 10.894356,8.3520143 11.168402,4.2545247 12.764952,4.3025073 13.383569,4.2857373 14.097424,4.267855 14.65681,5.001513" id="path4207" /> <path id="path4233" d="m 18.340331,10.454499 c 0,0 0.66424,0.722 1.010801,-0.17328" style="display:inline;fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4235" d="m 18.889052,10.728859 0.0722,0.56316" style="display:inline;fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4251" d="m 14.13482,5.3440801 c -0.178391,0 -0.632946,0.00698 -0.994192,-0.086816 C 12.90873,5.1970519 12.715284,5.0953125 12.658026,4.9235378" style="display:inline;fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4301" d="m 12.672906,11.249959 c 0,0 -1.213113,0.880247 -0.724909,1.545981 l 0.59916,0.532586 0.821072,0.443823 1.227907,0.06657 0.806277,-0.147941 0.414234,-0.184926 0.443822,0.37725 0.399441,0.01479 0.229308,-0.110956 0.687924,-0.273691 0.362456,-0.284786 0.207117,-0.314373 -0.02959,-0.340264 c 0,0 -0.384646,-1.161335 -0.79888,-1.346261 0,0 -0.532587,-0.576969 -1.272291,-0.08137 0,0 -1.116952,0.369852 -2.085964,0.04438 -0.969012,-0.32547 -1.287085,0.05918 -1.287085,0.05918 z" style="display:inline;fill:#f8f8f8;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.01046099px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" /> <path id="path4325" d="m 11.85318,12.481094 c 0,0 1.220511,-0.702719 3.06977,-0.184927 0,0 0.917234,0.162736 1.508996,-0.06657 0.591764,-0.229309 0.791483,0.27369 0.791483,0.27369 0,0 0.466014,0.843262 0.39944,0.902438 l 0.177529,-0.05178 0.266293,-0.340264 0.07397,-0.258897 -0.140543,-0.429028 -0.273691,-0.576968 -0.310676,-0.443822 -0.251499,-0.184927 -0.421631,-0.184925 -0.406838,0.02959 -0.606556,0.251499 c 0,0 -1.028189,0.288485 -2.2487,-0.184925 0,0 -0.902438,-0.162736 -1.516392,0.983806 l -0.118353,0.399439 z" style="display:inline;fill:#c9dad8;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.01046099px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" /> <path id="path4279" d="m 16.833672,13.785217 c 0.153423,-0.102967 1.454122,-0.405144 1.27153,-1.107052 -0.18259,-0.701906 -0.810488,-2.18308 -1.962749,-1.621151 -1.152264,0.561932 -2.428271,0.04422 -2.428271,0.04422 0,0 -0.502575,-0.191198 -0.917137,0.04475 -0.414562,0.235951 -0.835691,0.624285 -0.96967,1.263836 -0.133982,0.639557 1.559745,1.341991 1.559745,1.341991 0,0 1.628567,0.238813 2.395693,-0.276035 0,0 0.629729,0.697771 1.050859,0.309437 z" style="display:inline;fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path d="m 17.114016,8.5098241 a 0.94989708,0.58640587 78.078062 0 1 -0.340613,1.0406955 0.94989708,0.58640587 78.078062 0 1 -0.776562,-0.678756 0.94989708,0.58640587 78.078062 0 1 0.23956,-1.1290216 0.94989708,0.58640587 78.078062 0 1 0.807736,0.5318372 l -0.503878,0.3563839 z" id="path4265" style="display:inline;fill:#505050;fill-opacity:1;stroke-width:0.10460994;stroke-miterlimit:4;stroke-dasharray:none" /> <path d="M 20.413977,8.0315906 A 0.85676325,0.52891095 78.078062 0 1 20.10676,8.9702498 0.85676325,0.52891095 78.078062 0 1 19.406336,8.3580431 0.85676325,0.52891095 78.078062 0 1 19.622407,7.3397176 0.85676325,0.52891095 78.078062 0 1 20.350948,7.8194108 l -0.454474,0.3214416 z" id="path4265-2" style="display:inline;fill:#505050;fill-opacity:1;stroke-width:0.10460994;stroke-miterlimit:4;stroke-dasharray:none" /> <path id="path5720" d="m 21.134832,7.6963634 c -0.112318,-0.027757 -0.262497,-0.081054 -0.333731,-0.1184383 -0.144005,-0.075573 -0.299329,-0.2698653 -0.299329,-0.374426 0,-0.096607 -0.193298,-0.846814 -0.294133,-1.1415597 C 19.91785,5.2148827 19.426736,4.6758205 18.806808,4.5243423 18.574543,4.4675893 18.37796,4.3777172 18.37796,4.3282851 c 0,-0.1165874 0.518787,-0.372059 0.755587,-0.3720818 0.225129,-2.09e-5 0.551773,0.1955105 0.754007,0.4513556 0.08958,0.113326 0.336843,0.5587874 0.549476,0.9899141 0.630891,1.2791719 1.127464,1.9684738 1.567563,2.1759633 0.217308,0.1024518 0.226116,0.111942 0.130881,0.1410215 -0.159835,0.048804 -0.77495,0.037681 -1.000642,-0.018094 z" style="fill:#000000;fill-opacity:0;stroke-width:0.05230495;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" /> <path id="path4245" d="m 15.544387,4.3143709 c 0,0 1.555226,2.1088053 2.078276,2.2761811 0.523049,0.1673759 0.550099,-1.2673939 0.550099,-1.2673939 0,0 0.01046,-0.8054962 -0.03138,-1.16117" style="fill:none;fill-rule:evenodd;stroke:none;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <path id="path4249" d="m 18.944377,4.5456262 c 0.250182,0.02965 0.853235,-0.055903 1.134665,-0.7723694" style="fill:none;fill-rule:evenodd;stroke:#505050;stroke-width:0.1046099;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> <text id="text4245" y="2.0512714" x="11.557299" style="font-style:normal;font-weight:normal;font-size:0.12553188px;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.01046099px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" xml:space="preserve"><tspan style="font-size:0.4184396px;line-height:1.25;stroke-width:0.01046099px" y="2.0512714" x="11.557299" id="tspan4247"> </tspan></text> </g> </svg>";
                        // eslint-disable-next-line no-console
                        console.log(
                            "%cMusic Blocks",
                            "font-size: 24px; font-weight: bold; font-family: sans-serif; padding:20px 0 0 110px; background: url(" +
                                imgUrl +
                                ") no-repeat;"
                        );
                        // eslint-disable-next-line no-console
                        console.log(
                            "%cMusic Blocks is a collection of tools for exploring fundamental musical concepts in a fun way.",
                            "font-size: 16px; font-family: sans-serif; font-weight: bold;"
                        );
                    } else {
                        // eslint-disable-next-line no-console
                        console.log(
                            "%cTurtle Blocks is a collection of tools for exploring  concepts from Logo in a fun way.",
                            "font-size: 16px; font-family: sans-serif; font-weight: bold;"
                        );
                    }
                    // Set flag to 1 to enable keyboard after MB finishes loading
                    that.keyboardEnableFlag = 1;
                }

                document.removeEventListener("finishedLoading", __afterLoad);
            };

            // Set the flag to zero to disable keyboard
            that.keyboardEnableFlag = 0;

            that.sessionData = null;

            // Try restarting where we were when we hit save.
            if (that.planet) {
                that.sessionData = await that.planet.openCurrentProject();
            } else {
                const currentProject = that.storage.currentProject;
                that.sessionData = that.storage["SESSION" + currentProject];
            }

            // After we have finished loading the project, clear all
            // to ensure a clean start.
            if (document.addEventListener) {
                document.addEventListener("finishedLoading", __afterLoad);
            } else {
                document.attachEvent("finishedLoading", __afterLoad);
            }

            if (that.sessionData) {
                that.doLoadAnimation();
                try {
                    if (that.sessionData === "undefined" || that.sessionData === "[]") {
                        that.justLoadStart();
                    } else {
                        window.loadedSession = that.sessionData;
                        that.blocks.loadNewBlocks(JSON.parse(that.sessionData));
                    }
                } catch (e) {
                    // eslint-disable-next-line no-console
                    console.error(e);
                }
            } else {
                that.justLoadStart();
            }

            that.update = true;
        };

        this._loadProject = (projectID, flags) => {
            if (this.planet === undefined) {
                return;
            }

            // Set default value of run.
            flags =
                typeof flags !== "undefined"
                    ? flags
                    : {
                          run: false,
                          show: false,
                          collapse: false
                      };
            this.loading = true;
            document.body.style.cursor = "wait";
            this.doLoadAnimation();

            // palettes.updatePalettes();
            this.textMsg(this.planet.getCurrentProjectName());

            const that = this;
            setTimeout(() => {
                try {
                    that.planet.openProjectFromPlanet(projectID, () => {
                        that.loadStartWrapper(loadStart);
                    });
                } catch (e) {
                    // eslint-disable-next-line no-console
                    console.error(e);
                    that.loadStartWrapper(loadStart);
                }

                that.planet.initialiseNewProject();
                // Restore default cursor
                that.loading = false;

                document.body.style.cursor = "default";
                that.update = true;
            }, 2500);

            const run = flags.run;
            const show = flags.show;
            const collapse = flags.collapse;

            const __functionload = () => {
                setTimeout(() => {
                    if (!collapse && that.firstRun) {
                        that._toggleCollapsibleStacks();
                    }

                    if (run && that.firstRun) {
                        for (let turtle = 0; turtle < that.turtles.getTurtleCount(); turtle++) {
                            that.turtles.getTurtle(turtle).painter.doClear(true, true, false);
                        }

                        that.textMsg(_("Click the run button to run the project."));

                        if (show) {
                            that._changeBlockVisibility();
                        }

                        if (!collapse) {
                            that._toggleCollapsibleStacks();
                        }
                    } else if (!show) {
                        that._changeBlockVisibility();
                    }

                    document.removeEventListener("finishedLoading", __functionload);
                    that.firstRun = false;
                }, 1000);
            };

            if (document.addEventListener) {
                document.addEventListener("finishedLoading", __functionload, false);
            } else {
                document.attachEvent("finishedLoading", __functionload);
            }
        };
        // Function to convert ABC pitch to MB pitch
        function _adjustPitch(note, keySignature) {
            const accidental = keySignature.accidentals.find(acc => {
                const noteToCompare = acc.note.toUpperCase().replace(",", "");
                note = note.replace(",", "");
                return noteToCompare.toLowerCase() === note.toLowerCase();
            });

            if (accidental) {
                return (
                    note + (accidental.acc === "sharp" ? "♯" : accidental.acc === "flat" ? "♭" : "")
                );
            } else {
                return note;
            }
        }
        // When converting to pitch value from ABC to MB there is issue
        // with the octave conversion. We map the pitch to audible pitch.
        function _abcToStandardValue(pitchValue) {
            const octave = Math.floor(pitchValue / 7) + 4;
            return octave;
        }
        // Creates pitch which consist of note pitch notename you could
        // see them in the function.
        function _createPitchBlocks(
            pitches,
            blockId,
            pitchDuration,
            keySignature,
            actionBlock,
            triplet,
            meterDen
        ) {
            const blocks = [];

            const pitch = pitches;
            pitchDuration = toFraction(pitchDuration);
            const adjustedNote = _adjustPitch(pitch.name, keySignature).toUpperCase();
            if (triplet !== undefined && triplet !== null) {
                pitchDuration[1] = meterDen * triplet;
            }

            actionBlock.push(
                [
                    blockId,
                    ["newnote", { collapsed: true }],
                    0,
                    0,
                    [blockId - 1, blockId + 1, blockId + 4, blockId + 8]
                ],
                [blockId + 1, "divide", 0, 0, [blockId, blockId + 2, blockId + 3]],
                [blockId + 2, ["number", { value: pitchDuration[0] }], 0, 0, [blockId + 1]],
                [blockId + 3, ["number", { value: pitchDuration[1] }], 0, 0, [blockId + 1]],
                [blockId + 4, "vspace", 0, 0, [blockId, blockId + 5]],
                [blockId + 5, "pitch", 0, 0, [blockId + 4, blockId + 6, blockId + 7, null]],
                [blockId + 6, ["notename", { value: adjustedNote }], 0, 0, [blockId + 5]],
                [
                    blockId + 7,
                    ["number", { value: _abcToStandardValue(pitch.pitch) }],
                    0,
                    0,
                    [blockId + 5]
                ],
                [blockId + 8, "hidden", 0, 0, [blockId, blockId + 9]]
            );
            return blocks;
        }

        // Function to search index for particular type of block
        // mainly used to find nammeddo block in repeat block.
        function _searchIndexForMusicBlock(array, x) {
            // Iterate over each sub-array in the main array
            for (let i = 0; i < array.length; i++) {
                // Check if the 0th element of the sub-array matches x
                if (array[i][0] === x) {
                    // Return the index if a match is found
                    return i;
                }
            }
            // Return -1 if no match is found
            return -1;
        }

        /*
          The parseABC function converts ABC notation to Music Blocks
          and is able to convert almost all the ABC notation to Music
          Blocks. However, the following aspects need work:

          Hammers, pulls, and sliding offs grace notes (breaking the
          conversion) Alternate endings (not failing but not showing
          correctly) and DS al coda Bass voicing (failing)
        */
        this.parseABC = async function (tune) {
            const musicBlocksJSON = [];
            const staffBlocksMap = {};
            const organizeBlock = {};
            let blockId = 0;
            let tripletFinder = null;
            const title = (tune.metaText?.title ?? "title").toString().toLowerCase();
            const instruction = (tune.metaText?.instruction ?? "guitar").toString().toLowerCase();

            tune.lines?.forEach(line => {
                line.staff?.forEach((staff, staffIndex) => {
                    if (!organizeBlock.hasOwnProperty(staffIndex)) {
                        organizeBlock[staffIndex] = {
                            arrangedBlocks: []
                        };
                    }

                    organizeBlock[staffIndex].arrangedBlocks.push(staff);
                });
            });
            for (const lineId in organizeBlock) {
                organizeBlock[lineId].arrangedBlocks?.forEach(staff => {
                    if (!staffBlocksMap.hasOwnProperty(lineId)) {
                        staffBlocksMap[lineId] = {
                            meterNum: staff?.meter?.value[0]?.num || 4,
                            meterDen: staff?.meter?.value[0]?.den || 4,
                            keySignature: staff.key,
                            baseBlocks: [],
                            startBlock: [
                                [
                                    blockId,
                                    ["start", { collapsed: false }],
                                    100,
                                    100,
                                    [null, blockId + 1, null]
                                ],
                                [blockId + 1, "print", 0, 0, [blockId, blockId + 2, blockId + 3]],
                                [blockId + 2, ["text", { value: title }], 0, 0, [blockId + 1]],
                                [
                                    blockId + 3,
                                    "setturtlename2",
                                    0,
                                    0,
                                    [blockId + 1, blockId + 4, blockId + 5]
                                ],
                                [
                                    blockId + 4,
                                    ["text", { value: `Voice ${parseInt(lineId) + 1} ` }],
                                    0,
                                    0,
                                    [blockId + 3]
                                ],
                                [
                                    blockId + 5,
                                    "meter",
                                    0,
                                    0,
                                    [blockId + 3, blockId + 6, blockId + 7, blockId + 10]
                                ],
                                [
                                    blockId + 6,
                                    ["number", { value: staff?.meter?.value[0]?.num || 4 }],
                                    0,
                                    0,
                                    [blockId + 5]
                                ],
                                [
                                    blockId + 7,
                                    "divide",
                                    0,
                                    0,
                                    [blockId + 5, blockId + 8, blockId + 9]
                                ],
                                [blockId + 8, ["number", { value: 1 }], 0, 0, [blockId + 7]],
                                [
                                    blockId + 9,
                                    ["number", { value: staff?.meter?.value[0]?.den || 4 }],
                                    0,
                                    0,
                                    [blockId + 7]
                                ],
                                [blockId + 10, "vspace", 0, 0, [blockId + 5, blockId + 11]],
                                [
                                    blockId + 11,
                                    "setkey2",
                                    0,
                                    0,
                                    [blockId + 10, blockId + 12, blockId + 13, blockId + 14]
                                ],
                                [
                                    blockId + 12,
                                    ["notename", { value: staff.key.root }],
                                    0,
                                    0,
                                    [blockId + 11]
                                ],
                                [
                                    blockId + 13,
                                    [
                                        "modename",
                                        { value: staff.key.mode == "m" ? "minor" : "major" }
                                    ],
                                    0,
                                    0,
                                    [blockId + 11]
                                ],
                                //In Settimbre instead of null it should be nameddoblock of first action block
                                [
                                    blockId + 14,
                                    "settimbre",
                                    0,
                                    0,
                                    [blockId + 11, blockId + 15, null, blockId + 16]
                                ],
                                [
                                    blockId + 15,
                                    ["voicename", { value: instruction }],
                                    0,
                                    0,
                                    [blockId + 14]
                                ],
                                [blockId + 16, "hidden", 0, 0, [blockId + 14, null]]
                            ],
                            repeatBlock: [],
                            repeatArray: [],
                            nameddoArray: {}
                        };

                        // For adding 17 blocks above
                        blockId += 17;
                    }

                    const actionBlock = [];
                    staff.voices.forEach(voice => {
                        voice.forEach(element => {
                            if (element.el_type === "note") {
                                //check if triplet exists
                                if (
                                    element?.startTriplet !== null &&
                                    element?.startTriplet !== undefined
                                ) {
                                    tripletFinder = element.startTriplet;
                                }

                                // Check and set tripletFinder to null
                                // if element?.endTriplets exists.
                                _createPitchBlocks(
                                    element.pitches[0],
                                    blockId,
                                    element.duration,
                                    staff.key,
                                    actionBlock,
                                    tripletFinder,
                                    staffBlocksMap[lineId].meterDen
                                );
                                if (
                                    element?.endTriplet !== null &&
                                    element?.endTriplet !== undefined
                                ) {
                                    tripletFinder = null;
                                }
                                blockId = blockId + 9;
                            } else if (element.el_type === "bar") {
                                if (element.type === "bar_left_repeat") {
                                    staffBlocksMap[lineId].repeatArray.push({
                                        start: staffBlocksMap[lineId].baseBlocks.length,
                                        end: -1
                                    });
                                } else if (element.type === "bar_right_repeat") {
                                    const endBlockSearch = staffBlocksMap[lineId].repeatArray;

                                    for (const repeatbar in endBlockSearch) {
                                        if (endBlockSearch[repeatbar].end === -1) {
                                            staffBlocksMap[lineId].repeatArray[repeatbar].end =
                                                staffBlocksMap[lineId].baseBlocks.length;
                                        }
                                    }
                                }
                            }
                        });

                        // Update the newnote connection with hidden
                        actionBlock[0][4][0] = blockId + 3;
                        actionBlock[actionBlock.length - 1][4][1] = null;

                        // Update the namedo block if not first
                        // nameddo block appear
                        if (staffBlocksMap[lineId].baseBlocks.length != 0) {
                            staffBlocksMap[lineId].baseBlocks[
                                staffBlocksMap[lineId].baseBlocks.length - 1
                            ][0][
                                staffBlocksMap[lineId].baseBlocks[
                                    staffBlocksMap[lineId].baseBlocks.length - 1
                                ][0].length - 4
                            ][4][1] = blockId;
                        }
                        // Add the nameddo action text and hidden
                        // block for each line
                        actionBlock.push(
                            [
                                blockId,
                                [
                                    "nameddo",
                                    {
                                        value: `V: ${parseInt(lineId) + 1} Line ${
                                            staffBlocksMap[lineId]?.baseBlocks?.length + 1
                                        }`
                                    }
                                ],
                                0,
                                0,
                                [
                                    staffBlocksMap[lineId].baseBlocks.length === 0
                                        ? null
                                        : staffBlocksMap[lineId].baseBlocks[
                                              staffBlocksMap[lineId].baseBlocks.length - 1
                                          ][0][
                                              staffBlocksMap[lineId].baseBlocks[
                                                  staffBlocksMap[lineId].baseBlocks.length - 1
                                              ][0].length - 4
                                          ][0],
                                    null
                                ]
                            ],
                            [
                                blockId + 1,
                                ["action", { collapsed: false }],
                                100,
                                100,
                                [null, blockId + 2, blockId + 3, null]
                            ],
                            [
                                blockId + 2,
                                [
                                    "text",
                                    {
                                        value: `V: ${parseInt(lineId) + 1} Line ${
                                            staffBlocksMap[lineId]?.baseBlocks?.length + 1
                                        }`
                                    }
                                ],
                                0,
                                0,
                                [blockId + 1]
                            ],
                            [blockId + 3, "hidden", 0, 0, [blockId + 1, actionBlock[0][0]]]
                        ); // blockid of topaction block

                        if (!staffBlocksMap[lineId].nameddoArray) {
                            staffBlocksMap[lineId].nameddoArray = {};
                        }

                        // Ensure the array at nameddoArray[lineId] is initialized if it doesn't exist
                        if (!staffBlocksMap[lineId].nameddoArray[lineId]) {
                            staffBlocksMap[lineId].nameddoArray[lineId] = [];
                        }

                        staffBlocksMap[lineId].nameddoArray[lineId].push(blockId);
                        blockId += 4;

                        musicBlocksJSON.push(actionBlock);
                        staffBlocksMap[lineId].baseBlocks.push([actionBlock]);
                    });
                });
            }

            const finalBlock = [];
            // Some Error are here need to be fixed
            for (const staffIndex in staffBlocksMap) {
                staffBlocksMap[staffIndex].startBlock[
                    staffBlocksMap[staffIndex].startBlock.length - 3
                ][4][2] =
                    staffBlocksMap[staffIndex].baseBlocks[0][0][
                        staffBlocksMap[staffIndex].baseBlocks[0][0].length - 4
                    ][0];
                // Update the first namedo block with settimbre
                staffBlocksMap[staffIndex].baseBlocks[0][0][
                    staffBlocksMap[staffIndex].baseBlocks[0][0].length - 4
                ][4][0] =
                    staffBlocksMap[staffIndex].startBlock[
                        staffBlocksMap[staffIndex].startBlock.length - 3
                    ][0];
                const repeatblockids = staffBlocksMap[staffIndex].repeatArray;
                for (const repeatId of repeatblockids) {
                    if (repeatId.start == 0) {
                        staffBlocksMap[staffIndex].repeatBlock.push([
                            blockId,
                            "repeat",
                            0,
                            0,
                            [
                                staffBlocksMap[staffIndex].startBlock[
                                    staffBlocksMap[staffIndex].startBlock.length - 3
                                ][0] /*setribmre*/,
                                blockId + 1,
                                staffBlocksMap[staffIndex].nameddoArray[staffIndex][0],
                                staffBlocksMap[staffIndex].nameddoArray[staffIndex][
                                    repeatId.end + 1
                                ] === null
                                    ? null
                                    : staffBlocksMap[staffIndex].nameddoArray[staffIndex][
                                          repeatId.end + 1
                                      ]
                            ]
                        ]);
                        staffBlocksMap[staffIndex].repeatBlock.push([
                            blockId + 1,
                            ["number", { value: 2 }],
                            100,
                            100,
                            [blockId]
                        ]);

                        // Update the settrimbre block
                        staffBlocksMap[staffIndex].startBlock[
                            staffBlocksMap[staffIndex].startBlock.length - 3
                        ][4][2] = blockId;
                        const firstnammedo = _searchIndexForMusicBlock(
                            staffBlocksMap[staffIndex].baseBlocks[0][0],
                            staffBlocksMap[staffIndex].nameddoArray[staffIndex][0]
                        );
                        const endnammedo = _searchIndexForMusicBlock(
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.end][0],
                            staffBlocksMap[staffIndex].nameddoArray[staffIndex][repeatId.end]
                        );
                        // Because its [0] is the first nammeddo block
                        // obviously. Check if
                        // staffBlocksMap[staffIndex].baseBlocks[repeatId.end+1
                        // exists and has a [0] element
                        if (
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.end + 1] &&
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.end + 1][0]
                        ) {
                            const secondnammedo = _searchIndexForMusicBlock(
                                staffBlocksMap[staffIndex].baseBlocks[repeatId.end + 1][0],
                                staffBlocksMap[staffIndex].nameddoArray[staffIndex][
                                    repeatId.end + 1
                                ]
                            );

                            if (secondnammedo != -1) {
                                staffBlocksMap[staffIndex].baseBlocks[repeatId.end + 1][0][
                                    secondnammedo
                                ][4][0] = blockId;
                            }
                        }
                        staffBlocksMap[staffIndex].baseBlocks[0][0][firstnammedo][4][0] = blockId;
                        staffBlocksMap[staffIndex].baseBlocks[repeatId.end][0][endnammedo][4][1] =
                            null;

                        blockId += 2;
                    } else {
                        const currentnammeddo = _searchIndexForMusicBlock(
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.start][0],
                            staffBlocksMap[staffIndex].nameddoArray[staffIndex][repeatId.start]
                        );
                        const prevnameddo = _searchIndexForMusicBlock(
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.start - 1][0],
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.start][0][
                                currentnammeddo
                            ][4][0]
                        );
                        const afternamedo = _searchIndexForMusicBlock(
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.end][0],
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.start][0][
                                currentnammeddo
                            ][4][1]
                        );
                        let prevrepeatnameddo = -1;
                        if (prevnameddo === -1) {
                            prevrepeatnameddo = _searchIndexForMusicBlock(
                                staffBlocksMap[staffIndex].repeatBlock,
                                staffBlocksMap[staffIndex].baseBlocks[repeatId.start][0][
                                    currentnammeddo
                                ][4][0]
                            );
                        }
                        const prevBlockId =
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.start][0][
                                currentnammeddo
                            ][4][0];
                        const currentBlockId =
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.start][0][
                                currentnammeddo
                            ][0];

                        // Needs null checking optmizie
                        const nextBlockId =
                            staffBlocksMap[staffIndex].nameddoArray[staffIndex][repeatId.end + 1];

                        staffBlocksMap[staffIndex].repeatBlock.push([
                            blockId,
                            "repeat",
                            0,
                            0,
                            [
                                staffBlocksMap[staffIndex].baseBlocks[repeatId.start][0][
                                    currentnammeddo
                                ][4][0],
                                blockId + 1,
                                currentBlockId,
                                nextBlockId === null ? null : nextBlockId
                            ]
                        ]);
                        staffBlocksMap[staffIndex].repeatBlock.push([
                            blockId + 1,
                            ["number", { value: 2 }],
                            100,
                            100,
                            [blockId]
                        ]);
                        if (prevnameddo != -1) {
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.start - 1][0][
                                prevnameddo
                            ][4][1] = blockId;
                        } else {
                            staffBlocksMap[staffIndex].repeatBlock[prevrepeatnameddo][4][3] =
                                blockId;
                        }
                        if (afternamedo !== -1) {
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.end][0][
                                afternamedo
                            ][4][1] = null;
                        }
                        staffBlocksMap[staffIndex].baseBlocks[repeatId.start][0][
                            currentnammeddo
                        ][4][0] = blockId;
                        if (nextBlockId !== null) {
                            const nextnameddo = _searchIndexForMusicBlock(
                                staffBlocksMap[staffIndex].baseBlocks[repeatId.end + 1][0],
                                nextBlockId
                            );
                            staffBlocksMap[staffIndex].baseBlocks[repeatId.end + 1][0][
                                nextnameddo
                            ][4][0] = blockId;
                        }
                        blockId += 2;
                    }
                }

                const lineBlock = staffBlocksMap[staffIndex].baseBlocks.reduce(
                    (acc, curr) => acc.concat(curr),
                    []
                );
                // Flatten the multidimensional array
                const flattenedLineBlock = lineBlock.flat();
                const combinedBlock = [
                    ...staffBlocksMap[staffIndex].startBlock,
                    ...flattenedLineBlock
                ];

                finalBlock.push(...staffBlocksMap[staffIndex].startBlock);
                finalBlock.push(...flattenedLineBlock);
                finalBlock.push(...staffBlocksMap[staffIndex].repeatBlock);
            }
            this.blocks.loadNewBlocks(finalBlock);
            return null;
        };

        /**
         * @param loadProject all params are from load project function
         */
        this.loadStartWrapper = async (func, arg1, arg2, arg3) => {
            await func(this, arg1, arg2, arg3);
            this.showContents();
        };

        /*
         * Hides the loading animation and unhides the background.
         * Shows contents of MB after loading screen.
         */
        this.showContents = () => {
            clearInterval(window.intervalId);
            document.getElementById("loadingText").textContent = _("Loading Complete!");

            setTimeout(() => {
                const loadingText = document.getElementById("loadingText");
                if (loadingText) loadingText.textContent = null;

                const loadingImageContainer = document.getElementById("loading-image-container");
                if (loadingImageContainer) loadingImageContainer.style.display = "none";

                // Try hiding load-container instead if it exists
                const loadContainer = document.getElementById("load-container");
                if (loadContainer) loadContainer.style.display = "none";

                const bottomRightLogo = document.getElementById("bottom-right-logo");
                if (bottomRightLogo) bottomRightLogo.style.display = "none";

                const palette = document.getElementById("palette");
                if (palette) palette.style.display = "block";

                // document.getElementById('canvas').style.display = 'none';

                const hideContents = document.getElementById("hideContents");
                if (hideContents) hideContents.style.display = "block";

                const btnBottom = document.getElementById("buttoncontainerBOTTOM");
                if (btnBottom) btnBottom.style.display = "block";

                const btnTop = document.getElementById("buttoncontainerTOP");
                if (btnTop) btnTop.style.display = "block";
            }, 500);
        };

        this.justLoadStart = () => {
            this.blocks.loadNewBlocks(DATAOBJS);
        };

        /*
         * Sets up a new "clean" MB i.e. new project instance
         */
        const _afterDelete = that => {
            if (that.turtles.running()) {
                that._doHardStopButton();
            }

            // Use the planet New Project mechanism if it is available,
            // but only if the current project has a name.
            if (
                that.planet !== undefined &&
                that.planet.getCurrentProjectName() !== _("My Project")
            ) {
                that.planet.saveLocally();
                that.planet.initialiseNewProject();
                loadStart(that);
                that.planet.saveLocally();
            } else {
                that.toolbar.closeAuxToolbar(showHideAuxMenu);

                setTimeout(() => {
                    // Don't create the new blocks in sendAllToTrash so as to
                    // avoid clearing the screen of any graphics. Do it here
                    // instead.
                    that.sendAllToTrash(false, false);
                    that.blocks.loadNewBlocks(DATAOBJS);
                }, 1000);
            }
        };

        /*
         * Hides all message containers
         */
        this.hideMsgs = () => {
            // The containers may not be ready yet, so check before accessing.
            if (
                this.errorMsgText === null ||
                this.msgText === null ||
                this.errorText === undefined ||
                this.printText === undefined
            ) {
                return;
            }
            this.errorMsgText.parent.visible = false;
            this.errorText.classList.remove("show");
            this._hideArrows();

            this.msgText.parent.visible = false;
            this.printText.classList.remove("show");
            for (const i in this.errorArtwork) {
                this.errorArtwork[i].visible = false;
            }

            this.refreshCanvas();
        };

        const hideArrows = () => {
            globalActivity._hideArrows();
        };

        this._hideArrows = () => {
            if (this.errorMsgArrow !== null) {
                this.errorMsgArrow.removeAllChildren();
                this.refreshCanvas();
            }
        };

        this.textMsg = (msg, duration = _MSGTIMEOUT_) => {
            if (this.msgTimeoutID !== null) {
                clearTimeout(this.msgTimeoutID);
                this.msgTimeoutID = null;
            }

            if (this.msgText === null) {
                // The container may not be ready yet, so do nothing.
                return;
            }

            this.printText.classList.add("show");
            this.printTextContent.innerHTML = msg;

            const that = this;
            this.msgTimeoutID = setTimeout(() => {
                that.printText.classList.remove("show");
                that.msgTimeoutID = null;
            }, duration);
        };

        this.errorMsg = (msg, blk, text, timeout) => {
            if (this.errorMsgTimeoutID !== null) {
                clearTimeout(this.errorMsgTimeoutID);
            }

            // The container may not be ready yet, so do nothing.
            if (this.errorMsgText === null) {
                return;
            }

            if (
                blk !== undefined &&
                blk !== null &&
                blk in this.blocks.blockList &&
                !this.blocks.blockList[blk].collapsed
            ) {
                const fromX = this.canvas.width / 2;
                const fromY = 128;
                const toX = this.blocks.blockList[blk].container.x + this.blocksContainer.x;
                const toY = this.blocks.blockList[blk].container.y + this.blocksContainer.y;

                if (this.errorMsgArrow === null) {
                    this.errorMsgArrow = new createjs.Container();
                    this.stage.addChild(this.errorMsgArrow);
                }

                const line = new createjs.Shape();
                this.errorMsgArrow.addChild(line);
                line.graphics
                    .setStrokeStyle(4)
                    .beginStroke("#ff0031")
                    .moveTo(fromX, fromY)
                    .lineTo(toX, toY);
                this.stage.setChildIndex(this.errorMsgArrow, this.stage.children.length - 1);

                const angle = (Math.atan2(toX - fromX, fromY - toY) / Math.PI) * 180;
                const head = new createjs.Shape();
                this.errorMsgArrow.addChild(head);
                head.graphics
                    .setStrokeStyle(4)
                    .beginStroke("#ff0031")
                    .moveTo(-10, 18)
                    .lineTo(0, 0)
                    .lineTo(10, 18);
                head.x = toX;
                head.y = toY;
                head.rotation = angle;
            }

            switch (msg) {
                case NOMICERRORMSG:
                    this.errorArtwork["nomicrophone"].visible = true;
                    this.stage.setChildIndex(
                        this.errorArtwork["nomicrophone"],
                        this.stage.children.length - 1
                    );
                    break;
                case NOSTRINGERRORMSG:
                    this.errorArtwork["notastring"].visible = true;
                    this.stage.setChildIndex(
                        this.errorArtwork["notastring"],
                        this.stage.children.length - 1
                    );
                    break;
                case EMPTYHEAPERRORMSG:
                    this.errorArtwork["emptyheap"].visible = true;
                    this.stage.setChildIndex(
                        this.errorArtwork["emptyheap"],
                        this.stage.children.length - 1
                    );
                    break;
                case NOSQRTERRORMSG:
                    this.errorArtwork["negroot"].visible = true;
                    this.stage.setChildIndex(
                        this.errorArtwork["negroot"],
                        this.stage.children.length - 1
                    );
                    break;
                case NOACTIONERRORMSG:
                    if (text === null) {
                        text = "foo";
                    }

                    this.errorArtwork["nostack"].children[1].text = text;
                    this.errorArtwork["nostack"].visible = true;
                    this.errorArtwork["nostack"].updateCache();
                    this.stage.setChildIndex(
                        this.errorArtwork["nostack"],
                        this.stage.children.length - 1
                    );
                    break;
                case NOBOXERRORMSG:
                    if (text === null) {
                        text = "foo";
                    }

                    this.errorArtwork["emptybox"].children[1].text = text;
                    this.errorArtwork["emptybox"].visible = true;
                    this.errorArtwork["emptybox"].updateCache();
                    this.stage.setChildIndex(
                        this.errorArtwork["emptybox"],
                        this.stage.children.length - 1
                    );
                    break;
                case ZERODIVIDEERRORMSG:
                    this.errorArtwork["zerodivide"].visible = true;
                    this.stage.setChildIndex(
                        this.errorArtwork["zerodivide"],
                        this.stage.children.length - 1
                    );
                    break;
                case NANERRORMSG:
                    this.errorArtwork["notanumber"].visible = true;
                    this.stage.setChildIndex(
                        this.errorArtwork["notanumber"],
                        this.stage.children.length - 1
                    );
                    break;
                case NOINPUTERRORMSG:
                    this.errorArtwork["noinput"].visible = true;
                    this.stage.setChildIndex(
                        this.errorArtwork["noinput"],
                        this.stage.children.length - 1
                    );
                    break;
                default:
                    // Show and populate errorText div
                    this.errorText.classList.add("show");
                    this.errorTextContent.innerHTML = msg;
                    break;
            }

            let myTimeout = _ERRORMSGTIMEOUT_;
            if (timeout !== undefined) {
                myTimeout = timeout;
            }

            if (myTimeout > 0) {
                const that = this;
                this.errorMsgTimeoutID = setTimeout(() => {
                    that.hideMsgs();
                }, myTimeout);
            }

            this.refreshCanvas();
        };

        /*
         * Hides Error Text
         */
        this.hideErrorText = () => {
            if (this.errorText) {
                this.errorText.style.display = "none";
            }
        };
        /*
         * Hides Print Text
         */
        this.hidePrintText = () => {
            if (this.printText) {
                this.printText.classList.remove("show");
            }
        };

        /*
         * Hides cartesian grid
         */
        this._hideCartesian = () => {
            this.cartesianBitmap.visible = false;
            this.cartesianBitmap.uncache();
            this.update = true;
        };

        /*
         * Shows cartesian grid
         */
        this._showCartesian = () => {
            this.cartesianBitmap.visible = true;
            this.cartesianBitmap.cache(0, 0, 1200, 900);
            this.cartesianBitmap.updateCache();
            this.update = true;
        };

        /*
         * Hides polar grid
         */
        this._hidePolar = () => {
            this.polarBitmap.visible = false;
            this.polarBitmap.uncache();
            this.update = true;
        };

        /*
         * Shows polar grid
         */
        this._showPolar = () => {
            this.polarBitmap.visible = true;
            this.polarBitmap.cache(0, 0, 1200, 900);
            this.polarBitmap.updateCache();
            this.update = true;
        };

        /*
         * Hides accidentals
         */
        this._hideAccidentals = () => {
            const newX = this.canvas.width / (2 * this.turtleBlocksScale) - 600;
            for (let i = 0; i < 7; i++) {
                this.grandSharpBitmap[i].visible = false;
                this.grandSharpBitmap[i].x = newX;
                this.grandFlatBitmap[i].visible = false;
                this.grandFlatBitmap[i].x = newX;

                this.trebleSharpBitmap[i].visible = false;
                this.trebleSharpBitmap[i].x = newX;
                this.trebleFlatBitmap[i].visible = false;
                this.trebleFlatBitmap[i].x = newX;

                this.sopranoSharpBitmap[i].visible = false;
                this.sopranoSharpBitmap[i].x = newX;
                this.sopranoFlatBitmap[i].visible = false;
                this.sopranoFlatBitmap[i].x = newX;

                this.altoSharpBitmap[i].visible = false;
                this.altoSharpBitmap[i].x = newX;
                this.altoFlatBitmap[i].visible = false;
                this.altoFlatBitmap[i].x = newX;

                this.tenorSharpBitmap[i].visible = false;
                this.tenorSharpBitmap[i].x = newX;
                this.tenorFlatBitmap[i].visible = false;
                this.tenorFlatBitmap[i].x = newX;

                this.bassSharpBitmap[i].visible = false;
                this.bassSharpBitmap[i].x = newX;
                this.bassFlatBitmap[i].visible = false;
                this.bassFlatBitmap[i].x = newX;
            }
            this.update = true;
        };

        /*
         * Hides musical treble staff
         */
        this._hideTreble = () => {
            this.trebleBitmap.visible = false;
            this.trebleBitmap.uncache();
            this._hideAccidentals();
            this.update = true;
        };

        /*
         * Shows musical treble staff
         */
        this._showTreble = () => {
            this.trebleBitmap.visible = true;
            this.trebleBitmap.cache(0, 0, 1200, 900);
            this.trebleBitmap.updateCache();
            this._hideAccidentals();
            // eslint-disable-next-line no-console
            console.log(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1]);
            const scale = buildScale(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1])[0];
            // eslint-disable-next-line no-console
            console.log(scale);
            const _sharps = [
                "F" + SHARP,
                "C" + SHARP,
                "G" + SHARP,
                "D" + SHARP,
                "A" + SHARP,
                "E" + SHARP,
                "B" + SHARP
            ];
            const _flats = [
                "B" + FLAT,
                "E" + FLAT,
                "A" + FLAT,
                "D" + FLAT,
                "G" + FLAT,
                "C" + FLAT,
                "F" + FLAT
            ];
            let dx = 0;
            for (let i = 0; i < 7; i++) {
                if (scale.includes(_sharps[i])) {
                    this.trebleSharpBitmap[i].x += dx;
                    this.trebleSharpBitmap[i].visible = true;
                    dx += 15;
                }
                if (scale.includes(_flats[i])) {
                    this.trebleFlatBitmap[i].x += dx;
                    this.trebleFlatBitmap[i].visible = true;
                    dx += 15;
                }
            }

            this.update = true;
        };

        /*
         * Hides musical grand staff
         */
        this._hideGrand = () => {
            this.grandBitmap.visible = false;
            this.grandBitmap.uncache();
            this._hideAccidentals();
            this.update = true;
        };

        /*
         * Shows musical grand staff
         */
        this._showGrand = () => {
            this.grandBitmap.visible = true;
            this.grandBitmap.cache(0, 0, 1200, 900);
            this.grandBitmap.updateCache();
            this._hideAccidentals();
            // eslint-disable-next-line no-console
            console.log(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1]);
            const scale = buildScale(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1])[0];
            // eslint-disable-next-line no-console
            console.log(scale);
            const _sharps = [
                "F" + SHARP,
                "C" + SHARP,
                "G" + SHARP,
                "D" + SHARP,
                "A" + SHARP,
                "E" + SHARP,
                "B" + SHARP
            ];
            const _flats = [
                "B" + FLAT,
                "E" + FLAT,
                "A" + FLAT,
                "D" + FLAT,
                "G" + FLAT,
                "C" + FLAT,
                "F" + FLAT
            ];
            let dx = 0;
            for (let i = 0; i < 7; i++) {
                if (scale.includes(_sharps[i])) {
                    this.grandSharpBitmap[i].x += dx;
                    this.grandSharpBitmap[i].visible = true;
                    dx += 15;
                }
                if (scale.includes(_flats[i])) {
                    this.grandFlatBitmap[i].x += dx;
                    this.grandFlatBitmap[i].visible = true;
                    dx += 15;
                }
            }
            this.update = true;
        };

        /*
         * Hides musical soprano staff
         */
        this._hideSoprano = () => {
            this.sopranoBitmap.visible = false;
            this.sopranoBitmap.uncache();
            this.update = true;
        };

        /*
         * Shows musical soprano staff
         */
        this._showSoprano = () => {
            this.sopranoBitmap.visible = true;
            this.sopranoBitmap.cache(0, 0, 1200, 900);
            this.sopranoBitmap.updateCache();
            this._hideAccidentals();
            // eslint-disable-next-line no-console
            console.log(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1]);
            const scale = buildScale(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1])[0];
            // eslint-disable-next-line no-console
            console.log(scale);
            const _sharps = [
                "F" + SHARP,
                "C" + SHARP,
                "G" + SHARP,
                "D" + SHARP,
                "A" + SHARP,
                "E" + SHARP,
                "B" + SHARP
            ];
            const _flats = [
                "B" + FLAT,
                "E" + FLAT,
                "A" + FLAT,
                "D" + FLAT,
                "G" + FLAT,
                "C" + FLAT,
                "F" + FLAT
            ];
            let dx = 0;
            for (let i = 0; i < 7; i++) {
                if (scale.includes(_sharps[i])) {
                    this.sopranoSharpBitmap[i].x += dx;
                    this.sopranoSharpBitmap[i].visible = true;
                    dx += 15;
                }
                if (scale.includes(_flats[i])) {
                    this.sopranoFlatBitmap[i].x += dx;
                    this.sopranoFlatBitmap[i].visible = true;
                    dx += 15;
                }
            }

            this.update = true;
        };

        /*
         * Hides musical alto staff
         */
        this._hideAlto = () => {
            this.altoBitmap.visible = false;
            this.altoBitmap.uncache();
            this._hideAccidentals();
            this.update = true;
        };

        this.__showAltoAccidentals = () => {
            // No-op for Alto clef
        };

        /*
         * Shows musical alto staff
         */
        this._showAlto = () => {
            this.altoBitmap.visible = true;
            this.altoBitmap.cache(0, 0, 1200, 900);
            this.altoBitmap.updateCache();
            this._hideAccidentals();
            // eslint-disable-next-line no-console
            console.log(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1]);
            const scale = buildScale(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1])[0];
            // eslint-disable-next-line no-console
            console.log(scale);
            const _sharps = [
                "F" + SHARP,
                "C" + SHARP,
                "G" + SHARP,
                "D" + SHARP,
                "A" + SHARP,
                "E" + SHARP,
                "B" + SHARP
            ];
            const _flats = [
                "B" + FLAT,
                "E" + FLAT,
                "A" + FLAT,
                "D" + FLAT,
                "G" + FLAT,
                "C" + FLAT,
                "F" + FLAT
            ];
            let dx = 0;
            for (let i = 0; i < 7; i++) {
                if (scale.includes(_sharps[i])) {
                    this.altoSharpBitmap[i].x += dx;
                    this.altoSharpBitmap[i].visible = true;
                    dx += 15;
                }
                if (scale.includes(_flats[i])) {
                    this.altoFlatBitmap[i].x += dx;
                    this.altoFlatBitmap[i].visible = true;
                    dx += 15;
                }
            }

            this.update = true;
        };

        /*
         * Hides musical tenor staff
         */
        this._hideTenor = () => {
            this.tenorBitmap.visible = false;
            this.tenorBitmap.uncache();
            this.update = true;
        };

        /*
         * Shows musical tenor staff
         */
        this._showTenor = () => {
            this.tenorBitmap.visible = true;
            this.tenorBitmap.cache(0, 0, 1200, 900);
            this.tenorBitmap.updateCache();
            this._hideAccidentals();
            // eslint-disable-next-line no-console
            console.log(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1]);
            const scale = buildScale(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1])[0];
            // eslint-disable-next-line no-console
            console.log(scale);
            const _sharps = [
                "F" + SHARP,
                "C" + SHARP,
                "G" + SHARP,
                "D" + SHARP,
                "A" + SHARP,
                "E" + SHARP,
                "B" + SHARP
            ];
            const _flats = [
                "B" + FLAT,
                "E" + FLAT,
                "A" + FLAT,
                "D" + FLAT,
                "G" + FLAT,
                "C" + FLAT,
                "F" + FLAT
            ];
            let dx = 0;
            for (let i = 0; i < 7; i++) {
                if (scale.includes(_sharps[i])) {
                    this.tenorSharpBitmap[i].x += dx;
                    this.tenorSharpBitmap[i].visible = true;
                    dx += 15;
                }
                if (scale.includes(_flats[i])) {
                    this.tenorFlatBitmap[i].x += dx;
                    this.tenorFlatBitmap[i].visible = true;
                    dx += 15;
                }
            }

            this.update = true;
        };

        /*
         * Hides musical bass staff
         */
        this._hideBass = () => {
            this.bassBitmap.visible = false;
            this.bassBitmap.uncache();
            this._hideAccidentals();
            this.update = true;
        };

        /*
         * Shows musical bass staff
         */
        this._showBass = () => {
            this.bassBitmap.visible = true;
            this.bassBitmap.cache(0, 0, 1200, 900);
            this.bassBitmap.updateCache();
            this._hideAccidentals();
            // eslint-disable-next-line no-console
            console.log(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1]);
            const scale = buildScale(this.KeySignatureEnv[0] + " " + this.KeySignatureEnv[1])[0];
            // eslint-disable-next-line no-console
            console.log(scale);
            const _sharps = [
                "F" + SHARP,
                "C" + SHARP,
                "G" + SHARP,
                "D" + SHARP,
                "A" + SHARP,
                "E" + SHARP,
                "B" + SHARP
            ];
            const _flats = [
                "B" + FLAT,
                "E" + FLAT,
                "A" + FLAT,
                "D" + FLAT,
                "G" + FLAT,
                "C" + FLAT,
                "F" + FLAT
            ];
            let dx = 0;
            for (let i = 0; i < 7; i++) {
                if (scale.includes(_sharps[i])) {
                    this.bassSharpBitmap[i].x += dx;
                    this.bassSharpBitmap[i].visible = true;
                    dx += 15;
                }
                if (scale.includes(_flats[i])) {
                    this.bassFlatBitmap[i].x += dx;
                    this.bassFlatBitmap[i].visible = true;
                    dx += 15;
                }
            }

            this.update = true;
        };

        /*
         * We don't save blocks in the trash, so we need to
         * consolidate the block list and remap the connections.
         */
        this.prepareExport = () => {
            const blockMap = [];
            this.hasMatrixDataBlock = false;
            for (let blk = 0; blk < this.blocks.blockList.length; blk++) {
                const myBlock = this.blocks.blockList[blk];
                if (myBlock.trash) {
                    // Don't save blocks in the trash.
                    continue;
                }

                blockMap.push(blk);
            }

            const data = [];
            for (let blk = 0; blk < this.blocks.blockList.length; blk++) {
                const myBlock = this.blocks.blockList[blk];
                let args = null;

                if (myBlock.trash) {
                    // Don't save blocks in the trash.
                    continue;
                }

                if (
                    myBlock.isValueBlock() ||
                    myBlock.name === "loadFile" ||
                    myBlock.name === "boolean"
                ) {
                    // FIX ME: scale image if it exceeds a maximum size.
                    switch (myBlock.name) {
                        case "namedbox":
                        case "namedarg":
                            args = {
                                value: myBlock.privateData
                            };
                            break;
                        default:
                            args = {
                                value: myBlock.value
                            };
                    }
                } else {
                    switch (myBlock.name) {
                        case "start":
                        case "drum":
                            // Find the turtle associated with this block.
                            // eslint-disable-next-line no-case-declarations
                            const turtle = this.turtles.getTurtle(myBlock.value);
                            if (turtle === null || turtle === undefined) {
                                args = {
                                    id: this.turtles.getTurtleCount(),
                                    collapsed: false,
                                    xcor: 0,
                                    ycor: 0,
                                    heading: 0,
                                    color: 0,
                                    shade: 50,
                                    pensize: 5,
                                    grey: 100
                                };
                            } else {
                                args = {
                                    id: turtle.id,
                                    collapsed: myBlock.collapsed,
                                    xcor: turtle.x,
                                    ycor: turtle.y,
                                    heading: turtle.orientation,
                                    color: turtle.painter.color,
                                    shade: turtle.painter.value,
                                    pensize: turtle.painter.stroke,
                                    grey: turtle.painter.chroma
                                    // 'name': turtle.name
                                };
                            }
                            break;
                        case "temperament1":
                            if (this.blocks.customTemperamentDefined) {
                                // If a define temperament block is
                                // present, find the value of the arg
                                // block to get the name of the custom
                                // temperament.
                                let customName = "custom";
                                if (myBlock.connections[1] !== null) {
                                    // eslint-disable-next-line max-len
                                    customName =
                                        this.blocks.blockList[myBlock.connections[1]].value;
                                }
                                // eslint-disable-next-line no-console
                                console.log(customName);
                                args = {
                                    customName: customName,
                                    customTemperamentNotes: getTemperament(customName),
                                    startingPitch: this.logo.synth.startingPitch,
                                    octaveSpace: getOctaveRatio()
                                };
                            }
                            break;
                        case "interval":
                        case "newnote":
                        case "action":
                        case "matrix":
                        case "pitchdrummatrix":
                        case "rhythmruler":
                        case "timbre":
                        case "pitchstaircase":
                        case "tempo":
                        case "pitchslider":
                        case "musickeyboard":
                        case "modewidget":
                        case "meterwidget":
                        case "status":
                            args = {
                                collapsed: myBlock.collapsed
                            };
                            break;
                        case "storein2":
                        case "nameddo":
                        case "nameddoArg":
                        case "namedcalc":
                        case "namedcalcArg":
                        case "outputtools":
                            args = {
                                value: myBlock.privateData
                            };
                            break;
                        case "nopValueBlock":
                        case "nopZeroArgBlock":
                        case "nopOneArgBlock":
                        case "nopTwoArgBlock":
                        case "nopThreeArgBlock":
                            // restore original block name
                            myBlock.name = myBlock.privateData;
                            break;
                        case "matrixData":
                            // deprecated
                            args = {
                                notes: window.savedMatricesNotes,
                                count: window.savedMatricesCount
                            };
                            this.hasMatrixDataBlock = true;
                            break;
                        case "wrapmode":
                            args = {
                                value: myBlock.value
                            };
                            break;
                        default:
                            break;
                    }
                }

                const connections = [];
                for (let c = 0; c < myBlock.connections.length; c++) {
                    const mapConnection = blockMap.indexOf(myBlock.connections[c]);
                    if (myBlock.connections[c] === null || mapConnection === -1) {
                        connections.push(null);
                    } else {
                        connections.push(mapConnection);
                    }
                }

                if (args === null) {
                    data.push([
                        blockMap.indexOf(blk),
                        myBlock.name,
                        myBlock.container.x,
                        myBlock.container.y,
                        connections
                    ]);
                } else {
                    data.push([
                        blockMap.indexOf(blk),
                        [myBlock.name, args],
                        myBlock.container.x,
                        myBlock.container.y,
                        connections
                    ]);
                }
            }

            return JSON.stringify(data);
        };

        /*
         * Opens plugin by clicking on the plugin open chooser in the DOM (.json).
         */
        const doOpenPlugin = activity => {
            activity._doOpenPlugin();
        };

        this._doOpenPlugin = () => {
            this.toolbar.closeAuxToolbar(showHideAuxMenu);
            this.pluginChooser.focus();
            this.pluginChooser.click();
        };

        /*
         * Specifies that loading an MB project should merge it
         * within the existing project
         */
        const _doMergeLoad = that => {
            doLoad(that, true);
        };

        /*
         * Sets up palette buttons and functions
         * e.g. Home, Collapse, Expand
         * These menu items are on the canvas, not the toolbar.
         */
        this._setupPaletteMenu = () => {
            const btnSize = this.cellSize;
            const createButton = (icon, label, action) => {
                const button = this._makeButton(icon, label, x, y, btnSize, 0);
                this._loadButtonDragHandler(button, action, this);
                x += btnSize;
                return button;
            };

            let x = window.innerWidth - 4 * btnSize - 27.5;
            const y = window.innerHeight - 57.5;

            const removeButtonContainer = document.getElementById("buttoncontainerBOTTOM");
            if (removeButtonContainer) {
                removeButtonContainer.parentNode.removeChild(removeButtonContainer);
            }

            const ButtonHolder = document.createElement("div");
            ButtonHolder.setAttribute("id", "buttoncontainerBOTTOM");
            ButtonHolder.style.display = "block";
            document.body.appendChild(ButtonHolder);

            this.homeButtonContainer = createButton(
                GOHOMEFADEDBUTTON,
                _("Home") + " [" + _("Home").toUpperCase() + "]",
                findBlocks
            );
            this.boundary.hide();

            if (!this.helpfulWheelItems.find(ele => ele.label === "Home [HOME]"))
                this.helpfulWheelItems.push({
                    label: "Home [HOME]",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(GOHOMEFADEDBUTTON)),
                    display: true,
                    fn: findBlocks
                });

            this.hideBlocksContainer = createButton(
                SHOWBLOCKSBUTTON,
                _("Show/hide blocks"),
                changeBlockVisibility
            );

            if (!this.helpfulWheelItems.find(ele => ele.label === "Show/hide blocks"))
                this.helpfulWheelItems.push({
                    label: "Show/hide blocks",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(SHOWBLOCKSBUTTON)),
                    display: true,
                    fn: changeBlockVisibility
                });

            this.collapseBlocksContainer = createButton(
                COLLAPSEBLOCKSBUTTON,
                _("Expand/collapse blocks"),
                toggleCollapsibleStacks
            );

            if (!this.helpfulWheelItems.find(ele => ele.label === "Expand/collapse blocks"))
                this.helpfulWheelItems.push({
                    label: "Expand/collapse blocks",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(COLLAPSEBLOCKSBUTTON)),
                    display: true,
                    fn: toggleCollapsibleStacks
                });

            this.smallerContainer = createButton(
                SMALLERBUTTON,
                _("Decrease block size"),
                doSmallerBlocks
            );

            if (!this.helpfulWheelItems.find(ele => ele.label === "Decrease block size"))
                this.helpfulWheelItems.push({
                    label: "Decrease block size",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(SMALLERBUTTON)),
                    display: true,
                    fn: doSmallerBlocks
                });

            this.largerContainer = createButton(
                BIGGERBUTTON,
                _("Increase block size"),
                doLargerBlocks
            );

            if (!this.helpfulWheelItems.find(ele => ele.label === "Increase block size"))
                this.helpfulWheelItems.push({
                    label: "Increase block size",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(BIGGERBUTTON)),
                    display: true,
                    fn: doLargerBlocks
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Restore"))
                this.helpfulWheelItems.push({
                    label: "Restore",
                    icon: "imgsrc:header-icons/restore-from-trash.svg",
                    display: true,
                    fn: restoreTrashPop
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Turtle Wrap Off"))
                this.helpfulWheelItems.push({
                    label: "Turtle Wrap Off",
                    icon: "imgsrc:header-icons/wrap-text.svg",
                    display: true,
                    fn: this.toolbar.changeWrap
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Turtle Wrap On"))
                this.helpfulWheelItems.push({
                    label: "Turtle Wrap On",
                    icon: "imgsrc:header-icons/wrap-text.svg",
                    display: false,
                    fn: this.toolbar.changeWrap
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Enable horizontal scrolling"))
                this.helpfulWheelItems.push({
                    label: "Enable horizontal scrolling",
                    icon: "imgsrc:header-icons/compare-arrows.svg",
                    display: this.beginnerMode ? false : true,
                    fn: setScroller
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Disable horizontal scrolling"))
                this.helpfulWheelItems.push({
                    label: "Disable horizontal scrolling",
                    icon: "imgsrc:header-icons/lock.svg",
                    display: false,
                    fn: setScroller
                });

            if (
                _THIS_IS_MUSIC_BLOCKS_ &&
                !this.helpfulWheelItems.find(ele => ele.label === "Set Pitch Preview")
            )
                this.helpfulWheelItems.push({
                    label: "Set Pitch Preview",
                    icon: "imgsrc:header-icons/music-note.svg",
                    display: true,
                    fn: chooseKeyMenu
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Grid"))
                this.helpfulWheelItems.push({
                    label: "Grid",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(CARTESIANBUTTON)),
                    display: true,
                    fn: piemenuGrid
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Select"))
                this.helpfulWheelItems.push({
                    label: "Select",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(SELECTBUTTON)),
                    display: true,
                    fn: this.selectMode
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Clear"))
                this.helpfulWheelItems.push({
                    label: "Clear",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(CLEARBUTTON)),
                    display: true,
                    fn: () => this._allClear(false)
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Collapse"))
                this.helpfulWheelItems.push({
                    label: "Collapse",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(COLLAPSEBUTTON)),
                    display: true,
                    fn: this.turtles.collapse
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Expand"))
                this.helpfulWheelItems.push({
                    label: "Expand",
                    icon:
                        "imgsrc:data:image/svg+xml;base64," +
                        window.btoa(base64Encode(EXPANDBUTTON)),
                    display: false,
                    fn: this.turtles.expand
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Search for Blocks"))
                this.helpfulWheelItems.push({
                    label: "Search for Blocks",
                    icon: "imgsrc:header-icons/search-button.svg",
                    display: true,
                    fn: this._displayHelpfulSearchDiv
                });

            if (!this.helpfulWheelItems.find(ele => ele.label === "Paste previous stack"))
                this.helpfulWheelItems.push({
                    label: "Paste previous stack",
                    icon: "imgsrc:header-icons/copy-button.svg",
                    display: false,
                    fn: this.turtles.expand
                });
            if (!this.helpfulWheelItems.find(ele => ele.label === "Close"))
                this.helpfulWheelItems.push({
                    label: "Close",
                    icon: "imgsrc:header-icons/cancel-button.svg",
                    display: true,
                    fn: this._hideHelpfulSearchWidget
                });
        };

        /*
         * Shows search widget on helpfulSearchDiv
         */
        this.showHelpfulSearchWidget = () => {
            // Bring widget to top.
            const $j = window.jQuery;
            if ($j("#helpfulSearch")) {
                try {
                    $j("#helpfulSearch").autocomplete("destroy");
                } catch {
                    //
                }
            }
            this.helpfulSearchWidget.style.zIndex = 1001;
            this.helpfulSearchWidget.idInput_custom = "";
            if (this.helpfulSearchDiv.style.display === "block") {
                this.helpfulSearchWidget.value = null;
                this.helpfulSearchWidget.style.visibility = "visible";

                this.searchBlockPosition = [100, 100];
                this.prepSearchWidget();

                const that = this;
                setTimeout(() => {
                    that.helpfulSearchWidget.focus();
                    that.doHelpfulSearch();
                }, 500);

                document.getElementById("helpfulWheelDiv").style.display = "none";
            }
        };

        /*
         * Uses JQuery to add autocompleted search suggestions
         */
        this.doHelpfulSearch = () => {
            const $j = window.jQuery;
            if (this.searchSuggestions.length === 0) {
                this.prepSearchWidget();
            }

            const that = this;
            const $helpfulSearch = $j("#helpfulSearch");

            if (!$helpfulSearch.data("autocomplete-init")) {
                $helpfulSearch.autocomplete({
                    source: that.searchSuggestions,
                    appendTo: "body",
                    select: (event, ui) => {
                        event.preventDefault();
                        that.helpfulSearchWidget.value = ui.item.label;
                        that.helpfulSearchWidget.idInput_custom = ui.item.value;
                        that.helpfulSearchWidget.protoblk = ui.item.specialDict;
                        that.doHelpfulSearch();
                    },
                    focus: event => {
                        event.preventDefault();
                    }
                });

                const instance = $helpfulSearch.autocomplete("instance");
                if (instance) {
                    instance._renderItem = (ul, item) => {
                        return $j("<li></li>")
                            .append(
                                '<img src="' +
                                    (item.artwork || "") +
                                    '" height = "20px">' +
                                    "<a>" +
                                    " " +
                                    item.label +
                                    "</a>"
                            )
                            .appendTo(ul.css("z-index", 35000));
                    };
                }
                $helpfulSearch.data("autocomplete-init", true);
            }

            const searchInput = this.helpfulSearchWidget.idInput_custom;
            if (!searchInput || searchInput.length <= 0) {
                if (this.helpfulSearchWidget.value && this.helpfulSearchWidget.value.length > 0) {
                    $helpfulSearch.autocomplete("search", this.helpfulSearchWidget.value);
                }
                return;
            }

            const protoblk = this.helpfulSearchWidget.protoblk;
            const paletteName = protoblk.palette.name;
            const protoName = protoblk.name;

            // eslint-disable-next-line no-prototype-builtins
            if (this.blocks.protoBlockDict.hasOwnProperty(protoName)) {
                this.palettes.dict[paletteName].makeBlockFromSearch(
                    protoblk,
                    protoName,
                    newBlock => {
                        that.blocks.moveBlock(
                            newBlock,
                            100 + that.searchBlockPosition[0] - that.blocksContainer.x,
                            that.searchBlockPosition[1] - that.blocksContainer.y
                        );
                    }
                );

                // Move the position of the next newly created block.
                this.searchBlockPosition[0] += STANDARDBLOCKHEIGHT;
                this.searchBlockPosition[1] += STANDARDBLOCKHEIGHT;
            } else if (this.deprecatedBlockNames.indexOf(searchInput) > -1) {
                this.errorMsg(_("This block is deprecated."));
            } else {
                this.errorMsg(_("Block cannot be found."));
            }

            this.helpfulSearchWidget.value = "";
            // Hide search div after search is complete.
            document.getElementById("helpfulSearchDiv").style.display = "none";
            this.update = true;
        };

        /**
         * Toggles display of javaScript editor widget.
         */
        const toggleJSWindow = activity => {
            new JSEditor(activity);
        };

        const doAnalytics = activity => {
            if (!activity.statsWindow || !activity.statsWindow.isOpen) {
                activity.statsWindow = new StatsWindow(activity);
            }
        };

        /*
         * Shows help page
         */
        const showHelp = activity => {
            activity._showHelp();
        };

        this._showHelp = () => {
            // Will show welcome page by default.
            new HelpWidget(this, false);
        };

        /*
         * Shows about page
         */
        const showAboutPage = activity => {
            activity._showAboutPage();
        };

        this._showAboutPage = () => {
            // Will show welcome page by default.
            new HelpWidget(this, false);
        };

        /*
         * Makes non-toolbar buttons, e.g., the palette menu buttons
         */
        this._makeButton = (name, label, x, y) => {
            const container = document.createElement("div");
            container.setAttribute("id", "" + label);
            container.setAttribute("class", "tooltipped");
            container.setAttribute("data-tooltip", label);
            container.setAttribute("data-position", "top");
            window.jQuery(".tooltipped").tooltip({
                html: true,
                delay: 100
            });

            const that = this;
            container.onmouseover = () => {
                if (!that.loading) {
                    document.body.style.cursor = "pointer";
                    container.style.transition = "0.12s ease-out";
                    container.style.transform = "scale(1.15)";
                }
            };

            container.onmouseout = () => {
                if (!that.loading) {
                    document.body.style.cursor = "default";
                    container.style.transition = "0.15s ease-out";
                    container.style.transform = "scale(1)";
                }
            };

            const img = new Image();
            img.src = "data:image/svg+xml;base64," + window.btoa(base64Encode(name));

            container.appendChild(img);
            container.setAttribute(
                "style",
                "position: absolute; right:" +
                    (document.body.clientWidth - x) +
                    "px;  top: " +
                    y +
                    "px;"
            );
            document.getElementById("buttoncontainerBOTTOM").appendChild(container);
            return container;
        };

        /**
         * Handles button dragging, long hovering and prevents multiple button presses.
         * @param container longAction
         * @param hoverAction extraLongImg
         */
        this._loadButtonDragHandler = (container, actionClick, arg) => {
            const that = this;
            container.onmousedown = () => {
                if (!that.loading) {
                    document.body.style.cursor = "default";
                }
                actionClick(arg);
            };
        };

        /*
         * Handles pasted strings into input fields
         */
        this.pasted = () => {
            const rawData = document.getElementById("paste").value;
            let obj = "";
            if (rawData === null || rawData === "") {
                return;
            }

            const cleanData = rawData.replace("\n", " ");
            try {
                obj = JSON.parse(cleanData);
            } catch (e) {
                this.errorMsg(_("Could not parse JSON input."));
                return;
            }

            for (const name in this.palettes.dict) {
                this.palettes.dict[name].hideMenu(true);
            }

            this.refreshCanvas();

            this.blocks.loadNewBlocks(obj);
            this.pasteBox.hide();
        };

        /**
         * Handles changes in y coordinates of elements when aux toolbar is opened.
         * Repositions elements on screen by a certain amount (dy).
         * @param dy how much of a change in y
         */
        this.deltaY = dy => {
            this.toolbarHeight += dy;
            for (let i = 0; i < this.onscreenButtons.length; i++) {
                this.onscreenButtons[i].y += dy;
            }

            for (let i = 0; i < this.onscreenMenu.length; i++) {
                this.onscreenMenu[i].y += dy;
            }

            this.palettes.deltaY(dy);
            this.turtles.deltaY(dy);

            // this.menuContainer.y += dy;
            this.blocksContainer.y += dy;
            this.refreshCanvas();
        };

        /*
         * Ran once dom is ready and editable
         * Sets up dependencies and vars
         */
        this.domReady = async () => {
            this.saveLocally = undefined;

            // Do we need to update the stage?
            this.update = true;

            // Get things started
            await this.init();
        };

        this.__saveLocally = () => {
            const data = this.prepareExport();

            if (this.storage.currentProject === undefined) {
                try {
                    this.storage.currentProject = "My Project";
                    this.storage.allProjects = JSON.stringify(["My Project"]);
                } catch (e) {
                    // Edge case, eg. Firefox localSorage DB corrupted
                    // eslint-disable-next-line no-console
                    console.error(e);
                }
            }

            let p = "";
            try {
                p = this.storage.currentProject;
                this.storage["SESSION" + p] = data;
            } catch (e) {
                // eslint-disable-next-line no-console
                console.error(e);
            }

            const img = new Image();
            const svgData = doSVG(
                this.canvas,
                this.logo,
                this.turtles,
                320,
                240,
                320 / this.canvas.width
            );

            img.onload = () => {
                const bitmap = new createjs.Bitmap(img);
                const bounds = bitmap.getBounds();
                bitmap.cache(bounds.x, bounds.y, bounds.width, bounds.height);
                try {
                    that.storage["SESSIONIMAGE" + p] = bitmap.bitmapCache.getCacheDataURL();
                } catch (e) {
                    // eslint-disable-next-line no-console
                    console.error(e);
                }
            };

            img.src = "data:image/svg+xml;base64," + window.btoa(base64Encode(svgData));
        };

        // Setup mouse events to start the drag

        this.setupMouseEvents = () => {
            this.addEventListener(
                document,
                "mousedown",
                event => {
                    if (!this.isSelecting) return;
                    this.moving = false;
                    // event.preventDefault();
                    // event.stopPropagation();
                    if (event.target.id === "myCanvas") {
                        this._createDrag(event);
                    }
                },
                false
            );
        };

        // deselect the selected blocks

        this.deselectSelectedBlocks = () => {
            this.unhighlightSelectedBlocks(false);
            this.setSelectionMode(false);
        };

        // end the drag on navbar
        this.addEventListener(document.getElementById("toolbars"), "mouseover", () => {
            this.isDragging = false;
        });

        this.deleteMultipleBlocks = () => {
            if (this.blocks.selectionModeOn) {
                const blocksArray = this.blocks.selectedBlocks;
                // figure out which of the blocks in selectedBlocks are clamp blocks and nonClamp blocks.
                const clampBlocks = [];
                const nonClampBlocks = [];

                for (let i = 0; i < blocksArray.length; i++) {
                    if (this.blocks.selectedBlocks[i].isClampBlock()) {
                        clampBlocks.push(this.blocks.selectedBlocks[i]);
                    } else if (this.blocks.selectedBlocks[i].isDisconnected()) {
                        nonClampBlocks.push(this.blocks.selectedBlocks[i]);
                    }
                }

                for (let i = 0; i < clampBlocks.length; i++) {
                    this.blocks.sendStackToTrash(clampBlocks[i]);
                }

                for (let i = 0; i < nonClampBlocks.length; i++) {
                    this.blocks.sendStackToTrash(nonClampBlocks[i]);
                }
                // set selection mode to false
                this.blocks.setSelectionToActivity(false);
                this.refreshCanvas();
                // Cache DOM element reference for performance
                document.getElementById("helpfulWheelDiv").style.display = "none";
            }
        };

        this.copyMultipleBlocks = () => {
            if (this.blocks.selectionModeOn && this.blocks.selectedBlocks.length) {
                const blocksArray = this.blocks.selectedBlocks;
                let pasteDx = 0,
                    pasteDy = 0;
                const map = new Map();
                for (let i = 0; i < blocksArray.length; i++) {
                    const idx = this.blocks.blockList.indexOf(blocksArray[i]);
                    map.set(
                        idx,
                        blocksArray[i].connections.filter(blk => blk !== null)
                    );

                    if (
                        blocksArray[i].connections.some(blkno => {
                            const a = map.get(blkno);
                            return a && a.some(b => b === idx);
                        }) ||
                        blocksArray[i].trash
                    )
                        continue;

                    this.blocks.activeBlock = idx;
                    this.blocks.pasteDx = pasteDx;
                    this.blocks.pasteDy = pasteDy;
                    this.blocks.prepareStackForCopy();
                    this.blocks.pasteStack();
                    pasteDx += 21;
                    pasteDy += 21;
                }

                this.setSelectionMode(false);
                this.selectedBlocks = [];
                this.unhighlightSelectedBlocks(false, false);
                this.blocks.setSelectedBlocks(this.selectedBlocks);
                this.refreshCanvas();
                // Cache DOM element reference for performance
                document.getElementById("helpfulWheelDiv").style.display = "none";
            }
        };

        this.selectMode = () => {
            this.moving = false;
            this.isSelecting = !this.isSelecting;
            this.isSelecting
                ? this.textMsg(_("Select is enabled."))
                : this.textMsg(_("Select is disabled."));
            document.getElementById("helpfulWheelDiv").style.display = "none";
        };

        this._create2Ddrag = () => {
            this.dragArea = {};
            this.selectedBlocks = [];
            this.startX = 0;
            this.startY = 0;
            this.currentX = 0;
            this.currentY = 0;
            this.hasMouseMoved = false;
            if (this.selectionArea && this.selectionArea.parentNode) {
                this.selectionArea.parentNode.removeChild(this.selectionArea);
            }
            this.selectionArea = document.createElement("div");
            document.body.appendChild(this.selectionArea);

            this.setupMouseEvents();

            this.addEventListener(document, "mousemove", event => {
                this.hasMouseMoved = true;
                // event.preventDefault();
                // this.selectedBlocks = [];
                if (this.isDragging && this.isSelecting) {
                    this.currentX = event.clientX;
                    this.currentY = event.clientY;
                    if (!this.blocks.isBlockMoving && !this.turtles.running()) {
                        this.setSelectionMode(true);
                        this.drawSelectionArea();
                        this.selectedBlocks = this.selectBlocksInDragArea();
                        this.unhighlightSelectedBlocks(true, true);
                        this.blocks.setSelectedBlocks(this.selectedBlocks);
                    }
                }
            });

            this.addEventListener(document, "mouseup", event => {
                // event.preventDefault();
                if (!this.isSelecting) return;
                this.isDragging = false;
                this.selectionArea.style.display = "none";
                this.startX = 0;
                this.startY = 0;
                this.currentX = 0;
                this.currentY = 0;
                setTimeout(() => {
                    this.hasMouseMoved = false;
                }, 100);
            });
        };

        // Set starting points of the drag

        this._createDrag = event => {
            this.isDragging = true;
            this.startX = event.clientX;
            this.startY = event.clientY;
        };

        // Draw the area that has been dragged

        this.drawSelectionArea = () => {
            const x = Math.min(this.startX, this.currentX);
            const y = Math.min(this.startY, this.currentY);
            const width = Math.abs(this.currentX - this.startX);
            const height = Math.abs(this.currentY - this.startY);

            this.selectionArea.style.display = "flex";
            this.selectionArea.style.position = "absolute";
            this.selectionArea.style.left = x + "px";
            this.selectionArea.style.top = y + "px";
            this.selectionArea.style.height = height + "px";
            this.selectionArea.style.width = width + "px";
            this.selectionArea.style.zIndex = "9989";
            this.selectionArea.style.backgroundColor = "rgba(137, 207, 240, 0.5)";
            this.selectionArea.style.pointerEvents = "none";

            this.dragArea = { x, y, width, height };
        };

        // Check if the block is overlapping the dragged area.

        this.rectanglesOverlap = (rect1, rect2) => {
            return (
                rect1.x + rect1.width > rect2.x &&
                rect1.x < rect2.x + rect2.width &&
                rect1.y + rect1.height > rect2.y &&
                rect1.y < rect2.y + rect2.height
            );
        };

        // Select the blocks that overlap the dragged area.

        this.selectBlocksInDragArea = (dragArea, blocks) => {
            const selectedBlocks = [];
            this.dragRect = this.dragArea;

            this.blocks.blockList.forEach(block => {
                this.blockRect = {
                    x: this.scrollBlockContainer
                        ? block.container.x + this.blocksContainer.x
                        : block.container.x,
                    y: block.container.y + this.blocksContainer.y,
                    height: block.height,
                    width: block.width
                };

                if (this.rectanglesOverlap(this.blockRect, this.dragRect)) {
                    selectedBlocks.push(block);
                }
            });
            return selectedBlocks;
        };

        // Unhighlight the selected blocks

        this.unhighlightSelectedBlocks = (unhighlight, selectionModeOn) => {
            for (let i = 0; i < this.selectedBlocks.length; i++) {
                for (const blk in this.blocks.blockList) {
                    if (this.isEqual(this.blocks.blockList[blk], this.selectedBlocks[i])) {
                        if (unhighlight) {
                            this.blocks.unhighlightSelectedBlocks(blk, true);
                        } else {
                            this.blocks.highlight(blk, true);
                            this.refreshCanvas();
                        }
                    }
                }
            }
        };

        // Check if two blocks are same or not.

        this.isEqual = (obj1, obj2) => {
            const keys1 = Object.keys(obj1);
            const keys2 = Object.keys(obj2);

            if (keys1.length !== keys2.length) {
                return false;
            }

            for (const key of keys1) {
                if (!obj2.hasOwnProperty(key)) {
                    return false;
                }
            }

            for (const key of keys1) {
                if (obj1[key] !== obj2[key]) {
                    return false;
                }
            }

            return true;
        };

        this.setSelectionMode = selection => {
            if (selection) {
                if (!this.selectionModeOn) {
                    if (this.selectedBlocks.length !== 0) {
                        this.selectedBlocks = [];
                        this.selectionModeOn = selection;
                        this.blocks.setSelection(this.selectionModeOn);
                    }
                }
            } else {
                this.selectedBlocks = [];
                this.selectionModeOn = selection;
                this.blocks.setSelection(this.selectionModeOn);
            }
        };

        /*
         * Inits everything. The main function.
         */
        this.init = async () => {
            this._clientWidth = document.body.clientWidth;
            this._clientHeight = document.body.clientHeight;
            this._innerWidth = window.innerWidth;
            this._innerHeight = window.innerHeight;
            this._outerWidth = window.outerWidth;
            this._outerHeight = window.outerHeight;

            document.getElementById("loader").className = "loader";

            /*
             * Run browser check before implementing onblur -->
             * stop MB functionality
             * (This is being done to stop MB to lose focus when
             * increasing/decreasing volume on Firefox)
             */

            doBrowserCheck();

            const that = this;

            if (!jQuery.browser.mozilla) {
                window.onblur = () => {
                    doHardStopButton(that, true);
                };
            }

            this.stage = new createjs.Stage(this.canvas);
            createjs.Touch.enable(this.stage);

            // Initialize Ticker with optimal framerate
            createjs.Ticker.framerate = 60;

            // ===== Idle Ticker Optimization =====
            // Throttle rendering when user is inactive and no music is playing
            this._initIdleWatcher();

            // Named event handlers for proper cleanup
            let mouseEvents = 0;
            this.handleMouseMove = () => {
                mouseEvents++;
                if (mouseEvents % 4 === 0) {
                    that.__tick();
                }
            };

            this.handleDocumentClick = e => {
                if (!this.hasMouseMoved) {
                    if (this.selectionModeOn) {
                        this.deselectSelectedBlocks();
                    } else {
                        this._hideHelpfulSearchWidget(e);
                    }
                }
            };

            // Use managed addEventListener for automatic cleanup
            this.addEventListener(document, "mousemove", this.handleMouseMove);
            this.addEventListener(document, "click", this.handleDocumentClick);

            this._createMsgContainer(
                "#ffffff",
                "#7a7a7a",
                text => {
                    that.msgText = text;
                },
                130
            );

            this._createMsgContainer(
                "#ffcbc4",
                "#ff0031",
                text => {
                    that.errorMsgText = text;
                },
                130
            );

            this._createErrorContainers();

            /* Z-Order (top to bottom):
             *   menus
             *   palettes
             *   blocks
             *   trash
             *   turtles
             *   logo (drawing)
             */
            this.blocksContainer = new createjs.Container();
            this.trashContainer = new createjs.Container();
            this.turtleContainer = new createjs.Container();
            this.stage.addChild(this.turtleContainer);
            this.stage.addChild(this.trashContainer);
            this.stage.addChild(this.blocksContainer);
            this._setupBlocksContainerEvents();

            this.trashcan = new Trashcan(this);
            this.turtles = new Turtles(this);
            this.boundary = new Boundary(this.blocksContainer);
            this.blocks = new Blocks(this);
            this.palettes = new Palettes(this);
            this.palettes.init();
            this.logo = new Logo(this);

            this.pasteBox = new PasteBox(this);
            this.languageBox = new LanguageBox(this);
            this.themeBox = new ThemeBox(this);

            // Show help on startup if first-time user.
            if (this.firstTimeUser) {
                this._showHelp();
            }

            try {
                this.planet = new PlanetInterface(this);
                await this.planet.init();
            } catch (e) {
                this.planet = undefined;
            }

            this.save = new SaveInterface(this);

            this.toolbar = new Toolbar();
            this.toolbar.init(this);

            this.toolbar.renderLogoIcon(showAboutPage);
            this.toolbar.renderPlayIcon(doFastButton);
            this.toolbar.renderStopIcon(doHardStopButton);
            this.toolbar.renderNewProjectIcon(_afterDelete);
            this.toolbar.renderLoadIcon(doLoad);
            this.toolbar.renderSaveIcons(
                this.save.saveHTML.bind(this.save),
                doSVG,
                this.save.saveSVG.bind(this.save),
                this.save.saveMIDI.bind(this.save),
                this.save.savePNG.bind(this.save),
                this.save.saveWAV.bind(this.save),
                this.save.saveLilypond.bind(this.save),
                this.save.saveAbc.bind(this.save),
                this.save.saveMxml.bind(this.save),
                this.save.saveBlockArtwork.bind(this.save),
                this.save.saveBlockArtworkPNG.bind(this.save)
            );
            this.toolbar.renderPlanetIcon(this.planet, doOpenSamples);
            this.toolbar.renderMenuIcon(showHideAuxMenu);
            this.toolbar.renderHelpIcon(showHelp);
            this.toolbar.renderModeSelectIcon(
                doSwitchMode,
                () => doRecordButton(this),
                doAnalytics,
                doOpenPlugin,
                deletePlugin,
                setScroller
            );
            this.toolbar.renderRunSlowlyIcon(doSlowButton);
            this.toolbar.renderRunStepIcon(doStepButton);
            this.toolbar.renderThemeSelectIcon(this.themeBox, this.themes);
            this.toolbar.renderMergeIcon(_doMergeLoad);
            this.toolbar.renderRestoreIcon(restoreTrash);
            if (_THIS_IS_MUSIC_BLOCKS_) {
                this.toolbar.renderChooseKeyIcon(chooseKeyMenu);
            }
            this.toolbar.renderJavaScriptIcon(toggleJSWindow);
            this.toolbar.renderLanguageSelectIcon(this.languageBox);
            this.toolbar.renderWrapIcon();

            initPalettes(this.palettes);

            if (this.planet !== undefined) {
                this.saveLocally = this.planet.saveLocally.bind(this.planet);
            } else {
                this.saveLocally = this.__saveLocally;
            }

            window.saveLocally = this.saveLocally;

            initBasicProtoBlocks(this);

            // Load any macros saved in local storage.
            // this.storage.macros = null;
            this.macroData = this.storage.macros;
            if (this.macroData !== null) {
                processMacroData(this.macroData, this.palettes, this.blocks, this.macroDict);
            }

            // Load any plugins saved in local storage.
            this.pluginData = this.storage.plugins;
            if (this.pluginData !== null && this.pluginData !== "null") {
                updatePluginObj(
                    this,
                    processPluginData(this, this.pluginData, "localStorage:plugins")
                );
            }

            // Load custom mode saved in local storage.
            const custommodeData = this.storage.custommode;
            if (custommodeData !== undefined) {
                // Parse and update the custom musical mode with saved data.
                try {
                    const customModeDataObj = JSON.parse(custommodeData);
                    Object.assign(MUSICALMODES["custom"], customModeDataObj);
                } catch (e) {
                    console.error("Error parsing custommode data:", e);
                }
            }

            this.fileChooser.addEventListener("click", () => {
                that.value = null;
            });

            this.fileChooser.addEventListener(
                "change",
                () => {
                    // Read file here.
                    const reader = new FileReader();
                    const midiReader = new FileReader();

                    reader.onload = () => {
                        that.loading = true;
                        document.body.style.cursor = "wait";
                        that.doLoadAnimation();

                        setTimeout(() => {
                            const rawData = reader.result;
                            if (rawData === null || rawData === "") {
                                that.errorMsg(
                                    _(
                                        "Cannot load project from the file. Please check the file type."
                                    )
                                );
                            } else {
                                const cleanData = rawData.replace("\n", " ");
                                let obj;
                                try {
                                    if (cleanData.includes("html")) {
                                        if (cleanData.includes('id="codeBlock"')) {
                                            obj = JSON.parse(
                                                cleanData.match(
                                                    '<div class="code" id="codeBlock">(.+?)</div>'
                                                )[1]
                                            );
                                        } else {
                                            obj = JSON.parse(
                                                cleanData.match('<div class="code">(.+?)</div>')[1]
                                            );
                                        }
                                    } else {
                                        obj = JSON.parse(cleanData);
                                    }
                                    // First, hide the palettes as they will need updating.
                                    for (const name in that.palettes.dict) {
                                        that.palettes.dict[name].hideMenu(true);
                                    }

                                    that.stage.removeAllEventListeners("trashsignal");

                                    if (!that.merging) {
                                        // Wait for the old blocks to be removed.
                                        const __listener = () => {
                                            that.blocks.loadNewBlocks(obj);
                                            that.stage.removeAllEventListeners("trashsignal");
                                            if (that.planet) {
                                                that.planet.saveLocally();
                                            }
                                        };

                                        that.stage.addEventListener(
                                            "trashsignal",
                                            __listener,
                                            false
                                        );
                                        that.sendAllToTrash(false, false);
                                        that._allClear(false, true);
                                        if (that.planet) {
                                            that.planet.closePlanet();
                                            that.planet.initialiseNewProject(
                                                that.fileChooser.files[0].name.substr(
                                                    0,
                                                    that.fileChooser.files[0].name.lastIndexOf(".")
                                                )
                                            );
                                        }
                                    } else {
                                        that.merging = false;
                                        that.blocks.loadNewBlocks(obj);
                                    }

                                    that.loading = false;
                                    that.refreshCanvas();
                                } catch (e) {
                                    that.errorMsg(
                                        _(
                                            "Cannot load project from the file. Please check the file type."
                                        )
                                    );
                                    // eslint-disable-next-line no-console
                                    console.error(e);
                                    document.body.style.cursor = "default";
                                    that.loading = false;
                                }
                            }
                        }, 200);
                    };

                    midiReader.onload = e => {
                        const midi = new Midi(e.target.result);
                        // eslint-disable-next-line no-console
                        console.debug(midi);
                        midiImportBlocks(midi);
                    };

                    const file = that.fileChooser.files[0];
                    if (file) {
                        const extension = file.name.split(".").pop().toLowerCase();
                        const isMidi = extension === "mid" || extension === "midi";
                        if (isMidi) {
                            midiReader.readAsArrayBuffer(file);
                        } else {
                            reader.readAsText(file);
                        }
                    }
                },
                false
            );

            const __handleFileSelect = event => {
                event.stopPropagation();
                event.preventDefault();

                const files = event.dataTransfer.files;
                const reader = new FileReader();
                const midiReader = new FileReader();

                const abcReader = new FileReader();
                reader.onload = () => {
                    that.loading = true;
                    document.body.style.cursor = "wait";
                    // doLoadAnimation();

                    setTimeout(() => {
                        const rawData = reader.result;
                        if (rawData === null || rawData === "") {
                            that.errorMsg(
                                _("Cannot load project from the file. Please check the file type.")
                            );
                        } else {
                            const cleanData = rawData.replace("\n", " ");
                            let obj;
                            try {
                                if (cleanData.includes("html")) {
                                    obj = JSON.parse(
                                        cleanData.match('<div class="code">(.+?)</div>')[1]
                                    );
                                } else {
                                    obj = JSON.parse(cleanData);
                                }
                                for (const name in that.blocks.palettes.dict) {
                                    that.palettes.dict[name].hideMenu(true);
                                }

                                that.stage.removeAllEventListeners("trashsignal");

                                const __afterLoad = () => {
                                    document.removeEventListener("finishedLoading", __afterLoad);
                                };

                                // Wait for the old blocks to be removed.
                                const __listener = () => {
                                    that.blocks.loadNewBlocks(obj);
                                    that.stage.removeAllEventListeners("trashsignal");

                                    if (document.addEventListener) {
                                        document.addEventListener("finishedLoading", __afterLoad);
                                    } else {
                                        document.attachEvent("finishedLoading", __afterLoad);
                                    }
                                };

                                that.stage.addEventListener("trashsignal", __listener, false);
                                that.sendAllToTrash(false, false);
                                if (that.planet !== undefined) {
                                    that.planet.initialiseNewProject(
                                        files[0].name.substr(0, files[0].name.lastIndexOf("."))
                                    );
                                }

                                that.loading = false;
                                that.refreshCanvas();
                            } catch (e) {
                                // eslint-disable-next-line no-console
                                console.error(e);
                                that.errorMsg(
                                    _(
                                        "Cannot load project from the file. Please check the file type."
                                    )
                                );
                                document.body.style.cursor = "default";
                                that.loading = false;
                            }
                        }
                    }, 200);
                };
                midiReader.onload = e => {
                    const midi = new Midi(e.target.result);
                    // eslint-disable-next-line no-console
                    console.debug(midi);
                    midiImportBlocks(midi);
                };

                // Music Block Parser from abc to MB
                abcReader.onload = event => {
                    //get the abc data and replace the / so that the block does not break
                    let abcData = event.target.result;
                    abcData = abcData.replace(/\\/g, "");

                    const tunebook = new ABCJS.parseOnly(abcData);
                    // eslint-disable-next-line no-console
                    console.log(tunebook);
                    tunebook.forEach(tune => {
                        //call parseABC to parse abcdata to MB json
                        this.parseABC(tune);
                    });
                };

                // Work-around in case the handler is called by the
                // widget drag & drop code.
                if (files[0] !== undefined) {
                    const extension = files[0].name.split(".").pop().toLowerCase(); //file extension from input file

                    const isMidi = extension == "mid" || extension == "midi";
                    if (isMidi) {
                        midiReader.readAsArrayBuffer(files[0]);
                        return;
                    }

                    const isABC = extension == "abc";
                    if (isABC) {
                        abcReader.readAsText(files[0]);
                        return;
                    }
                    reader.readAsText(files[0]);
                    window.scroll(0, 0);
                }
            };

            const __handleDragOver = event => {
                event.stopPropagation();
                event.preventDefault();
                event.dataTransfer.dropEffect = "copy";
            };

            const dropZone = document.getElementById("canvasHolder");
            dropZone.addEventListener("dragover", __handleDragOver, false);
            dropZone.addEventListener("drop", __handleFileSelect, false);

            this.allFilesChooser.addEventListener("click", () => {
                this.value = null;
            });

            this.pluginChooser.addEventListener("click", () => {
                window.scroll(0, 0);
                this.value = null;
            });

            this.pluginChooser.addEventListener(
                "change",
                () => {
                    window.scroll(0, 0);

                    // Read file here.
                    const reader = new FileReader();
                    const pluginFile = that.pluginChooser.files[0];

                    reader.onload = () => {
                        that.loading = true;
                        document.body.style.cursor = "wait";
                        //doLoadAnimation();

                        setTimeout(() => {
                            const obj = processRawPluginData(
                                that,
                                reader.result,
                                pluginFile && pluginFile.name ? pluginFile.name : "local-file"
                            );
                            // Save plugins to local storage.
                            if (obj !== null) {
                                that.storage.plugins = preparePluginExports(that, obj);
                            }

                            // Refresh the palettes.
                            setTimeout(() => {
                                if (that.palettes.visible) {
                                    that.palettes.hide();
                                }
                            }, 1000);

                            document.body.style.cursor = "default";
                            that.loading = false;
                        }, 200);
                    };

                    reader.readAsText(pluginFile);
                },
                false
            );

            // Workaround to chrome security issues
            // createjs.LoadQueue(true, null, true);

            // Enable touch interactions if supported on the current device.
            createjs.Touch.enable(this.stage, false, true);

            // Keep tracking the mouse even when it leaves the canvas.
            this.stage.mouseMoveOutside = true;

            // Enabled mouse over and mouse out events.
            this.stage.enableMouseOver(10); // default is 20

            this.cartesianBitmap = this._createGrid(
                "data:image/svg+xml;base64," + window.btoa(base64Encode(CARTESIAN))
            );
            this.polarBitmap = this._createGrid(
                "data:image/svg+xml;base64," + window.btoa(base64Encode(POLAR))
            );
            this.trebleBitmap = this._createGrid(
                "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE))
            );
            this.grandBitmap = this._createGrid(
                "data:image/svg+xml;base64," + window.btoa(base64Encode(GRAND))
            );
            this.sopranoBitmap = this._createGrid(
                "data:image/svg+xml;base64," + window.btoa(base64Encode(SOPRANO))
            );
            this.altoBitmap = this._createGrid(
                "data:image/svg+xml;base64," + window.btoa(base64Encode(ALTO))
            );
            this.tenorBitmap = this._createGrid(
                "data:image/svg+xml;base64," + window.btoa(base64Encode(TENOR))
            );
            this.bassBitmap = this._createGrid(
                "data:image/svg+xml;base64," + window.btoa(base64Encode(BASS))
            );

            // We use G (one sharp) and F (one flat) as prototypes for all
            // of the accidentals. When applied, these graphics are offset
            // vertically to rendering different sharps and flats and
            // horizontally so as not to overlap.
            for (let i = 0; i < 7; i++) {
                this.grandSharpBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(GRAND_G))
                );
                this.grandFlatBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(GRAND_F))
                );
                this.trebleSharpBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_G))
                );
                this.trebleFlatBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_F))
                );
                this.sopranoSharpBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_G))
                );
                this.sopranoFlatBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_F))
                );
                this.altoSharpBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_G))
                );
                this.altoFlatBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_F))
                );
                this.tenorSharpBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_G))
                );
                this.tenorFlatBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_F))
                );
                this.bassSharpBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_G))
                );
                this.bassFlatBitmap[i] = this._createGrid(
                    "data:image/svg+xml;base64," + window.btoa(base64Encode(TREBLE_F))
                );
            }

            const URL = window.location.href;
            const flags = {
                run: false,
                show: false,
                collapse: false
            };

            // Scale the canvas relative to the screen size.
            this._onResize(true);

            let urlParts;
            const env = [];

            if (URL.indexOf("?") > 0) {
                let args, url;
                urlParts = URL.split("?");
                if (urlParts[1].indexOf("&") > 0) {
                    const newUrlParts = urlParts[1].split("&");
                    for (let i = 0; i < newUrlParts.length; i++) {
                        if (newUrlParts[i].indexOf("=") > 0) {
                            args = newUrlParts[i].split("=");
                            switch (args[0].toLowerCase()) {
                                case "file":
                                    break;
                                case "id":
                                    this.projectID = args[1];
                                    break;
                                case "run":
                                    if (args[1].toLowerCase() === "true") flags.run = true;
                                    break;
                                case "show":
                                    if (args[1].toLowerCase() === "true") flags.show = true;
                                    break;
                                case "collapse":
                                    if (args[1].toLowerCase() === "true") flags.collapse = true;
                                    break;
                                case "inurl":
                                    url = args[1];
                                    // eslint-disable-next-line no-case-declarations
                                    const getJSON = url => {
                                        return new Promise((resolve, reject) => {
                                            const xhr = new XMLHttpRequest();
                                            xhr.open("get", url, true);
                                            xhr.responseType = "json";
                                            xhr.onload = () => {
                                                const status = xhr.status;
                                                if (status === 200) {
                                                    resolve(xhr.response);
                                                } else {
                                                    reject(status);
                                                }
                                            };
                                            xhr.send();
                                        });
                                    };

                                    getJSON(url).then(
                                        data => {
                                            const n = data.arg;
                                            env.push(parseInt(n));
                                        },
                                        () => {
                                            alert(
                                                "Something went wrong reading JSON-encoded project data."
                                            );
                                        }
                                    );
                                    break;
                                case "outurl":
                                    url = args[1];
                                    break;
                                default:
                                    this.errorMsg(_("Invalid parameters"));
                                    break;
                            }
                        }
                    }
                } else {
                    if (urlParts[1].indexOf("=") > 0) {
                        args = urlParts[1].split("=");
                    }

                    //ID is the only arg that can stand alone
                    if (args[0].toLowerCase() === "id") {
                        this.projectID = args[1];
                    }
                }
            }

            if (this.projectID !== null) {
                setTimeout(() => {
                    that.loadStartWrapper(loadProject, that.projectID, flags, env);
                }, 200); // 2000
            } else {
                setTimeout(() => {
                    that.loadStartWrapper(loadStart);
                }, 200); // 2000
            }

            this.prepSearchWidget();

            // initialize doSearch
            this.doSearch();

            // create functionality of 2D drag to select blocks in bulk
            this._create2Ddrag();

            /*
            document.addEventListener("mousewheel", scrollEvent, false);
            document.addEventListener("DOMMouseScroll", scrollEvent, false);
            */

            // Named event handler for proper cleanup
            const activity = this;
            this.handleKeyDown = event => {
                activity.__keyPressed(event);
            };

            // Use managed addEventListener instead of onkeydown assignment
            this.addEventListener(document, "keydown", this.handleKeyDown);

            if (this.planet !== undefined) {
                this.planet.planet.setAnalyzeProject(doAnalyzeProject);
            }
        };
    }

    /**
     * Managed addEventListener that tracks listeners for cleanup.
     * @param {EventTarget} target - The DOM element or object to attach the listener to.
     * @param {string} type - The event type.
     * @param {Function} listener - The callback function.
     * @param {Object|boolean} [options] - listener options.
     */
    addEventListener(target, type, listener, options) {
        if (!target || typeof target.addEventListener !== "function") return;
        target.addEventListener(type, listener, options);
        this._listeners.push({ target, type, listener, options });
    }

    /**
     * Managed removeEventListener that also updates the tracker.
     * @param {EventTarget} target - The DOM element or object to remove the listener from.
     * @param {string} type - The event type.
     * @param {Function} listener - The callback function.
     * @param {Object|boolean} [options] - listener options.
     */
    removeEventListener(target, type, listener, options) {
        if (!target || typeof target.removeEventListener !== "function") return;
        target.removeEventListener(type, listener, options);
        this._listeners = this._listeners.filter(
            l =>
                l.target !== target ||
                l.type !== type ||
                l.listener !== listener ||
                !this._areOptionsEqual(l.options, options)
        );
    }

    /**
     * Checks if two event listener option sets are equivalent for the purpose of removal.
     * @param {Object|boolean} opt1 - First option set.
     * @param {Object|boolean} opt2 - Second option set.
     * @returns {boolean} True if they are effectively equal.
     */
    _areOptionsEqual(opt1, opt2) {
        // Normalize options to booleans for capture flag, as that's the primary discriminator for removal
        const getCapture = opt => {
            if (typeof opt === "boolean") return opt;
            if (typeof opt === "object" && opt !== null) return !!opt.capture;
            return false;
        };
        return getCapture(opt1) === getCapture(opt2);
    }

    /**
     * Removes all tracked event listeners.
     */
    cleanupEventListeners() {
        while (this._listeners.length > 0) {
            const { target, type, listener, options } = this._listeners.pop();
            if (target && typeof target.removeEventListener === "function") {
                target.removeEventListener(type, listener, options);
            }
        }
    }

    /**
     * Saves the current state locally
     * @returns {void}
     */
    saveLocally() {
        try {
            localStorage.setItem("beginnerMode", this.beginnerMode.toString());
            localStorage.setItem("themePreference", this.themePreference.toString());
        } catch (e) {
            // eslint-disable-next-line no-console
            console.error("Error saving to localStorage:", e);
        }
    }

    /**
     * Regenerates all palettes based on current mode
     * @returns {void}
     */
    regeneratePalettes() {
        try {
            // Store current palette positions
            const palettePositions = {};
            if (this.palettes && this.palettes.dict) {
                for (const name in this.palettes.dict) {
                    const palette = this.palettes.dict[name];
                    if (
                        palette &&
                        palette.container &&
                        typeof palette.container.x !== "undefined"
                    ) {
                        palettePositions[name] = {
                            x: palette.container.x,
                            y: palette.container.y,
                            visible: !!palette.visible
                        };
                    }
                }
            }

            // Safely hide and clear existing palettes
            if (!this.palettes) {
                // eslint-disable-next-line no-console
                console.warn("Palettes object not initialized");
                return;
            }

            if (typeof this.palettes.hide !== "function") {
                // eslint-disable-next-line no-console
                console.warn("Palettes hide method not available");
            } else {
                this.palettes.hide();
            }

            if (typeof this.palettes.clear !== "function") {
                // eslint-disable-next-line no-console
                console.warn("Palettes clear method not available");
                // Fallback clear implementation
                this.palettes.dict = {};
                this.palettes.visible = false;
                this.palettes.activePalette = null;
                this.palettes.paletteObject = null;
            } else {
                this.palettes.clear();
            }

            // Reinitialize palettes
            initPalettes(this.palettes);

            // Reinitialize blocks
            if (this.blocks) {
                initBasicProtoBlocks(this);
            }

            // Restore palette positions
            if (this.palettes && this.palettes.dict) {
                for (const name in palettePositions) {
                    const palette = this.palettes.dict[name];
                    const pos = palettePositions[name];

                    if (palette && palette.container && pos) {
                        palette.container.x = pos.x;
                        palette.container.y = pos.y;

                        if (pos.visible) {
                            palette.showMenu(true);
                        }
                    }
                }
            }

            // Update the palette display
            if (this.palettes && typeof this.palettes.updatePalettes === "function") {
                this.palettes.updatePalettes();
            }

            // Update blocks
            if (this.blocks && typeof this.blocks.updateBlockPositions === "function") {
                this.blocks.updateBlockPositions();
            }

            this.refreshCanvas();
        } catch (e) {
            // eslint-disable-next-line no-console
            console.error("Error regenerating palettes:", e);
            this.errorMsg(_("Error regenerating palettes. Please refresh the page."));
        }
    }
}

// ---------------------------------------------------------------------------
// Hard Deprecation Guard — window.activity
//
// The Activity singleton is no longer exposed on window.activity.
// All code must use ActivityContext.getActivity() instead.
// This guard ensures:
//   • Silent-regression safety (warns loudly in console, not silently undefined)
//   • A migration window — replace with a hard removal in the next major version
// ---------------------------------------------------------------------------
(function installActivityDeprecationGuard() {
    if (typeof window === "undefined") return; // safety for SSR / Node test runners
    try {
        Object.defineProperty(window, "activity", {
            configurable: true, // allow removal in the next major version
            enumerable: false,
            get() {
                // eslint-disable-next-line no-console
                console.warn(
                    "[Deprecated] window.activity is removed. " +
                        "Use ActivityContext.getActivity() instead."
                );
                return undefined;
            },
            set() {
                // eslint-disable-next-line no-console
                console.error(
                    "[Deprecated] window.activity is removed and cannot be set. " +
                        "Use ActivityContext.setActivity() via activity-context.js."
                );
            }
        });
    } catch (e) {
        // Fail silently — defining the property must never break the app.
        // eslint-disable-next-line no-console
        console.warn("[ActivityDeprecationGuard] Could not install guard:", e);
    }
})();

const activity = new Activity();

// Execute initialization once all RequireJS modules are loaded AND DOM is ready
define(["domReady!"].concat(MYDEFINES), doc => {
    const initialize = () => {
        // Defensive check for multiple critical globals that may be delayed
        // due to 'defer' execution timing variances.
        const globalsReady =
            typeof createDefaultStack !== "undefined" &&
            typeof createjs !== "undefined" &&
            typeof Tone !== "undefined" &&
            typeof GIFAnimator !== "undefined" &&
            typeof SuperGif !== "undefined";

        if (globalsReady) {
            activity.setupDependencies();
            activity.domReady(doc);
            activity.doContextMenus();
            activity.doPluginsAndPaletteCols();
        } else {
            // Race condition in Firefox: non-AMD scripts might not have
            // finished global assignment yet.
            // Use readiness-based initialization for Firefox for better performance
            if (typeof jQuery !== "undefined" && jQuery.browser && jQuery.browser.mozilla) {
                waitForReadiness(
                    () => {
                        activity.setupDependencies();
                        activity.domReady(doc);
                        activity.doContextMenus();
                        activity.doPluginsAndPaletteCols();
                    },
                    {
                        maxWait: 10000,
                        minWait: 500,
                        checkInterval: 100
                    }
                );
            } else {
                setTimeout(initialize, 50); // Increased delay slightly
            }
        }
    };
    initialize();
});