From 95c979681787ecb056833c6fecf74d43c68718a6 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sun, 5 Nov 2023 21:45:33 -0800
Subject: [PATCH 01/13] Create Sty-Lists.js

---
 extensions/SharkPool/Sty-Lists.js | 950 ++++++++++++++++++++++++++++++
 1 file changed, 950 insertions(+)
 create mode 100644 extensions/SharkPool/Sty-Lists.js

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
new file mode 100644
index 0000000000..fdc0086e92
--- /dev/null
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -0,0 +1,950 @@
+// Name: Sty-Lists
+// ID: SPlistMonitors
+// Description: Customize and Organize Lists Monitors.
+// By: SharkPool
+
+// Version 1.0
+
+(function (Scratch) {
+  "use strict";
+
+  if (!Scratch.extensions.unsandboxed) {
+    throw new Error("Sty-Lists must run unsandboxed!");
+  }
+
+  const menuIconURI =
+"data:image/svg+xml;base64,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";
+
+  const vm = Scratch.vm;
+  const runtime = vm.runtime;
+  const builtInFonts = [
+    "Scratch",
+    "Sans Serif",
+    "Serif",
+    "Handwriting",
+    "Marker",
+    "Curly",
+    "Pixel"
+  ];
+
+  class SPlistMonitors {
+    getInfo() {
+      return {
+        id: "SPlistMonitors",
+        name: "Sty-Lists",
+        color1: "#FF661A",
+        color2: "#ba3e00",
+        color3: "#cc4602",
+        menuIconURI,
+        blocks: [
+          {
+            opcode: "listExists",
+            blockType: Scratch.BlockType.BOOLEAN,
+            text: "does [LIST] exist?",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "my list"
+              },
+            },
+          },
+          {
+            opcode: "isShowing",
+            blockType: Scratch.BlockType.BOOLEAN,
+            text: "is [LIST] showing?",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "makeList",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "create list named [LIST] [TYPE]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "my list",
+              },
+              TYPE: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "listTypes",
+                defaultValue: "globally",
+              }
+            },
+          },
+          "---",
+          {
+            opcode: "renderList",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "render [LIST] with [NUM] columns",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              NUM: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 2,
+              },
+            },
+          },
+          {
+            opcode: "getColumns",
+            blockType: Scratch.BlockType.REPORTER,
+            text: "# of columns in [LIST]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          "---",
+          {
+            opcode: "stretchList",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "stretch [LIST] to width: [WIDTH] and height: [HEIGHT]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              WIDTH: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 200,
+              },
+              HEIGHT: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 200,
+              },
+            },
+          },
+          {
+            opcode: "getAtt",
+            blockType: Scratch.BlockType.REPORTER,
+            text: "get [THING] of [LIST]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              THING: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "ATTS",
+                defaultValue: "width",
+              },
+            },
+          },
+          "---",
+          {
+            opcode: "chooseOption",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "turn [THING] in [LIST] [ON_OFF]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              THING: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "listUtils",
+                defaultValue: "click events",
+              },
+              ON_OFF: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "ON_OFF",
+                defaultValue: "off",
+              },
+            },
+          },
+          {
+            opcode: "formatItems",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "align item text to [ALIGN] in [LIST]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              ALIGN: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "ALIGN",
+                defaultValue: "left",
+              },
+            },
+          },
+          {
+            blockType: Scratch.BlockType.XML,
+            xml: "<sep gap=\"6\"/><label text=\"Positioning\"/><sep gap=\"-12\"/><sep gap=\"12\"/>",
+          },
+          {
+            opcode: "setPosition",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "set position of [LIST] to x: [x] y: [y]",
+            arguments: {
+              x: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0,
+              },
+              y: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 0,
+              },
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "currentPos",
+            blockType: Scratch.BlockType.REPORTER,
+            text: "current [POSITION] of [LIST]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              POSITION: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "POSITIONS",
+                defaultValue: "x",
+              },
+            },
+          },
+          "---",
+          {
+            opcode: "setScroll",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "set scrollbar position of [LIST] to [SCROLL]%",
+            arguments: {
+              SCROLL: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 50,
+              },
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            blockType: Scratch.BlockType.XML,
+            xml: "<sep gap=\"6\"/><label text=\"Effects\"/><sep gap=\"-12\"/><sep gap=\"12\"/>",
+          },
+          {
+            opcode: "resetAll",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "reset all changes to [LIST]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "setDisplay",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "set [DISPLAY] name of [LIST] to [NAME]",
+            arguments: {
+              NAME: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "my cooler list",
+              },
+              DISPLAY: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "list_displays",
+                defaultValue: "header",
+              },
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "setColor",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "set color of item # [NUM] in [LIST] to [COLOR]",
+            arguments: {
+              NUM: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 1,
+              },
+              COLOR: {
+                type: Scratch.ArgumentType.COLOR,
+                defaultValue: "#0000ff",
+              },
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "setLabel",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "set name of label # [NUM] in [LIST] to [VALUE]",
+            arguments: {
+              NUM: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 1,
+              },
+              VALUE: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "item 1",
+              },
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "setFont",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "set font of [LIST] to [FONT]",
+            arguments: {
+              FONT: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "allFonts",
+                defaultValue: "Scratch",
+              },
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          "---",
+          {
+            opcode: "resetEffect",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "reset effects of [LIST]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "setEffect",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "set [EFFECT] of [LIST] to [AMOUNT]",
+            arguments: {
+              AMOUNT: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 5,
+              },
+              EFFECT: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "EFFECTS",
+                defaultValue: "blur",
+              },
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "stretchEffect",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "scale [LIST] to x: [x] y: [y]",
+            arguments: {
+              x: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 200,
+              },
+              y: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: 100,
+              },
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+            },
+          },
+          {
+            opcode: "currentEffect",
+            blockType: Scratch.BlockType.REPORTER,
+            text: "current [EFFECT] of [LIST]",
+            arguments: {
+              LIST: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "lists"
+              },
+              EFFECT: {
+                type: Scratch.ArgumentType.STRING,
+                menu: "ALL_EFFECTS",
+                defaultValue: "blur",
+              },
+            },
+          }
+        ],
+        menus: {
+          ATTS: {
+            acceptReporters: true,
+            items: ["width", "height"],
+          },
+          lists: {
+            acceptReporters: true,
+            items: "getLists",
+          },
+          allFonts: {
+            acceptReporters: true,
+            items: "getFonts",
+          },
+          POSITIONS: {
+            acceptReporters: false,
+            items: ["x", "y"],
+          },
+          list_displays: {
+            acceptReporters: false,
+            items: ["header", "footer"],
+          },
+          listTypes: {
+            acceptReporters: false,
+            items: ["globally", "for this sprite only"],
+          },
+          listUtils: {
+            acceptReporters: false,
+            items: [
+              "click events",
+              "text highlighting",
+              "numbered items",
+              "+ and = buttons"
+            ],
+          },
+          ON_OFF: {
+            acceptReporters: false,
+            items: ["on", "off"],
+          },
+          ALIGN: {
+            acceptReporters: true,
+            items: ["left", "right", "center"],
+          },
+          EFFECTS: {
+            acceptReporters: true,
+            items: this.getEffects(false)
+          },
+          ALL_EFFECTS: {
+            acceptReporters: true,
+            items: this.getEffects(true)
+          },
+        }
+      }
+    }
+
+    // Thank you SkyHigh173 for the getLists and find list functions :))
+    getLists() {
+      const globalLists = Object.values(
+        vm.runtime.getTargetForStage().variables
+      ).filter((x) => x.type == "list");
+      const localLists = Object.values(vm.editingTarget.variables).filter(
+        (x) => x.type == "list"
+      );
+      const uniqueLists = [...new Set([...globalLists, ...localLists])];
+      if (uniqueLists.length === 0) {
+        return [
+          { text: "make a list", value: "make a list" },
+        ];
+      }
+      return uniqueLists.map((i) => ({
+        text: i.name,
+        value: i.id,
+      }));
+    }
+
+    lookForList(list, util) {
+      const byId = util.target.lookupVariableById(list);
+      if (byId && byId.type === "list") {
+        return JSON.stringify(byId.id);
+      }
+      const byName = util.target.lookupVariableByNameAndType(list, "list");
+      if (byName) {
+        return JSON.stringify(byName.id);
+      }
+      return;
+    }
+
+    getFonts() {
+      const customFonts = Scratch.vm.runtime.fontManager
+        ? Scratch.vm.runtime.fontManager.getFonts().map((i) => ({
+            text: i.name,
+            value: i.family,
+          }))
+        : [];
+      return [
+        ...builtInFonts,
+        ...customFonts,
+      ];
+    }
+
+    getEffects(enable) {
+      return [
+        "blur",
+        "saturation",
+        "contrast",
+        "brightness",
+        "hue",
+        "opacity",
+        "sepia",
+        "invert",
+        "direction",
+        ...(enable ? ["scale x", "scale y"] : []),
+        "skew x",
+        "skew y"
+      ];
+    }
+
+    renderList(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      args.NUM = args.NUM > 0 ? Math.round(args.NUM) : 1;
+      const parentList = document.querySelector(`[data-id=${list}] .ReactVirtualized__Grid.ReactVirtualized__List`);
+      if (parentList === null) return;
+      let listWidth = parseInt(parentList.style.width, 10);
+      listWidth = listWidth / args.NUM;
+      list = document.querySelector(`[data-id=${list}] .ReactVirtualized__Grid__innerScrollContainer`);
+      if (list === null) return;
+      const itemsHTML = this.getListArray(args.LIST, util);
+      const newContainer = document.createElement("div");
+      newContainer.className = "ReactVirtualized__Grid__innerScrollContainer";
+
+      newContainer.setAttribute("role", "rowgroup");
+      newContainer.style.width = "auto";
+      newContainer.style.height = `${((itemsHTML[1] * 24) / args.NUM) + 24}px`;
+      newContainer.style.maxWidth = parentList.style.width;
+      newContainer.style.maxHeight = list.style.maxHeight;
+      newContainer.style.overflow = "hidden";
+      newContainer.style.position = "relative";
+
+      newContainer.innerHTML = itemsHTML[0];
+      list.parentNode.replaceChild(newContainer, list);
+      function reorderIntoColumns(numColumns) {
+        const items = newContainer.querySelectorAll(`[class^="monitor_list-row"]`);
+        for (let i = 0; i < items.length; i++) {
+          const column = i % numColumns;
+          const top = Math.floor(i / numColumns) * items[0].offsetHeight;
+          items[i].style.top = top + "px";
+          items[i].style.left = (column * listWidth) + "px";
+          items[i].style.width = 100 / numColumns + "%";
+        }
+      }
+      reorderIntoColumns(args.NUM);
+      parentList.scrollTop = 0;
+    }
+
+    getColumns(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return 0;
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      list = list.querySelector(".ReactVirtualized__Grid__innerScrollContainer");
+      if (list === null) return 1;
+
+      const items = Array.from(list.querySelectorAll(`[class^="monitor_list-row"]`));
+      if (items.length === 0) return 1;
+      const firstItem = items[0];
+      const itemWidth = parseFloat(firstItem.style.width);
+      if (!isNaN(itemWidth) && itemWidth > 0) {
+        const numColumns = 100 / itemWidth;
+        return Math.round(numColumns);
+      }
+      return 1;
+    }
+
+    getListArray(list, util) {
+      const items = util.target.lookupVariableById(list).value;
+      let allItems = document.querySelectorAll(`[data-id="${list}"]`);
+      allItems = allItems[allItems.length - 1];
+      allItems = allItems.querySelectorAll(`[class^="monitor_list-index"`);
+      let html = "";
+      for (let i = 0; i < items.length; i++) {
+        const value = allItems[i] ? allItems[i].textContent : i + 1;
+        html += `
+          <div class="monitor_list-row_okCNn" style="height: 24px; left: 0px; position: absolute; top: ${i * 24}px; width: 100%;">
+            <div class="monitor_list-index_7tKdl">${value}</div>
+            <div class="monitor_list-value_1zGfI" dataindex="${i}" style="background: rgb(252, 102, 44);">
+              <div class="monitor_value-inner_3E9Ou">${items[i]}</div>
+            </div>
+          </div>`;
+      }
+      return [html, items.length];
+    }
+
+    isShowing(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return false;
+      list = runtime.getMonitorState().get(args.LIST);
+      if (!list) return false;
+      return list.visible;
+    }
+
+    listExists(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      return Scratch.Cast.toBoolean(list);
+    }
+
+    stretchList(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      args.WIDTH = Scratch.Cast.toNumber(args.WIDTH), args.HEIGHT = Scratch.Cast.toNumber(args.HEIGHT);
+      args.WIDTH = args.WIDTH < 1 || args.WIDTH === Infinity ? 100 : args.WIDTH;
+      args.HEIGHT = args.HEIGHT < 1 || args.HEIGHT === Infinity ? 200 : args.HEIGHT;
+
+      runtime.requestUpdateMonitor(new Map([
+        ["id", list.match(/"([^"]+)"/)[1]],
+        ["width", args.WIDTH],
+        ["height", args.HEIGHT]
+      ]));
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      if (list.classList.contains("blocklyDraggable")) return;
+      list = list.querySelector(`[class^="monitor_list-monitor"]`);
+      list.style.cssText = `width: ${args.WIDTH}px; height: ${args.HEIGHT}px;`;
+      let items = list.querySelector(".ReactVirtualized__Grid.ReactVirtualized__List");
+      if (items) items.style.cssText = `width: ${args.WIDTH}px;`;
+      items = list.querySelector(".ReactVirtualized__Grid__innerScrollContainer");
+      if (items) items.style.cssText = `width: auto; height: ${Scratch.vm.runtime.stageHeight}px; max-width: ${args.WIDTH}px; max-height: ${Scratch.vm.runtime.stageHeight}px; overflow: hidden; position: relative;`;
+      this.renderList({"LIST":args.LIST, "NUM": this.getColumns(args, util)}, util);
+    }
+
+    getAtt(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return "";
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      if (list.classList.contains("blocklyDraggable")) return "";
+      list = list.querySelector(`[class^="monitor_list-monitor"]`);
+      let value;
+      if (args.THING === "width") {
+        value = parseInt(list.style.width, 10);
+      } else {
+        value = parseInt(list.style.height, 10);
+      }
+      return value;
+    }
+
+    chooseOption(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      if (args.THING === "click events") {
+        list.style.pointerEvents = args.ON_OFF === "off" ? "none" : "auto";
+      } else if (args.THING === "text highlighting") {
+        const items = list.querySelectorAll(`[class^="monitor_value-inner"]`);
+        items.forEach(item => {
+          item.style.userSelect = args.ON_OFF === "off" ? "none " : "auto";
+          item.style.webkitUserSelect = args.ON_OFF === "off" ? "none" : "auto"; //apple devices need this for some reason
+        });
+      } else if (args.THING === "numbered items") {
+        const numberedItems = list.querySelectorAll(`[class^="monitor_list-index"]`);
+        numberedItems.forEach(item => {
+          item.style.display = args.ON_OFF === "off" ? "none" : "block";
+        });
+      } else {
+        let button1 = list.querySelector(`[class^="monitor_add-button"]`);
+        let button2 = list.querySelector(`[class^="monitor_resize-handle"]`);
+        if (button1 === null || button2 === null) {
+          const buttons = list.querySelectorAll(".no-drag");
+          buttons.forEach(button => {
+            button.style.display = args.ON_OFF === "off" ? "none" : "block";
+          });
+        } else {
+          button1.style.display = args.ON_OFF === "off" ? "none" : "block";
+          button2.style.display = args.ON_OFF === "off" ? "none" : "block";
+        }
+        let text = list.querySelector(`[class^="monitor_footer-length_2"]`);
+        text.style.margin = "0 auto";
+      }
+    }
+
+    formatItems(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      list = list.querySelector(".ReactVirtualized__Grid__innerScrollContainer");
+      if (list === null) return;
+      const items = Array.from(list.querySelectorAll(`[class^="monitor_list-value"]`));
+      function reorder() {
+        for (let i = 0; i < items.length; i++) {
+          items[i].style.textAlign = args.ALIGN;
+        }
+      }
+      reorder();
+    }
+
+    setPosition(args, util) {
+      const canvas = [Scratch.vm.runtime.stageWidth / 2, Scratch.vm.runtime.stageHeight / 2];
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      if (list.classList.contains("blocklyDraggable")) return;
+
+      const box = list.querySelector(`[class^="monitor_list-monitor"]`);
+      const sizeOffset = [parseInt(box.style.width, 10), parseInt(box.style.height, 10)];
+      let x = Scratch.Cast.toNumber(args.x) + canvas[0] - (sizeOffset[0] / 2);
+      let y = (Scratch.Cast.toNumber(args.y) - canvas[1] + (sizeOffset[1] / 2)) * -1;
+
+      let styleAttribute = list.getAttribute("style");
+      const transformRegex = /transform:([^;]+); top:([^;]+); left:([^;]+);/;
+      const transformMatch = styleAttribute.match(transformRegex);
+      if (transformMatch) {
+        const updatedTransform = transformMatch[1].replace(/translate\([^)]+\)/, `translate(${x}px, ${y}px)`);
+        styleAttribute = styleAttribute.replace(transformRegex, `transform:${updatedTransform}; top: 5; left: 5;`);
+        list.setAttribute("style", styleAttribute);
+      }
+    }
+
+    currentPos(args, util) {
+      const canvas = [Scratch.vm.runtime.stageWidth / 2, Scratch.vm.runtime.stageHeight / 2];
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return "";
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      if (list.classList.contains("blocklyDraggable")) return "";
+
+      const box = list.querySelector(`[class^="monitor_list-monitor"]`);
+      const sizeOffset = [parseInt(box.style.width, 10), parseInt(box.style.height, 10)];
+      const styleAttribute = list.getAttribute("style");
+      if (styleAttribute) {
+        const match = styleAttribute.match(/transform\s*:\s*translate\((-?\d+(?:\.\d+)?px),\s*(-?\d+(?:\.\d+)?px)\)/);
+        if (match) {
+          if (args.POSITION === "x") {
+            return parseInt(match[1]) - canvas[0] + (sizeOffset[0] / 2);
+          } else {
+            return ((parseInt(match[2]) * -1) + canvas[1]) - (sizeOffset[1] / 2);
+          }
+        }
+      }
+      return "";
+    }
+
+    setScroll(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      list = document.querySelector(`[data-id=${list}] .ReactVirtualized__Grid.ReactVirtualized__List`);
+      if (list === null) return;
+      const inner = list.querySelector(".ReactVirtualized__Grid__innerScrollContainer");
+      const scroll = (args.SCROLL / 100) * (list.scrollHeight - list.clientHeight);
+      list.scrollTop = scroll;
+    }
+
+    resetAll(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      list = list.match(/"([^"]+)"/)[1];
+      this.changeMonitorVisibility(list, false);
+      setTimeout(() => {
+        this.changeMonitorVisibility(list, true);
+      }, 25);
+    }
+
+    changeMonitorVisibility(id, visible) {
+      runtime.monitorBlocks.changeBlock({
+        id: id,
+        element: "checkbox",
+        value: visible
+      }, runtime);
+    }
+
+    setDisplay(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      let label;
+      if (args.DISPLAY === "header") {
+        label = document.querySelector(`[data-id=${list}] [class*="monitor_"][class^="monitor_list-header"]`);
+      } else {
+        label = document.querySelector(`[data-id=${list}] [class*="monitor_"][class^="monitor_footer-length_2"] span`);
+      }
+      if (label) label.textContent = args.NAME;
+    }
+
+    resetEffects(list, currentTransform) {
+      const translationRegex = /translate\(([^,]+),\s*([^)]+)\)/;
+      const matches = currentTransform.match(translationRegex);
+      let translation = matches ? `translate(${matches[1]}, ${matches[2]})` : "";
+      translation = translation.replace(/scale\([^,]+,\s*[^)]+\)/g, "scale(1)");
+      list.style.filter = "";
+      list.style.transform = translation;
+    }
+
+    setEffect(args, util) {
+      this.listEffect(args.LIST, args.EFFECT, args.AMOUNT, util);
+    }
+
+    listEffect(LIST, EFFECT, AMOUNT, util) {
+      let list = this.lookForList(LIST, util);
+      if (!list) return;
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      let currentTransform = list.style.transform || "";
+      let currentFilterEffect = list.style.filter || "";
+      let setEffect = EFFECT;
+      let amountIn = AMOUNT;
+      if (setEffect === "saturation") {
+        setEffect = "saturate";
+      } else if (setEffect === "hue") {
+        setEffect = "hue-rotate";
+      } else if (setEffect === "direction") {
+        setEffect = "rotate";
+        amountIn = AMOUNT - 90;
+      } else if (setEffect === "brightness") {
+        amountIn = AMOUNT + 100;
+      } else if (setEffect === "skew x") {
+        setEffect = "skewX";
+      } else if (setEffect === "skew y") {
+        setEffect = "skewY";
+      }
+      const regex = new RegExp(`${setEffect}\\([^)]+\\)`, "g");
+      currentTransform = currentTransform.replace(regex, "").trim();
+      currentFilterEffect = currentFilterEffect.replace(regex, "").trim();
+      if (setEffect === "rotate" || setEffect.includes("skew")) {
+        currentTransform += ` ${setEffect}(${amountIn}deg)`;
+        list.style.transform = currentTransform.trim();
+      } else {
+        currentFilterEffect += ` ${setEffect}(${amountIn}${setEffect === "blur" ? "px" : setEffect === "hue-rotate" ? "deg" : "%"})`;
+        list.style.filter = currentFilterEffect.trim();
+      }
+    }
+
+    stretchEffect(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      if (list.classList.contains("blocklyDraggable")) return;
+      let existingTransform = list.style.transform || "";
+      existingTransform = existingTransform.replace(/scale\([^)]*\)/g, "");
+      list.style.transform = `${existingTransform} scale(${args.x / 100}, ${args.y / 100})`;
+    }
+
+    currentEffect(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return "";
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      const currentTransform = list.style.transform || "";
+      const currentFilterEffect = list.style.filter || "";
+      const setEffect = {
+        saturation: "saturate",
+        hue: "hue-rotate",
+        direction: "rotate",
+        "scale x": "scale",
+        "scale y": "scale",
+        brightness: "brightness",
+        opacity: "opacity",
+        "skew x": "skewX",
+        "skew y": "skewY",
+      }[args.EFFECT] || args.EFFECT;
+      const defaultV = {
+        saturation: 100,
+        hue: 0,
+        direction: 90,
+        "scale x": 100,
+        "scale y": 100,
+        brightness: 0,
+        opacity: 100,
+      }[args.EFFECT] || 0;
+
+      const regex = new RegExp(`${setEffect}\\(([^)]+)\\)`);
+      const transformMatch = currentTransform.match(regex);
+      const filterMatch = currentFilterEffect.match(regex);
+      if (filterMatch || transformMatch) {
+        const valueWithUnits = (filterMatch || transformMatch)[1];
+        const numericValue = parseFloat(valueWithUnits.replace(/[^0-9.-]/g, ""));
+        if (setEffect === "brightness") {
+          return numericValue - 100;
+        } else if (setEffect === "rotate") {
+          return numericValue + 90;
+        } else if (setEffect === "scale") {
+          const arr = valueWithUnits.split(", ");
+          return arr[args.EFFECT.includes("x") ? 0 : 1] * 100;
+        } else {
+          return numericValue;
+        }
+      } else {
+        return defaultV;
+      }
+    }
+
+    resetEffect(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      let currentTransform = list.style.transform || "";
+      this.resetEffects(list, currentTransform);
+    }
+
+    setFont(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      list.style.fontFamily = args.FONT;
+    }
+
+    setColor(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      args.NUM = Math.abs(args.NUM);
+      if (!args.COLOR.includes("gradient")) {
+        args.COLOR = args.COLOR.replace(/^#/, "");
+        const bigint = parseInt(args.COLOR, 16);
+        args.COLOR = `rgb(${(bigint >> 16) & 255}, ${(bigint >> 8) & 255}, ${bigint & 255})`;
+      }
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      const targetElement = list.querySelector(`[class^="monitor_list-monitor"] [class^="monitor_list-value"][dataindex="${args.NUM - 1}"]`);
+      if (targetElement) {
+        targetElement.style.background = args.COLOR;
+      }
+    }
+
+    setLabel(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (!list) return;
+      args.NUM = Math.abs(args.NUM);
+      list = document.querySelectorAll(`[data-id=${list}]`);
+      list = list[list.length - 1];
+      const targetElement = list.querySelectorAll(`[class^="monitor_list-index"`)[args.NUM - 1];
+      if (targetElement) {
+        targetElement.textContent = args.VALUE;
+      }
+    }
+
+    makeList(args, util) {
+      let list = this.lookForList(args.LIST, util);
+      if (list) return;
+      if (args.TYPE === "for this sprite only") {
+        //creating this kind of list doesnt show until you switch back from editing a sprite to another for some reason...
+        return util.target.createVariable(this.generateId(), args.LIST, "list");
+      } else {
+        Blockly.getMainWorkspace().createVariable(args.LIST, "list");
+      }
+    }
+
+    generateId() {
+      const chars = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "/", "|", ",", ".", "{", "}", "[", "]", "(", ")", "+", "-", "!", "?", "`"];
+      const array = Array.from(Array(20).keys());
+      const normalArray = array.map(() => {
+        return chars[Math.round(Math.random() * (chars.length - 1))]
+      })
+      return normalArray.join("");
+    }
+  }
+
+  Scratch.extensions.register(new SPlistMonitors());
+})(Scratch);

From dd86035649b303145ab2ef067e533bc37e1d508f Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sun, 5 Nov 2023 21:49:18 -0800
Subject: [PATCH 02/13] Create Sty-Lists.svg

---
 images/SharkPool/Sty-Lists.svg | 84 ++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 images/SharkPool/Sty-Lists.svg

diff --git a/images/SharkPool/Sty-Lists.svg b/images/SharkPool/Sty-Lists.svg
new file mode 100644
index 0000000000..011790a1c5
--- /dev/null
+++ b/images/SharkPool/Sty-Lists.svg
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="600px" height="300px" viewBox="0 0 600 300" version="1.1">
+<g id="surface1">
+<rect x="0" y="0" width="600" height="300" style="fill:rgb(100%,40%,10.196078%);fill-opacity:1;stroke:none;"/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 26.796875 72.695312 C 20.25 72.695312 14.941406 67.402344 14.941406 60.875 L 14.941406 32.316406 C 14.941406 25.789062 20.25 20.5 26.796875 20.5 L 55.453125 20.5 C 62 20.5 67.308594 25.789062 67.308594 32.316406 L 67.308594 60.875 C 67.308594 67.402344 62 72.695312 55.453125 72.695312 Z M 26.796875 72.695312 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 94.976562 72.695312 C 88.425781 72.695312 83.117188 67.402344 83.117188 60.875 L 83.117188 32.316406 C 83.117188 25.789062 88.425781 20.5 94.976562 20.5 L 182.914062 20.5 C 189.464844 20.5 194.773438 25.789062 194.773438 32.316406 L 194.773438 60.875 C 194.773438 67.402344 189.464844 72.695312 182.914062 72.695312 Z M 94.976562 72.695312 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 26.796875 141.628906 C 20.25 141.628906 14.941406 136.339844 14.941406 129.8125 L 14.941406 101.253906 C 14.941406 94.726562 20.25 89.433594 26.796875 89.433594 L 55.453125 89.433594 C 62 89.433594 67.308594 94.726562 67.308594 101.253906 L 67.308594 129.8125 C 67.308594 136.339844 62 141.628906 55.453125 141.628906 Z M 26.796875 141.628906 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 94.976562 141.628906 C 88.425781 141.628906 83.117188 136.339844 83.117188 129.8125 L 83.117188 101.253906 C 83.117188 94.726562 88.425781 89.433594 94.976562 89.433594 L 182.914062 89.433594 C 189.464844 89.433594 194.773438 94.726562 194.773438 101.253906 L 194.773438 129.8125 C 194.773438 136.339844 189.464844 141.628906 182.914062 141.628906 Z M 94.976562 141.628906 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 26.796875 210.566406 C 20.25 210.566406 14.941406 205.273438 14.941406 198.746094 L 14.941406 170.1875 C 14.941406 163.660156 20.25 158.371094 26.796875 158.371094 L 55.453125 158.371094 C 62 158.371094 67.308594 163.660156 67.308594 170.1875 L 67.308594 198.746094 C 67.308594 205.273438 62 210.566406 55.453125 210.566406 Z M 26.796875 210.566406 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 94.976562 210.566406 C 88.425781 210.566406 83.117188 205.273438 83.117188 198.746094 L 83.117188 170.1875 C 83.117188 163.660156 88.425781 158.371094 94.976562 158.371094 L 182.914062 158.371094 C 189.464844 158.371094 194.773438 163.660156 194.773438 170.1875 L 194.773438 198.746094 C 194.773438 205.273438 189.464844 210.566406 182.914062 210.566406 Z M 94.976562 210.566406 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 26.796875 279.5 C 20.25 279.5 14.941406 274.210938 14.941406 267.683594 L 14.941406 239.125 C 14.941406 232.597656 20.25 227.304688 26.796875 227.304688 L 55.453125 227.304688 C 62 227.304688 67.308594 232.597656 67.308594 239.125 L 67.308594 267.683594 C 67.308594 274.210938 62 279.5 55.453125 279.5 Z M 26.796875 279.5 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 94.976562 279.5 C 88.425781 279.5 83.117188 274.210938 83.117188 267.683594 L 83.117188 239.125 C 83.117188 232.597656 88.425781 227.304688 94.976562 227.304688 L 182.914062 227.304688 C 189.464844 227.304688 194.773438 232.597656 194.773438 239.125 L 194.773438 267.683594 C 194.773438 274.210938 189.464844 279.5 182.914062 279.5 Z M 94.976562 279.5 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 222.4375 72.695312 C 215.890625 72.695312 210.582031 67.402344 210.582031 60.875 L 210.582031 32.316406 C 210.582031 25.789062 215.890625 20.5 222.4375 20.5 L 251.09375 20.5 C 257.640625 20.5 262.949219 25.789062 262.949219 32.316406 L 262.949219 60.875 C 262.949219 67.402344 257.640625 72.695312 251.09375 72.695312 Z M 222.4375 72.695312 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 290.617188 72.695312 C 284.066406 72.695312 278.757812 67.402344 278.757812 60.875 L 278.757812 32.316406 C 278.757812 25.789062 284.066406 20.5 290.617188 20.5 L 378.554688 20.5 C 385.105469 20.5 390.414062 25.789062 390.414062 32.316406 L 390.414062 60.875 C 390.414062 67.402344 385.105469 72.695312 378.554688 72.695312 Z M 290.617188 72.695312 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(80%,27.45098%,0.784314%);fill-opacity:1;" d="M 222.4375 141.628906 C 215.890625 141.628906 210.582031 136.339844 210.582031 129.8125 L 210.582031 101.253906 C 210.582031 94.726562 215.890625 89.433594 222.4375 89.433594 L 251.09375 89.433594 C 257.640625 89.433594 262.949219 94.726562 262.949219 101.253906 L 262.949219 129.8125 C 262.949219 136.339844 257.640625 141.628906 251.09375 141.628906 Z M 222.4375 141.628906 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(80%,27.45098%,0.784314%);fill-opacity:1;" d="M 290.617188 141.628906 C 284.066406 141.628906 278.757812 136.339844 278.757812 129.8125 L 278.757812 101.253906 C 278.757812 94.726562 284.066406 89.433594 290.617188 89.433594 L 378.554688 89.433594 C 385.105469 89.433594 390.414062 94.726562 390.414062 101.253906 L 390.414062 129.8125 C 390.414062 136.339844 385.105469 141.628906 378.554688 141.628906 Z M 290.617188 141.628906 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 222.4375 210.566406 C 215.890625 210.566406 210.582031 205.273438 210.582031 198.746094 L 210.582031 170.1875 C 210.582031 163.660156 215.890625 158.371094 222.4375 158.371094 L 251.09375 158.371094 C 257.640625 158.371094 262.949219 163.660156 262.949219 170.1875 L 262.949219 198.746094 C 262.949219 205.273438 257.640625 210.566406 251.09375 210.566406 Z M 222.4375 210.566406 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 290.617188 210.566406 C 284.066406 210.566406 278.757812 205.273438 278.757812 198.746094 L 278.757812 170.1875 C 278.757812 163.660156 284.066406 158.371094 290.617188 158.371094 L 378.554688 158.371094 C 385.105469 158.371094 390.414062 163.660156 390.414062 170.1875 L 390.414062 198.746094 C 390.414062 205.273438 385.105469 210.566406 378.554688 210.566406 Z M 290.617188 210.566406 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 222.4375 279.5 C 215.890625 279.5 210.582031 274.210938 210.582031 267.683594 L 210.582031 239.125 C 210.582031 232.597656 215.890625 227.304688 222.4375 227.304688 L 251.09375 227.304688 C 257.640625 227.304688 262.949219 232.597656 262.949219 239.125 L 262.949219 267.683594 C 262.949219 274.210938 257.640625 279.5 251.09375 279.5 Z M 222.4375 279.5 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 290.617188 279.5 C 284.066406 279.5 278.757812 274.210938 278.757812 267.683594 L 278.757812 239.125 C 278.757812 232.597656 284.066406 227.304688 290.617188 227.304688 L 378.554688 227.304688 C 385.105469 227.304688 390.414062 232.597656 390.414062 239.125 L 390.414062 267.683594 C 390.414062 274.210938 385.105469 279.5 378.554688 279.5 Z M 290.617188 279.5 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 418.078125 72.695312 C 411.53125 72.695312 406.222656 67.402344 406.222656 60.875 L 406.222656 32.316406 C 406.222656 25.789062 411.53125 20.5 418.078125 20.5 L 446.734375 20.5 C 453.28125 20.5 458.589844 25.789062 458.589844 32.316406 L 458.589844 60.875 C 458.589844 67.402344 453.28125 72.695312 446.734375 72.695312 Z M 418.078125 72.695312 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 486.257812 72.695312 C 479.707031 72.695312 474.398438 67.402344 474.398438 60.875 L 474.398438 32.316406 C 474.398438 25.789062 479.707031 20.5 486.257812 20.5 L 574.195312 20.5 C 580.746094 20.5 586.054688 25.789062 586.054688 32.316406 L 586.054688 60.875 C 586.054688 67.402344 580.746094 72.695312 574.195312 72.695312 Z M 486.257812 72.695312 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 418.078125 141.628906 C 411.53125 141.628906 406.222656 136.339844 406.222656 129.8125 L 406.222656 101.253906 C 406.222656 94.726562 411.53125 89.433594 418.078125 89.433594 L 446.734375 89.433594 C 453.28125 89.433594 458.589844 94.726562 458.589844 101.253906 L 458.589844 129.8125 C 458.589844 136.339844 453.28125 141.628906 446.734375 141.628906 Z M 418.078125 141.628906 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 486.257812 141.628906 C 479.707031 141.628906 474.398438 136.339844 474.398438 129.8125 L 474.398438 101.253906 C 474.398438 94.726562 479.707031 89.433594 486.257812 89.433594 L 574.195312 89.433594 C 580.746094 89.433594 586.054688 94.726562 586.054688 101.253906 L 586.054688 129.8125 C 586.054688 136.339844 580.746094 141.628906 574.195312 141.628906 Z M 486.257812 141.628906 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 418.078125 210.566406 C 411.53125 210.566406 406.222656 205.273438 406.222656 198.746094 L 406.222656 170.1875 C 406.222656 163.660156 411.53125 158.371094 418.078125 158.371094 L 446.734375 158.371094 C 453.28125 158.371094 458.589844 163.660156 458.589844 170.1875 L 458.589844 198.746094 C 458.589844 205.273438 453.28125 210.566406 446.734375 210.566406 Z M 418.078125 210.566406 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 486.257812 210.566406 C 479.707031 210.566406 474.398438 205.273438 474.398438 198.746094 L 474.398438 170.1875 C 474.398438 163.660156 479.707031 158.371094 486.257812 158.371094 L 574.195312 158.371094 C 580.746094 158.371094 586.054688 163.660156 586.054688 170.1875 L 586.054688 198.746094 C 586.054688 205.273438 580.746094 210.566406 574.195312 210.566406 Z M 486.257812 210.566406 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 418.078125 279.5 C 411.53125 279.5 406.222656 274.210938 406.222656 267.683594 L 406.222656 239.125 C 406.222656 232.597656 411.53125 227.304688 418.078125 227.304688 L 446.734375 227.304688 C 453.28125 227.304688 458.589844 232.597656 458.589844 239.125 L 458.589844 267.683594 C 458.589844 274.210938 453.28125 279.5 446.734375 279.5 Z M 418.078125 279.5 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.588235%,30.588235%,0.784314%);fill-opacity:1;" d="M 486.257812 279.5 C 479.707031 279.5 474.398438 274.210938 474.398438 267.683594 L 474.398438 239.125 C 474.398438 232.597656 479.707031 227.304688 486.257812 227.304688 L 574.195312 227.304688 C 580.746094 227.304688 586.054688 232.597656 586.054688 239.125 L 586.054688 267.683594 C 586.054688 274.210938 580.746094 279.5 574.195312 279.5 Z M 486.257812 279.5 "/>
+<path style="fill:none;stroke-width:7.5;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(0%,0%,0%);stroke-opacity:0.501961;stroke-miterlimit:10;" d="M 311.597861 118.955078 C 311.660153 119.275391 311.775003 197.248047 311.667939 197.830078 C 311.50637 198.701172 311.292243 199.289062 310.466878 199.351562 C 309.773883 199.404297 171.315081 199.675781 170.423532 199.626953 C 169.565075 199.580078 168.274469 198.822266 168.264736 197.939453 C 168.255003 197.130859 168.145993 120.117188 168.336761 119.267578 C 168.478864 118.628906 169.419078 118.232422 169.650726 118.201172 C 169.868746 118.169922 204.559365 118.130859 246.717197 118.146484 C 293.552744 118.158203 306.41792 117.925781 309.89652 118.011719 C 311.004144 118.041016 311.535569 118.634766 311.597861 118.955078 Z M 311.597861 118.955078 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(90.980392%,94.117647%,99.215686%);fill-opacity:1;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(79.215686%,81.960784%,86.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 311.535569 119.492188 C 311.654313 125.537109 311.667939 198.535156 311.667939 198.535156 L 310.780283 199.470703 L 246.421312 199.478516 L 169.325641 199.470703 L 168.422412 198.566406 L 168.416572 183.638672 L 168.422412 119.181641 C 168.422412 119.181641 169.419078 118.232422 169.650726 118.201172 C 169.868746 118.169922 204.559365 118.130859 246.717197 118.146484 C 294.757698 118.158203 306.78583 118.183594 309.89068 118.277344 C 310.77639 118.302734 311.527783 119.099609 311.535569 119.492188 Z M 311.535569 119.492188 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(79.215686%,81.960784%,86.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 310.912653 187.53125 C 311.113154 187.541016 311.331175 187.5625 311.424612 187.578125 C 311.564769 187.603516 311.593968 198.488281 311.593968 198.488281 C 311.593968 198.488281 310.998304 199.384766 310.488291 199.394531 C 305.617861 199.480469 246.329821 199.898438 246.329821 199.898438 L 169.226364 199.640625 L 168.418519 198.660156 L 168.325081 193.699219 L 168.325081 187.607422 L 168.729977 187.5625 C 168.963571 187.539062 169.319801 187.517578 169.553395 187.515625 C 169.771416 187.511719 204.469821 187.486328 246.627653 187.488281 C 308.362588 187.490234 310.63234 187.515625 310.912653 187.53125 Z M 310.912653 187.53125 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(79.215686%,81.960784%,86.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 246.627653 130.505859 C 204.469821 130.505859 169.771416 130.482422 169.553395 130.478516 C 169.319801 130.476562 168.963571 130.453125 168.729977 130.429688 L 168.325081 130.386719 L 168.325081 124.294922 L 168.418519 119.333984 L 169.226364 118.351562 L 246.329821 118.095703 C 246.329821 118.095703 305.368694 118.261719 310.239124 118.349609 C 310.74719 118.357422 311.593968 119.503906 311.593968 119.503906 C 311.593968 119.503906 311.564769 130.390625 311.424612 130.416016 C 311.331175 130.431641 311.113154 130.453125 310.912653 130.462891 C 310.63234 130.478516 308.362588 130.503906 246.627653 130.505859 Z M 246.627653 130.505859 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 277.246094 172.953125 C 277.277344 172.921875 277.308594 175.132812 277.308594 177.871094 L 277.308594 182.851562 L 275.121094 182.851562 L 275.121094 173.234375 L 276.152344 173.109375 C 276.683594 173.046875 277.183594 172.953125 277.246094 172.953125 Z M 277.246094 172.953125 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 308.753906 173.171875 C 309.566406 173.390625 309.597656 173.484375 309.503906 175.070312 L 309.410156 176.722656 L 310.222656 176.222656 C 310.660156 175.941406 311.503906 175.695312 312.09375 175.695312 C 313.71875 175.695312 314.25 176.691406 314.40625 180.082031 L 314.53125 182.851562 L 312.28125 182.851562 L 312.28125 180.488281 C 312.28125 177.996094 311.9375 177.25 310.785156 177.25 C 309.910156 177.25 309.410156 178.742188 309.535156 180.953125 L 309.628906 182.851562 L 307.660156 182.851562 L 307.660156 178.402344 C 307.660156 175.972656 307.722656 173.765625 307.785156 173.453125 C 307.910156 173.078125 308.128906 173.015625 308.753906 173.171875 Z M 308.753906 173.171875 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 304.476562 173.765625 C 305.257812 173.886719 305.414062 174.042969 305.414062 174.792969 C 305.414062 175.476562 305.570312 175.695312 306.039062 175.695312 C 306.503906 175.695312 306.660156 175.910156 306.660156 176.472656 C 306.660156 177.03125 306.503906 177.25 306.039062 177.25 C 305.476562 177.25 305.414062 177.46875 305.414062 179.273438 C 305.414062 181.078125 305.476562 181.296875 306.039062 181.296875 C 306.503906 181.296875 306.660156 181.515625 306.660156 182.074219 C 306.660156 182.789062 306.535156 182.851562 305.382812 182.851562 C 303.539062 182.851562 303.226562 182.386719 303.226562 179.617188 C 303.226562 177.71875 303.132812 177.25 302.757812 177.25 C 302.476562 177.25 302.289062 176.96875 302.289062 176.472656 C 302.289062 175.972656 302.476562 175.695312 302.757812 175.695312 C 303.070312 175.695312 303.226562 175.382812 303.226562 174.820312 C 303.226562 174.324219 303.289062 173.855469 303.382812 173.765625 C 303.476562 173.703125 303.945312 173.671875 304.476562 173.765625 Z M 304.476562 173.765625 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 164.332031 175.257812 C 164.988281 175.382812 165.113281 175.632812 165.207031 176.722656 C 165.300781 177.996094 165.300781 177.996094 166.425781 177.902344 C 167.425781 177.808594 167.582031 177.902344 167.707031 178.589844 C 167.894531 179.460938 167.800781 179.492188 166.175781 179.398438 C 165.144531 179.335938 165.144531 179.367188 165.144531 180.765625 C 165.144531 182.136719 165.113281 182.199219 164.273438 182.199219 C 163.460938 182.199219 163.429688 182.136719 163.554688 180.765625 L 163.648438 179.335938 L 162.210938 179.429688 C 160.835938 179.554688 160.773438 179.523438 160.773438 178.710938 C 160.773438 177.871094 160.835938 177.839844 162.210938 177.839844 C 163.617188 177.839844 163.648438 177.839844 163.585938 176.8125 C 163.554688 176.285156 163.523438 175.664062 163.554688 175.476562 C 163.585938 175.289062 163.929688 175.195312 164.332031 175.257812 Z M 164.332031 175.257812 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 285.082031 178.058594 C 285.582031 179.863281 285.363281 180.050781 282.585938 180.050781 C 281.242188 180.050781 280.117188 180.144531 280.117188 180.238281 C 280.117188 181.078125 282.648438 181.699219 283.085938 180.984375 C 283.179688 180.796875 283.769531 180.671875 284.363281 180.671875 C 284.957031 180.671875 285.425781 180.796875 285.425781 180.984375 C 285.425781 181.140625 285.300781 181.296875 285.113281 181.296875 C 284.957031 181.296875 284.800781 181.453125 284.800781 181.636719 C 284.800781 182.355469 283.675781 182.820312 281.960938 182.851562 C 280.492188 182.851562 280.085938 182.726562 279.398438 182.074219 C 278.023438 180.703125 278.085938 178.058594 279.523438 176.628906 C 281.304688 174.851562 284.425781 175.664062 285.082031 178.058594 Z M 280.523438 177.71875 C 279.898438 178.402344 280.023438 178.496094 281.679688 178.496094 C 283.273438 178.496094 283.554688 178.308594 282.867188 177.625 C 282.367188 177.125 280.992188 177.15625 280.523438 177.71875 Z M 280.523438 177.71875 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 286.363281 175.695312 L 287.238281 175.695312 C 287.707031 175.695312 288.269531 175.847656 288.488281 176.066406 C 288.769531 176.347656 288.957031 176.347656 289.234375 176.066406 C 289.859375 175.445312 291.703125 175.632812 292.515625 176.378906 C 293.171875 176.96875 293.234375 177.3125 293.234375 179.957031 L 293.234375 182.851562 L 290.890625 182.851562 L 290.984375 180.519531 C 291.109375 178.121094 290.796875 177.25 289.890625 177.25 C 288.832031 177.25 288.488281 178.121094 288.613281 180.519531 L 288.707031 182.851562 L 286.363281 182.851562 Z M 286.363281 175.695312 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 297.199219 175.695312 C 297.855469 175.695312 298.605469 175.878906 298.824219 176.066406 C 299.167969 176.378906 299.261719 176.378906 299.386719 176.066406 C 299.480469 175.878906 299.886719 175.695312 300.292969 175.695312 L 301.039062 175.695312 L 301.039062 179.832031 C 301.039062 183.753906 301.007812 184.035156 300.355469 184.625 C 299.480469 185.40625 297.949219 185.777344 296.699219 185.496094 C 295.699219 185.28125 294.078125 183.878906 294.265625 183.351562 C 294.453125 182.820312 296.167969 182.976562 296.605469 183.535156 C 296.824219 183.847656 297.386719 184.097656 297.855469 184.097656 C 298.480469 184.097656 298.792969 183.878906 299.105469 183.164062 C 299.511719 182.292969 299.324219 181.203125 298.886719 181.824219 C 298.074219 183.070312 295.261719 182.601562 294.578125 181.078125 C 293.859375 179.554688 294.078125 177.746094 295.074219 176.660156 C 295.792969 175.910156 296.230469 175.695312 297.199219 175.695312 Z M 296.355469 178.652344 C 296.199219 180.019531 296.386719 180.582031 297.136719 180.984375 C 297.886719 181.390625 298.011719 181.359375 298.699219 180.582031 C 299.605469 179.617188 299.667969 179.054688 298.980469 178.027344 C 298.136719 176.722656 296.511719 177.125 296.355469 178.652344 Z M 296.355469 178.652344 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 432.054688 176.597656 L 435.644531 176.597656 L 435.550781 177.40625 L 435.460938 178.214844 L 432.054688 178.214844 C 429.277344 178.214844 428.589844 178.121094 428.371094 177.714844 C 428.214844 177.4375 428.183594 177.0625 428.277344 176.90625 C 428.402344 176.722656 430.023438 176.597656 432.054688 176.597656 Z M 432.054688 176.597656 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 432.054688 179.398438 L 435.644531 179.398438 L 435.550781 180.238281 L 435.460938 181.109375 L 432.492188 181.203125 C 428.777344 181.328125 428.214844 181.171875 428.308594 180.269531 C 428.339844 179.863281 428.402344 179.523438 428.402344 179.460938 C 428.433594 179.429688 430.054688 179.398438 432.054688 179.398438 Z M 432.054688 179.398438 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 169.683594 62.160156 L 170.714844 62.160156 L 170.621094 66.890625 L 170.527344 71.652344 L 169.527344 71.746094 L 168.5 71.839844 L 168.5 65.585938 L 167.21875 65.585938 C 166.03125 65.585938 165.96875 65.554688 166.0625 64.746094 C 166.125 64.058594 166.34375 63.84375 167.09375 63.71875 C 167.65625 63.625 168.15625 63.28125 168.34375 62.847656 C 168.5625 62.347656 168.902344 62.160156 169.683594 62.160156 Z M 169.683594 62.160156 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 168.964844 88.929688 C 169.839844 88.960938 170.777344 89.144531 171.121094 89.394531 C 171.746094 89.863281 172.558594 91.261719 172.558594 91.886719 C 172.558594 92.851562 171.464844 94.21875 169.902344 95.277344 C 168.964844 95.898438 168.1875 96.554688 168.1875 96.742188 C 168.1875 96.925781 168.964844 97.019531 170.308594 96.988281 C 172.371094 96.894531 172.402344 96.925781 172.496094 97.738281 L 172.589844 98.578125 L 168.84375 98.578125 C 165.40625 98.578125 164.46875 98.359375 165.375 97.796875 C 165.5625 97.707031 165.6875 97.363281 165.6875 97.050781 C 165.6875 96.742188 166.25 95.992188 166.96875 95.433594 C 170.058594 92.882812 170.402344 92.445312 170.089844 91.667969 C 169.902344 91.167969 169.558594 90.921875 168.902344 90.859375 C 168.03125 90.765625 167.9375 90.859375 167.75 91.855469 C 167.5625 92.851562 167.40625 92.972656 166.625 92.972656 C 165.78125 92.972656 165.6875 92.882812 165.6875 91.949219 C 165.6875 91.292969 166 90.578125 166.5625 89.925781 C 167.3125 89.050781 167.59375 88.929688 168.964844 88.929688 Z M 168.964844 88.929688 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 171.246094 116.597656 C 172.121094 117.34375 172.277344 119.929688 171.433594 120.113281 C 171.027344 120.175781 171.089844 120.363281 171.746094 121.078125 C 172.558594 121.949219 172.902344 123.789062 172.246094 123.789062 C 172.089844 123.789062 171.933594 124.003906 171.933594 124.285156 C 171.933594 124.566406 171.652344 124.847656 171.308594 124.9375 C 170.964844 125.03125 170.683594 125.21875 170.683594 125.375 C 170.683594 125.902344 167.28125 125.6875 166.59375 125.09375 C 166.09375 124.660156 165.0625 122.855469 165.0625 122.355469 C 165.0625 122.292969 165.625 122.230469 166.34375 122.230469 C 167.125 122.230469 167.53125 122.355469 167.40625 122.542969 C 167.0625 123.101562 167.875 123.789062 168.871094 123.789062 C 169.527344 123.789062 169.839844 123.601562 170.027344 123.070312 C 170.402344 122.105469 170.121094 121.640625 168.996094 121.359375 C 167.65625 121.015625 167.6875 120.019531 169.058594 119.679688 C 170.058594 119.429688 170.246094 119.027344 169.871094 118.0625 C 169.589844 117.34375 167.875 117.40625 167.875 118.121094 C 167.875 118.902344 167.28125 119.429688 166.40625 119.429688 C 165.8125 119.429688 165.6875 119.273438 165.6875 118.496094 C 165.6875 117.9375 165.96875 117.21875 166.40625 116.785156 C 167.3125 115.820312 170.152344 115.695312 171.246094 116.597656 Z M 171.246094 116.597656 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;" d="M 170.277344 142.773438 L 171.308594 142.773438 L 171.308594 145.730469 C 171.308594 148.40625 171.371094 148.71875 171.871094 148.625 C 172.246094 148.5625 172.433594 148.78125 172.496094 149.371094 C 172.589844 150.085938 172.464844 150.242188 171.964844 150.242188 C 171.433594 150.242188 171.308594 150.429688 171.308594 151.332031 C 171.308594 152.359375 171.246094 152.421875 170.214844 152.421875 C 169.183594 152.421875 169.121094 152.359375 169.121094 151.332031 L 169.121094 150.242188 L 165.0625 150.242188 L 165.0625 149.308594 C 165.0625 148.6875 165.375 148.035156 166 147.410156 C 166.5 146.882812 167 146.164062 167.09375 145.855469 C 167.21875 145.511719 167.375 145.261719 167.5 145.261719 C 167.625 145.261719 168.0625 144.703125 168.5 144.019531 C 169.152344 142.992188 169.433594 142.773438 170.277344 142.773438 Z M 168.964844 146.132812 C 168.5625 146.414062 167.25 148.25 167.25 148.53125 C 167.25 148.625 167.71875 148.6875 168.28125 148.625 C 169.121094 148.5625 169.246094 148.40625 169.183594 147.847656 C 169.121094 147.472656 169.246094 146.882812 169.433594 146.507812 C 169.777344 145.886719 169.558594 145.699219 168.964844 146.132812 Z M 168.964844 146.132812 "/>
+<path style="fill-rule:nonzero;fill:rgb(36.078431%,38.431373%,46.666667%);fill-opacity:1;stroke-width:0.2;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(34.509804%,36.862745%,45.098039%);stroke-opacity:1;stroke-miterlimit:10;" d="M 245.12292 136.759766 C 245.12292 137.041016 244.842607 137.181641 244.169078 137.181641 C 243.581201 137.181641 243.160732 137.349609 243.047828 137.601562 C 242.936871 137.9375 243.131533 138.021484 243.888766 138.021484 C 244.645999 138.021484 244.926312 138.162109 245.179371 138.722656 C 245.8529 140.208984 244.281982 141.583984 242.711064 140.853516 C 242.347047 140.685547 242.039482 140.376953 242.039482 140.125 C 242.039482 139.648438 242.740263 139.537109 243.020576 139.984375 C 243.300888 140.433594 244.198278 140.322266 244.394886 139.816406 C 244.702451 139.03125 244.028922 138.554688 242.991377 138.751953 C 242.039482 138.919922 242.039482 138.919922 242.206891 137.994141 C 242.290595 137.460938 242.403499 136.873047 242.487203 136.675781 C 242.62736 136.142578 245.12292 136.228516 245.12292 136.759766 Z M 245.12292 136.759766 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(36.078431%,38.431373%,46.666667%);fill-opacity:1;stroke-width:0.2;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(34.509804%,36.862745%,45.098039%);stroke-opacity:1;stroke-miterlimit:10;" d="M 244.842607 150.220703 C 245.34678 150.808594 244.955511 151.117188 244.25473 150.697266 C 243.805062 150.416016 243.581201 150.416016 243.271689 150.669922 C 242.62736 151.201172 242.796715 151.677734 243.664905 151.566406 C 244.702451 151.425781 245.206624 151.847656 245.206624 152.855469 C 245.206624 154.482422 243.74861 155.15625 242.600107 154.005859 C 241.899326 153.304688 241.842874 151.341797 242.487203 150.416016 C 242.991377 149.6875 244.309235 149.576172 244.842607 150.220703 Z M 243.160732 152.462891 C 242.711064 153.025391 242.991377 153.724609 243.694105 153.724609 C 244.338434 153.724609 244.591494 153.220703 244.22553 152.519531 C 243.917965 151.931641 243.608453 151.902344 243.160732 152.462891 Z M 243.160732 152.462891 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(36.078431%,38.431373%,46.666667%);fill-opacity:1;stroke-width:0.2;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(34.509804%,36.862745%,45.098039%);stroke-opacity:1;stroke-miterlimit:10;" d="M 243.581201 163.259766 C 245.37598 163.259766 245.432431 163.371094 244.422138 165.333984 C 244.028922 166.091797 243.721357 167.017578 243.721357 167.380859 C 243.721357 167.830078 243.553948 168.027344 243.187985 168.027344 C 242.740263 168.027344 242.683812 167.886719 242.85122 167.101562 C 242.991377 166.625 243.271689 165.810547 243.524749 165.306641 C 244.141826 164.101562 244.141826 164.101562 243.020576 164.101562 C 242.347047 164.101562 242.039482 163.960938 242.039482 163.679688 C 242.039482 163.34375 242.403499 163.259766 243.581201 163.259766 Z M 243.581201 163.259766 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(36.078431%,38.431373%,46.666667%);fill-opacity:1;stroke-width:0.2;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(34.509804%,36.862745%,45.098039%);stroke-opacity:1;stroke-miterlimit:10;" d="M 244.926312 178.373047 C 244.645999 178.794922 244.675198 178.990234 244.982763 179.244141 C 246.357073 180.392578 244.25473 182.076172 242.570908 181.207031 C 241.98303 180.869141 241.813675 179.412109 242.347047 179.074219 C 242.570908 178.962891 242.570908 178.822266 242.347047 178.597656 C 241.926578 178.177734 241.953831 177.673828 242.487203 177.140625 C 243.524749 176.103516 245.656292 177.195312 244.926312 178.373047 Z M 243.187985 177.533203 C 242.656559 177.869141 243.020576 178.738281 243.637653 178.626953 C 243.917965 178.570312 244.141826 178.289062 244.141826 178.009766 C 244.141826 177.392578 243.74861 177.195312 243.187985 177.533203 Z M 242.88042 180.113281 C 242.88042 180.757812 243.721357 181.037109 244.22553 180.533203 C 244.591494 180.197266 244.591494 180.029297 244.281982 179.691406 C 243.664905 178.935547 242.88042 179.1875 242.88042 180.113281 Z M 242.88042 180.113281 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(33.72549%,94.901961%,0.784314%);fill-opacity:1;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(20.392157%,57.254902%,0.392157%);stroke-opacity:1;stroke-miterlimit:10;" d="M 306.692392 159.416016 C 307.790283 160.173828 307.585888 160.126953 307.585888 165.337891 L 307.585888 169.990234 C 307.585888 169.990234 307.266644 170.693359 307.052516 170.908203 C 306.811136 171.148438 306.209632 171.367188 306.209632 171.367188 L 250.604586 171.367188 L 250.094573 171.011719 C 249.058974 170.314453 249.043401 170.238281 249.027828 165.306641 C 249.012256 161.054688 249.027828 160.853516 249.352913 160.25 C 249.524215 159.910156 249.894072 159.523438 250.156865 159.400391 C 250.557868 159.201172 297.973506 159.171875 305.503011 159.363281 C 305.676259 159.367188 306.692392 159.416016 306.692392 159.416016 Z M 306.692392 159.416016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(100%,40%,10.196078%);fill-opacity:1;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(80.392157%,32.156863%,7.843137%);stroke-opacity:1;stroke-miterlimit:10;" d="M 307.578102 178.798828 L 307.578102 183.451172 C 307.578102 183.451172 307.177099 184.236328 306.933773 184.482422 C 306.725485 184.689453 306.201845 184.828125 306.201845 184.828125 L 250.5968 184.828125 L 250.086787 184.472656 C 249.051188 183.775391 249.035615 183.699219 249.020042 178.767578 C 249.004469 174.515625 249.020042 174.314453 249.345127 173.712891 C 249.516429 173.371094 249.886286 172.986328 250.149078 172.861328 C 250.544241 172.664062 297.492692 172.634766 305.721032 172.820312 C 306.491891 172.835938 307.077822 173.083984 307.303629 173.638672 C 307.607301 174.382812 307.578102 175.814453 307.578102 178.798828 Z M 307.578102 178.798828 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(36.078431%,38.431373%,46.666667%);fill-opacity:1;stroke-width:0.2;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(34.509804%,36.862745%,45.098039%);stroke-opacity:1;stroke-miterlimit:10;" d="M 251.975003 193.347656 C 251.69469 193.769531 251.72389 193.964844 252.031455 194.216797 C 253.405765 195.367188 251.303421 197.048828 249.619599 196.179688 C 249.031722 195.84375 248.862366 194.384766 249.395739 194.048828 C 249.619599 193.9375 249.619599 193.796875 249.395739 193.572266 C 248.97527 193.152344 249.002523 192.646484 249.535895 192.113281 C 250.57344 191.076172 252.704983 192.169922 251.975003 193.347656 Z M 250.236676 192.505859 C 249.70525 192.84375 250.069267 193.712891 250.686344 193.599609 C 250.966657 193.544922 251.190517 193.263672 251.190517 192.984375 C 251.190517 192.367188 250.797301 192.169922 250.236676 192.505859 Z M 249.929111 195.085938 C 249.929111 195.732422 250.770049 196.011719 251.274222 195.507812 C 251.640185 195.169922 251.640185 195.001953 251.330674 194.666016 C 250.713597 193.908203 249.929111 194.162109 249.929111 195.085938 Z M 249.929111 195.085938 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 225.04943 123.15625 C 225.04943 123.677734 224.527737 123.650391 223.924287 123.099609 C 223.375342 122.605469 222.468219 122.771484 222.631735 123.347656 C 222.715439 123.511719 223.128121 123.814453 223.593362 123.953125 C 225.353102 124.529297 225.847542 125.628906 224.720452 126.396484 C 223.538857 127.220703 221.479339 126.671875 221.479339 125.544922 C 221.479339 125.050781 222.193746 125.078125 222.413714 125.599609 C 222.495472 125.847656 222.908154 126.011719 223.402594 126.011719 C 224.55499 126.011719 224.418727 125.216797 223.209879 124.804688 C 222.715439 124.638672 222.137295 124.308594 221.919274 124.089844 C 221.313877 123.511719 221.672054 122.523438 222.549977 122.220703 C 223.704319 121.835938 225.04943 122.359375 225.04943 123.15625 Z M 225.04943 123.15625 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 232.055296 122.166016 C 232.38622 122.166016 232.467978 122.605469 232.467978 124.501953 C 232.467978 126.396484 232.38622 126.835938 232.055296 126.835938 C 231.726318 126.835938 231.64456 126.396484 231.64456 124.501953 C 231.64456 122.605469 231.726318 122.166016 232.055296 122.166016 Z M 232.055296 122.166016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.25;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 233.978551 122.166016 C 234.198519 122.166016 234.391233 122.275391 234.391233 122.441406 C 234.391233 122.578125 234.198519 122.716797 233.978551 122.716797 C 233.758584 122.716797 233.565869 122.578125 233.565869 122.441406 C 233.565869 122.275391 233.758584 122.166016 233.978551 122.166016 Z M 233.978551 122.166016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 245.241663 122.166016 C 245.572588 122.166016 245.654345 122.605469 245.654345 124.447266 L 245.654345 126.753906 L 244.309235 126.78125 C 242.522243 126.808594 241.973297 126.095703 242.440485 124.28125 C 242.6332 123.541016 242.962177 123.402344 244.22553 123.511719 C 244.692718 123.541016 244.830927 123.429688 244.830927 122.853516 C 244.830927 122.414062 244.994443 122.166016 245.241663 122.166016 Z M 243.37486 124.28125 C 243.016683 124.638672 243.182145 125.957031 243.62208 126.123047 C 244.22553 126.341797 244.22553 126.341797 244.556455 125.738281 C 244.71997 125.408203 244.774476 124.914062 244.692718 124.638672 C 244.527256 124.117188 243.73109 123.896484 243.37486 124.28125 Z M 243.37486 124.28125 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 248.675491 122.166016 C 249.171878 122.166016 249.226383 122.359375 249.226383 124.089844 L 249.226383 126.011719 L 250.324274 126.011719 C 251.122386 126.011719 251.424111 126.123047 251.424111 126.423828 C 251.424111 126.753906 251.065934 126.835938 249.775328 126.835938 L 248.126546 126.835938 L 248.126546 124.501953 C 248.126546 122.359375 248.181051 122.166016 248.675491 122.166016 Z M 248.675491 122.166016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.25;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 252.660211 122.166016 C 252.880179 122.166016 253.072894 122.275391 253.072894 122.441406 C 253.072894 122.578125 252.880179 122.716797 252.660211 122.716797 C 252.440244 122.716797 252.247529 122.578125 252.247529 122.441406 C 252.247529 122.275391 252.440244 122.166016 252.660211 122.166016 Z M 252.660211 122.166016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 227.05639 122.990234 C 227.1654 123.375 227.439873 123.541016 228.018017 123.541016 C 228.732425 123.541016 228.868688 123.677734 229.03415 124.363281 C 229.308623 125.544922 229.637601 125.599609 229.995778 124.501953 C 230.159293 123.980469 230.490218 123.541016 230.710185 123.541016 C 231.204625 123.541016 231.204625 123.623047 230.324756 125.875 C 229.664853 127.550781 229.474085 127.798828 228.814183 127.880859 C 228.265237 127.935547 228.072523 127.853516 228.072523 127.523438 C 228.072523 127.275391 228.208786 127.166016 228.346995 127.248047 C 228.89594 127.578125 228.950446 126.5625 228.485205 125.216797 C 228.099775 124.171875 227.879808 123.923828 227.494378 124.007812 C 226.836422 124.199219 226.781917 125.683594 227.385368 125.902344 C 227.961565 126.123047 227.90706 126.835938 227.30361 126.835938 C 226.534697 126.835938 226.149267 126.259766 226.149267 125.160156 C 226.149267 124.583984 225.983805 124.0625 225.820289 123.980469 C 225.54387 123.841797 225.54387 123.787109 225.820289 123.650391 C 225.983805 123.568359 226.149267 123.265625 226.149267 122.962891 C 226.149267 122.275391 226.863675 122.275391 227.05639 122.990234 Z M 227.05639 122.990234 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 257.879085 122.441406 C 258.099052 122.441406 258.291767 122.632812 258.291767 122.853516 C 258.291767 123.099609 258.484482 123.347656 258.70445 123.429688 C 258.924417 123.541016 259.115185 123.705078 259.115185 123.841797 C 259.115185 123.980469 258.924417 124.089844 258.70445 124.089844 C 258.429977 124.089844 258.291767 124.363281 258.291767 124.914062 C 258.291767 125.408203 258.45723 125.820312 258.70445 125.902344 C 259.280647 126.123047 259.226142 126.835938 258.620745 126.835938 C 257.851832 126.835938 257.468349 126.259766 257.468349 125.160156 C 257.468349 124.583984 257.302887 124.0625 257.137425 123.980469 C 256.862952 123.841797 256.862952 123.787109 257.137425 123.650391 C 257.302887 123.568359 257.468349 123.265625 257.468349 122.962891 C 257.468349 122.6875 257.659118 122.441406 257.879085 122.441406 Z M 257.879085 122.441406 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 239.995537 123.265625 C 240.598987 123.265625 241.533362 124.117188 241.533362 124.666016 C 241.533362 125.105469 241.340648 125.1875 240.435472 125.1875 C 239.664612 125.1875 239.335634 125.298828 239.335634 125.572266 C 239.335634 126.123047 239.88458 126.259766 240.655439 125.929688 C 241.451605 125.572266 241.807835 125.957031 241.149879 126.451172 C 239.911832 127.332031 238.428512 126.644531 238.428512 125.1875 C 238.428512 124.583984 238.621227 124.117188 239.033909 123.759766 C 239.39014 123.484375 239.802822 123.265625 239.995537 123.265625 Z M 239.857327 124.089844 C 239.582855 124.089844 239.335634 124.199219 239.335634 124.363281 C 239.335634 124.501953 239.664612 124.638672 240.050042 124.638672 C 240.435472 124.638672 240.682692 124.529297 240.571735 124.363281 C 240.489977 124.199219 240.159052 124.089844 239.857327 124.089844 Z M 239.857327 124.089844 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 256.259502 123.732422 C 256.726689 124.199219 256.726689 124.226562 256.259502 124.308594 C 256.012282 124.363281 255.599599 124.253906 255.379632 124.0625 C 255.077907 123.814453 254.885192 123.814453 254.665224 124.035156 C 254.363499 124.335938 254.499762 124.419922 256.314007 125.050781 C 256.726689 125.216797 256.753942 126.068359 256.314007 126.507812 C 255.846819 126.974609 254.308994 126.919922 253.896312 126.423828 C 253.401871 125.820312 253.785355 125.572266 254.583467 126.011719 C 255.132412 126.287109 255.352379 126.314453 255.599599 126.068359 C 255.846819 125.820312 255.654105 125.628906 254.776181 125.271484 C 253.538134 124.804688 253.236409 124.0625 254.116279 123.568359 C 254.830687 123.128906 255.735862 123.210938 256.259502 123.732422 Z M 256.259502 123.732422 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 262.04484 123.667969 C 262.731995 124.189453 262.274541 124.583984 261.532881 124.117188 C 261.149398 123.896484 260.874925 123.869141 260.709463 124.035156 C 260.516748 124.226562 260.736715 124.474609 261.42387 124.748047 C 262.192783 125.078125 262.41275 125.326172 262.41275 125.847656 C 262.41275 126.644531 261.532881 127.029297 260.380485 126.726562 C 259.527868 126.507812 259.19889 125.738281 259.94055 125.738281 C 260.242275 125.738281 260.489495 125.847656 260.489495 126.011719 C 260.489495 126.150391 260.736715 126.287109 261.03844 126.287109 C 261.91831 126.287109 261.67109 125.572266 260.709463 125.298828 C 259.666077 124.996094 259.362405 124.171875 260.104065 123.623047 C 260.629651 123.234375 261.135771 123.167969 261.686663 123.441406 C 261.79762 123.496094 262.04484 123.667969 262.04484 123.667969 Z M 262.04484 123.667969 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 233.978551 123.541016 C 234.307529 123.541016 234.391233 123.896484 234.391233 125.1875 C 234.391233 126.480469 234.307529 126.835938 233.978551 126.835938 C 233.649573 126.835938 233.565869 126.480469 233.565869 125.1875 C 233.565869 123.896484 233.649573 123.541016 233.978551 123.541016 Z M 233.978551 123.541016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 236.314489 123.541016 C 237.906819 123.541016 237.990524 123.787109 236.945192 125.023438 L 236.230784 125.875 L 237.083401 125.957031 C 237.632347 126.011719 237.961325 126.205078 237.961325 126.451172 C 237.961325 126.726562 237.577842 126.835938 236.450752 126.835938 C 235.160146 126.835938 234.940179 126.753906 234.940179 126.341797 C 234.940179 126.068359 235.241904 125.544922 235.627334 125.1875 C 236.010817 124.832031 236.314489 124.447266 236.314489 124.308594 C 236.314489 124.199219 236.010817 124.089844 235.627334 124.089844 C 235.241904 124.089844 234.940179 123.953125 234.940179 123.814453 C 234.940179 123.650391 235.572828 123.541016 236.314489 123.541016 Z M 236.314489 123.541016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(34.509804%,36.862745%,45.098039%);fill-opacity:1;stroke-width:0.125;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(36.078431%,38.431373%,46.666667%);stroke-opacity:1;stroke-miterlimit:10;" d="M 252.660211 123.541016 C 252.989189 123.541016 253.072894 123.896484 253.072894 125.1875 C 253.072894 126.480469 252.989189 126.835938 252.660211 126.835938 C 252.329287 126.835938 252.247529 126.480469 252.247529 125.1875 C 252.247529 123.896484 252.329287 123.541016 252.660211 123.541016 Z M 252.660211 123.541016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(0.784314%,42.352941%,90.980392%);fill-opacity:1;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(0.392157%,25.098039%,53.333333%);stroke-opacity:1;stroke-miterlimit:10;" d="M 306.692392 132.541016 C 307.790283 133.298828 307.585888 133.251953 307.585888 138.462891 L 307.585888 143.115234 C 307.585888 143.115234 307.266644 143.818359 307.052516 144.033203 C 306.811136 144.273438 306.209632 144.492188 306.209632 144.492188 L 250.604586 144.492188 L 250.094573 144.136719 C 249.058974 143.439453 249.043401 143.363281 249.027828 138.431641 C 249.012256 134.179688 249.027828 133.978516 249.352913 133.375 C 249.524215 133.035156 249.894072 132.648438 250.156865 132.525391 C 250.557868 132.326172 297.973506 132.296875 305.503011 132.488281 C 305.676259 132.492188 306.692392 132.541016 306.692392 132.541016 Z M 306.692392 132.541016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(100%,40%,10.196078%);fill-opacity:1;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(80.392157%,32.156863%,7.843137%);stroke-opacity:1;stroke-miterlimit:10;" d="M 307.578102 151.923828 L 307.578102 156.576172 C 307.578102 156.576172 307.177099 157.361328 306.933773 157.605469 C 306.725485 157.814453 306.201845 157.953125 306.201845 157.953125 L 250.5968 157.953125 L 250.086787 157.597656 C 249.051188 156.900391 249.035615 156.824219 249.020042 151.892578 C 249.004469 147.640625 249.020042 147.439453 249.345127 146.837891 C 249.516429 146.496094 249.886286 146.111328 250.149078 145.986328 C 250.544241 145.789062 297.492692 145.759766 305.721032 145.945312 C 306.491891 145.960938 307.077822 146.208984 307.303629 146.763672 C 307.607301 147.507812 307.578102 148.939453 307.578102 151.923828 Z M 307.578102 151.923828 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(100%,40%,10.196078%);fill-opacity:1;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(80.392157%,32.156863%,7.843137%);stroke-opacity:1;stroke-miterlimit:10;" d="M 237.692692 159.416016 C 238.788636 160.173828 238.586188 160.126953 238.586188 165.337891 L 238.586188 169.990234 C 238.586188 169.990234 238.266943 170.693359 238.052815 170.908203 C 237.811435 171.148438 237.209931 171.367188 237.209931 171.367188 L 181.604886 171.367188 L 181.094873 171.011719 C 180.059274 170.314453 180.043701 170.238281 180.028128 165.306641 C 180.012555 161.054688 180.028128 160.853516 180.353213 160.25 C 180.522568 159.910156 180.894371 159.523438 181.157164 159.400391 C 181.55622 159.201172 228.973805 159.171875 236.50331 159.363281 C 236.676559 159.367188 237.692692 159.416016 237.692692 159.416016 Z M 237.692692 159.416016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(100%,83.137255%,1.176471%);fill-opacity:1;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(69.411765%,58.039216%,0.784314%);stroke-opacity:1;stroke-miterlimit:10;" d="M 238.578401 178.798828 L 238.578401 183.451172 C 238.578401 183.451172 238.177399 184.236328 237.932125 184.480469 C 237.725784 184.689453 237.202145 184.828125 237.202145 184.828125 L 181.597099 184.828125 L 181.087086 184.472656 C 180.051487 183.775391 180.035914 183.699219 180.020342 178.767578 C 180.004769 174.515625 180.020342 174.314453 180.345426 173.712891 C 180.514782 173.371094 180.886585 172.986328 181.149378 172.861328 C 181.544541 172.664062 228.492991 172.634766 236.721331 172.820312 C 237.49219 172.835938 238.078121 173.083984 238.303929 173.638672 C 238.607601 174.382812 238.578401 175.814453 238.578401 178.798828 Z M 238.578401 178.798828 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(100%,40%,10.196078%);fill-opacity:1;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(80.392157%,32.156863%,7.843137%);stroke-opacity:1;stroke-miterlimit:10;" d="M 237.692692 132.541016 C 238.788636 133.298828 238.586188 133.251953 238.586188 138.462891 L 238.586188 143.115234 C 238.586188 143.115234 238.266943 143.818359 238.052815 144.033203 C 237.811435 144.273438 237.209931 144.492188 237.209931 144.492188 L 181.604886 144.492188 L 181.094873 144.136719 C 180.059274 143.439453 180.043701 143.363281 180.028128 138.431641 C 180.012555 134.179688 180.028128 133.978516 180.353213 133.375 C 180.522568 133.035156 180.894371 132.648438 181.157164 132.525391 C 181.55622 132.326172 228.973805 132.296875 236.50331 132.488281 C 236.676559 132.492188 237.692692 132.541016 237.692692 132.541016 Z M 237.692692 132.541016 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill-rule:nonzero;fill:rgb(66.27451%,0.784314%,94.509804%);fill-opacity:1;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(37.254902%,0.392157%,52.941176%);stroke-opacity:1;stroke-miterlimit:10;" d="M 238.578401 151.923828 L 238.578401 156.576172 C 238.578401 156.576172 238.177399 157.361328 237.932125 157.605469 C 237.725784 157.814453 237.202145 157.953125 237.202145 157.953125 L 181.597099 157.953125 L 181.087086 157.597656 C 180.051487 156.900391 180.035914 156.824219 180.020342 151.892578 C 180.004769 147.640625 180.020342 147.439453 180.345426 146.837891 C 180.514782 146.496094 180.886585 146.111328 181.149378 145.986328 C 181.544541 145.789062 228.492991 145.759766 236.721331 145.945312 C 237.49219 145.960938 238.078121 146.208984 238.303929 146.763672 C 238.607601 147.507812 238.578401 148.939453 238.578401 151.923828 Z M 238.578401 151.923828 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill:none;stroke-width:7.5;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(0%,0%,0%);stroke-opacity:0.501961;stroke-miterlimit:10;" d="M 332.777028 149.5625 C 336.236162 149.5625 346.712842 149.5625 346.712842 149.5625 C 346.712842 149.5625 346.712842 145.429688 346.712842 144.650391 C 346.712842 143.652344 347.545993 141.835938 348.861904 142.779297 C 353.210641 145.896484 363.790491 155.632812 366.235439 157.386719 C 367.33917 158.177734 367.18928 159.896484 365.978486 160.765625 C 363.599723 162.470703 354.121657 171.103516 349.589938 174.353516 C 347.859398 175.59375 346.712842 175.109375 346.712842 174.330078 C 346.712842 173.332031 346.712842 168.40625 346.712842 168.40625 C 346.712842 168.40625 335.81764 168.40625 332.383812 168.40625 C 330.456663 168.40625 327.869612 165.736328 327.869612 163.769531 C 327.869612 161.892578 327.869612 157.841797 327.869612 154.542969 C 327.869612 151.791016 330.723349 149.5625 332.777028 149.5625 Z M 332.777028 149.5625 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill:none;stroke-width:7.5;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(0%,0%,0%);stroke-opacity:0.501961;stroke-miterlimit:10;" d="M 156.982158 154.542969 C 156.982158 157.841797 156.982158 161.892578 156.982158 163.769531 C 156.982158 165.736328 154.395107 168.40625 152.466012 168.40625 C 149.032184 168.40625 138.136982 168.40625 138.136982 168.40625 C 138.136982 168.40625 138.136982 173.332031 138.136982 174.330078 C 138.136982 175.109375 136.990426 175.59375 135.261832 174.353516 C 130.728167 171.103516 121.250101 162.470703 118.871338 160.765625 C 117.660543 159.896484 117.512601 158.177734 118.614384 157.386719 C 121.059332 155.632812 131.639183 145.896484 135.98792 142.779297 C 137.305778 141.835938 138.136982 143.652344 138.136982 144.650391 C 138.136982 145.429688 138.136982 149.5625 138.136982 149.5625 C 138.136982 149.5625 148.613662 149.5625 152.074743 149.5625 C 154.128421 149.5625 156.982158 151.791016 156.982158 154.542969 Z M 156.982158 154.542969 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.980392%,94.117647%,99.215686%);fill-opacity:1;" d="M 486.671875 89.125 C 493.613281 89.125 514.636719 89.125 514.636719 89.125 C 514.636719 89.125 514.636719 80.859375 514.636719 79.300781 C 514.636719 77.304688 516.308594 73.671875 518.949219 75.558594 C 527.675781 81.792969 548.90625 101.265625 553.8125 104.773438 C 556.027344 106.355469 555.726562 109.792969 553.296875 111.53125 C 548.523438 114.941406 529.503906 132.207031 520.410156 138.707031 C 516.9375 141.1875 514.636719 140.21875 514.636719 138.660156 C 514.636719 136.664062 514.636719 126.8125 514.636719 126.8125 C 514.636719 126.8125 492.773438 126.8125 485.882812 126.8125 C 482.015625 126.8125 476.824219 121.472656 476.824219 117.539062 C 476.824219 113.785156 476.824219 105.683594 476.824219 99.085938 C 476.824219 93.582031 482.550781 89.125 486.671875 89.125 Z M 486.671875 89.125 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(90.980392%,94.117647%,99.215686%);fill-opacity:1;" d="M 133.90625 99.085938 C 133.90625 105.683594 133.90625 113.785156 133.90625 117.539062 C 133.90625 121.472656 128.714844 126.8125 124.84375 126.8125 C 117.953125 126.8125 96.089844 126.8125 96.089844 126.8125 C 96.089844 126.8125 96.089844 136.664062 96.089844 138.660156 C 96.089844 140.21875 93.789062 141.1875 90.320312 138.707031 C 81.222656 132.207031 62.203125 114.941406 57.429688 111.53125 C 55 109.792969 54.703125 106.355469 56.914062 104.773438 C 61.820312 101.265625 83.050781 81.792969 91.777344 75.558594 C 94.421875 73.671875 96.089844 77.304688 96.089844 79.300781 C 96.089844 80.859375 96.089844 89.125 96.089844 89.125 C 96.089844 89.125 117.113281 89.125 124.058594 89.125 C 128.179688 89.125 133.90625 93.582031 133.90625 99.085938 Z M 133.90625 99.085938 "/>
+<path style="fill:none;stroke-width:7.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(0%,0%,0%);stroke-opacity:0.501961;stroke-miterlimit:10;" d="M 172.403239 231.714844 C 173.542008 232.347656 174.628219 232.666016 175.661871 232.666016 C 176.699417 232.666016 177.219163 232.263672 177.219163 231.457031 C 177.219163 231.091797 177.07122 230.767578 176.775335 230.486328 C 176.485289 230.205078 175.94997 229.882812 175.169378 229.521484 C 174.386839 229.154297 173.800908 228.869141 173.411585 228.664062 C 173.020315 228.455078 172.500569 228.111328 171.854293 227.634766 C 171.209964 227.158203 170.71747 226.664062 170.374866 226.148438 C 169.403506 224.763672 168.916852 222.996094 168.916852 220.847656 C 168.916852 218.699219 169.714964 216.888672 171.311188 215.417969 C 172.905465 213.941406 174.998076 213.203125 177.58318 213.203125 C 179.340973 213.203125 180.962503 213.392578 182.449717 213.773438 C 183.934983 214.150391 184.750615 215.396484 184.750615 215.466797 C 184.750615 216.324219 184.480036 217.40625 183.94277 218.710938 C 183.409398 220.011719 184.032314 222.736328 183.814293 222.882812 C 182.251162 222.078125 179.852933 219.675781 178.618779 219.675781 C 177.390465 219.675781 176.777282 220.113281 176.777282 220.990234 C 176.777282 221.529297 177.228896 222.005859 178.134072 222.419922 C 178.328733 222.519531 178.607099 222.654297 178.96917 222.826172 C 179.33708 222.994141 179.757549 223.193359 180.234469 223.427734 C 180.71139 223.660156 181.223349 223.953125 181.770348 224.304688 C 182.319293 224.658203 182.911064 225.126953 183.549554 225.712891 C 184.840159 226.931641 185.486435 228.542969 185.486435 230.542969 C 185.486435 233.154297 184.766188 235.287109 183.32764 236.945312 C 181.889092 238.603516 179.669951 239.455078 176.668271 239.503906 C 175.206364 239.503906 173.882666 239.380859 172.697177 239.138672 C 171.515582 238.896484 170.483877 238.421875 169.60206 237.716797 C 168.726084 237.007812 168.288095 236.152344 168.288095 235.152344 C 168.288095 234.152344 168.471077 233.158203 168.838987 232.171875 C 169.204951 231.181641 169.59622 230.529297 170.010849 230.214844 C 170.010849 230.214844 171.270309 231.082031 172.403239 231.714844 Z M 196.716455 238.917969 C 196.716455 239.212891 195.692536 239.359375 193.64275 239.359375 C 191.205589 239.259766 189.985062 239.099609 189.985062 238.880859 L 189.985062 225.935547 L 188.120205 225.935547 C 187.629658 225.935547 187.384384 225.091797 187.384384 223.40625 C 187.384384 222.966797 187.42721 222.431641 187.512861 221.796875 C 187.598512 221.164062 187.777601 220.847656 188.04818 220.847656 L 189.985062 220.847656 L 189.985062 217.625 C 189.985062 217.138672 191.014821 216.896484 193.072392 216.896484 C 195.133857 216.896484 196.165563 217.091797 196.165563 217.482422 L 196.165563 219.826172 L 196.200602 220.847656 L 199.317132 220.847656 C 199.731761 220.847656 199.938102 221.703125 199.938102 223.412109 C 199.938102 225.117188 199.731761 225.970703 199.317132 225.970703 L 196.716455 225.970703 Z M 200.483154 221.117188 C 200.483154 220.845703 201.596618 220.708984 203.825491 220.708984 C 206.060205 220.708984 207.214547 220.830078 207.292412 221.074219 L 209.920342 229.712891 L 212.443154 221.001953 C 212.542431 220.806641 213.299664 220.708984 214.714853 220.708984 C 217.95986 220.708984 219.591123 220.869141 219.44318 221.1875 L 210.763226 245.660156 C 210.739866 245.806641 210.076071 245.880859 208.769892 245.880859 C 207.465661 245.880859 206.250973 245.837891 205.12583 245.751953 C 204.006526 245.666016 203.471207 245.5625 203.519873 245.4375 L 206.706481 237.757812 Z M 200.483154 221.117188 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill:none;stroke-width:7.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(0%,0%,0%);stroke-opacity:0.501961;stroke-miterlimit:10;" d="M 223.369502 232.296875 L 225.925407 224.980469 L 234.352301 224.980469 L 234.352301 232.296875 Z M 223.369502 232.296875 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style="fill:none;stroke-width:7.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(0%,0%,0%);stroke-opacity:0.501961;stroke-miterlimit:10;" d="M 241.803942 236.980469 L 241.803942 214.224609 C 241.803942 213.714844 243.040042 213.458984 245.512243 213.458984 C 247.990283 213.458984 249.22833 213.714844 249.22833 214.224609 L 249.22833 232.150391 L 254.865726 232.150391 C 255.303714 232.150391 255.609332 232.724609 255.780634 233.873047 C 255.852659 234.429688 255.887698 235.001953 255.887698 235.587891 C 255.887698 236.173828 255.852659 236.771484 255.780634 237.380859 C 255.585973 238.552734 255.268675 239.138672 254.830687 239.138672 L 243.561735 239.138672 C 243.024469 239.138672 242.596214 238.919922 242.276969 238.480469 C 241.961618 238.042969 241.803942 237.542969 241.803942 236.980469 Z M 264.591012 238.917969 C 264.591012 239.113281 263.473655 239.210938 261.240888 239.210938 C 259.012015 239.210938 257.896605 239.125 257.896605 238.953125 L 257.896605 220.990234 C 257.896605 220.824219 259.012015 220.740234 261.240888 220.740234 C 263.473655 220.740234 264.591012 220.8125 264.591012 220.955078 Z M 264.591012 218.796875 C 264.591012 218.96875 263.473655 219.054688 261.240888 219.054688 C 259.012015 219.054688 257.896605 218.980469 257.896605 218.832031 L 257.896605 213.566406 C 257.896605 213.324219 259.012015 213.203125 261.240888 213.203125 C 263.473655 213.203125 264.591012 213.275391 264.591012 213.423828 Z M 268.655543 232.550781 C 270.631357 233.746094 272.192542 234.34375 273.335205 234.34375 C 274.069078 234.34375 274.435042 234.089844 274.435042 233.580078 C 274.435042 233.212891 273.802392 232.736328 272.535146 232.150391 C 269.486748 230.908203 267.962549 228.871094 267.962549 226.041016 C 267.962549 224.236328 268.618558 222.859375 269.934469 221.912109 C 271.254274 220.958984 272.832978 220.482422 274.670582 220.482422 C 276.514026 220.482422 278.075211 220.677734 279.35219 221.068359 C 280.633063 221.458984 281.273499 221.970703 281.273499 222.605469 C 281.273499 223.138672 281.010706 223.845703 280.487067 224.726562 C 279.963427 225.603516 279.603304 226.078125 279.408642 226.148438 C 278.361364 225.568359 277.226487 225.277344 276.007907 225.277344 C 275.349951 225.277344 275.020973 225.507812 275.020973 225.970703 C 275.020973 226.261719 275.147503 226.511719 275.400563 226.720703 C 275.657516 226.925781 276.12665 227.179688 276.807965 227.484375 C 277.493174 227.789062 278.059638 228.066406 278.50736 228.314453 C 278.960921 228.556641 279.467041 228.896484 280.029612 229.335938 C 281.201474 230.259766 281.787405 231.466797 281.787405 232.958984 C 281.787405 234.90625 281.139183 236.486328 279.844684 237.695312 C 278.554078 238.900391 276.603571 239.503906 273.993161 239.503906 C 272.26262 239.503906 270.691702 239.210938 269.276513 238.625 C 267.861325 238.039062 267.154703 237.232422 267.154703 236.208984 C 267.154703 235.527344 267.318219 234.810547 267.647197 234.058594 C 267.976175 233.300781 268.312939 232.798828 268.655543 232.550781 Z M 292.762418 238.917969 C 292.762418 239.212891 291.738499 239.359375 289.690661 239.359375 C 287.251552 239.259766 286.031025 239.099609 286.031025 238.880859 L 286.031025 225.935547 L 283.59581 228.505859 C 283.105263 228.505859 283.430348 225.091797 283.430348 223.40625 C 283.430348 222.966797 283.473174 222.431641 283.558825 221.796875 C 283.644476 221.164062 283.823564 220.847656 284.09609 220.847656 L 286.031025 220.847656 L 286.031025 217.625 C 286.031025 217.138672 287.060784 216.896484 289.118356 216.896484 C 291.181767 216.896484 292.211526 217.091797 292.211526 217.482422 L 292.211526 219.826172 L 292.248512 220.847656 L 295.363095 220.847656 C 295.777724 220.847656 295.984065 221.703125 295.984065 223.412109 C 295.984065 225.117188 295.777724 225.970703 295.363095 225.970703 L 292.762418 225.970703 Z M 303.258564 234.34375 C 303.992438 234.34375 304.360348 234.089844 304.360348 233.580078 C 304.360348 233.212891 303.725752 232.736328 302.458506 232.150391 C 299.410107 230.908203 297.885908 228.871094 297.885908 226.041016 C 297.885908 224.236328 298.543864 222.859375 299.857828 221.912109 C 301.177633 220.958984 302.756338 220.482422 304.595888 220.482422 C 306.439332 220.482422 307.998571 220.677734 309.27555 221.068359 C 310.556422 221.458984 311.196858 221.970703 311.196858 222.605469 C 311.196858 223.138672 310.936012 223.845703 310.412373 224.726562 C 309.886787 225.603516 309.52861 226.078125 309.332002 226.148438 C 308.284723 225.568359 307.151793 225.277344 305.931266 225.277344 C 305.27331 225.277344 304.946279 225.507812 304.946279 225.970703 C 304.946279 226.261719 305.070862 226.511719 305.323922 226.720703 C 305.580875 226.925781 306.050009 227.179688 306.731325 227.484375 C 307.41848 227.789062 307.984944 228.066406 308.432666 228.314453 C 308.88428 228.556641 309.392347 228.896484 309.954918 229.335938 C 311.12678 230.259766 311.712711 231.466797 311.712711 232.958984 C 311.712711 234.90625 311.064489 236.486328 309.768043 237.695312 C 308.477438 238.900391 306.52693 239.503906 303.91652 239.503906 C 302.187926 239.503906 300.615062 239.210938 299.201819 238.625 C 297.786631 238.039062 297.078063 237.232422 297.078063 236.208984 C 297.078063 235.527344 297.243525 234.810547 297.572503 234.058594 C 297.901481 233.300781 296.665381 229.083984 297.007985 228.835938 C 297.007985 228.835938 302.115901 234.34375 303.258564 234.34375 Z M 303.258564 234.34375 " transform="matrix(2.006689,0,0,2,-181.108114,-210)"/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;" d="M 160.050781 250.429688 C 160.976562 251.164062 162.578125 252.164062 164.851562 253.429688 C 167.136719 254.695312 169.316406 255.332031 171.390625 255.332031 C 173.472656 255.332031 174.515625 254.527344 174.515625 252.914062 C 174.515625 252.183594 174.21875 251.535156 173.625 250.972656 C 173.042969 250.410156 171.96875 249.765625 170.402344 249.042969 C 168.832031 248.308594 167.65625 247.738281 166.875 247.328125 C 166.089844 246.910156 165.046875 246.222656 163.75 245.269531 C 162.457031 244.316406 161.46875 243.328125 160.78125 242.296875 C 158.832031 239.527344 157.855469 235.992188 157.855469 231.695312 C 157.855469 227.398438 159.457031 223.777344 162.660156 220.835938 C 165.859375 217.882812 170.058594 216.40625 175.246094 216.40625 C 178.773438 216.40625 182.027344 216.785156 185.011719 217.546875 C 187.992188 218.300781 189.53125 219.285156 189.628906 220.507812 C 189.628906 220.648438 189.628906 220.792969 189.628906 220.933594 C 189.628906 222.648438 189.085938 224.8125 188.007812 227.421875 C 186.9375 230.023438 186.183594 231.472656 185.742188 231.765625 C 182.605469 230.15625 179.800781 229.351562 177.324219 229.351562 C 174.859375 229.351562 173.628906 230.226562 173.628906 231.980469 C 173.628906 233.058594 174.535156 234.011719 176.351562 234.839844 C 176.742188 235.039062 177.300781 235.308594 178.027344 235.652344 C 178.765625 235.988281 179.609375 236.386719 180.566406 236.855469 C 181.523438 237.320312 182.550781 237.90625 183.648438 238.609375 C 184.75 239.316406 185.9375 240.253906 187.21875 241.425781 C 189.808594 243.863281 191.105469 247.085938 191.105469 251.085938 C 191.105469 256.308594 189.660156 260.574219 186.773438 263.890625 C 183.886719 267.207031 179.433594 268.910156 173.410156 269.007812 C 170.476562 269.007812 167.820312 268.761719 165.441406 268.277344 C 163.070312 267.792969 161 266.84375 159.230469 265.433594 C 157.472656 264.015625 156.59375 262.304688 156.59375 260.304688 C 156.59375 258.304688 156.960938 256.316406 157.699219 254.34375 C 158.433594 252.363281 159.21875 251.058594 160.050781 250.429688 Z M 213.640625 267.835938 C 213.640625 268.425781 211.585938 268.71875 207.472656 268.71875 C 202.582031 268.519531 200.132812 268.199219 200.132812 267.761719 L 200.132812 241.871094 L 196.390625 241.871094 C 195.40625 241.871094 194.914062 240.183594 194.914062 236.8125 C 194.914062 235.933594 195 234.863281 195.171875 233.59375 C 195.34375 232.328125 195.703125 231.695312 196.246094 231.695312 L 200.132812 231.695312 L 200.132812 225.25 C 200.132812 224.277344 202.199219 223.792969 206.328125 223.792969 C 210.464844 223.792969 212.535156 224.183594 212.535156 224.964844 L 212.535156 229.652344 L 212.605469 231.695312 L 218.859375 231.695312 C 219.691406 231.695312 220.105469 233.40625 220.105469 236.824219 C 220.105469 240.234375 219.691406 241.941406 218.859375 241.941406 L 213.640625 241.941406 Z M 221.199219 232.066406 C 221.199219 231.523438 223.433594 231.25 227.90625 231.25 C 232.390625 231.25 234.707031 231.496094 234.863281 231.980469 L 240.136719 249.257812 L 245.199219 231.835938 C 245.398438 231.445312 246.917969 231.25 249.757812 231.25 C 256.269531 231.25 259.375 231.570312 259.078125 232.210938 L 241.828125 281.152344 C 241.78125 281.449219 240.449219 281.59375 237.828125 281.59375 C 235.210938 281.59375 232.773438 281.507812 230.515625 281.339844 C 228.269531 281.167969 227.195312 280.957031 227.292969 280.710938 L 233.6875 265.347656 Z M 221.199219 232.066406 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;" d="M 294.738281 254.59375 L 266.011719 254.59375 C 264.375 254.59375 263.261719 253.21875 262.671875 250.472656 C 262.4375 249.378906 262.320312 248.3125 262.320312 247.277344 C 262.320312 246.234375 262.4375 245.164062 262.671875 244.070312 C 263.261719 241.332031 264.375 239.960938 266.011719 239.960938 L 294.738281 239.960938 C 296.375 239.960938 297.488281 241.332031 298.082031 244.070312 C 298.316406 245.164062 298.433594 246.234375 298.433594 247.277344 C 298.433594 248.3125 298.316406 249.378906 298.082031 250.472656 C 297.488281 253.21875 296.375 254.59375 294.738281 254.59375 Z M 294.738281 254.59375 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;" d="M 304.117188 263.960938 L 304.117188 218.449219 C 304.117188 217.429688 306.597656 216.917969 311.558594 216.917969 C 316.53125 216.917969 319.015625 217.429688 319.015625 218.449219 L 319.015625 254.300781 L 330.328125 254.300781 C 331.207031 254.300781 331.820312 255.449219 332.164062 257.746094 C 332.308594 258.859375 332.378906 260.003906 332.378906 261.175781 C 332.378906 262.347656 332.308594 263.542969 332.164062 264.761719 C 331.773438 267.105469 331.136719 268.277344 330.257812 268.277344 L 307.644531 268.277344 C 306.566406 268.277344 305.707031 267.839844 305.066406 266.960938 C 304.433594 266.085938 304.117188 265.085938 304.117188 263.960938 Z M 349.84375 267.835938 C 349.84375 268.226562 347.601562 268.421875 343.121094 268.421875 C 338.648438 268.421875 336.410156 268.25 336.410156 267.90625 L 336.410156 231.980469 C 336.410156 231.648438 338.648438 231.480469 343.121094 231.480469 C 347.601562 231.480469 349.84375 231.625 349.84375 231.910156 Z M 349.84375 227.59375 C 349.84375 227.9375 347.601562 228.109375 343.121094 228.109375 C 338.648438 228.109375 336.410156 227.960938 336.410156 227.664062 L 336.410156 217.132812 C 336.410156 216.648438 338.648438 216.40625 343.121094 216.40625 C 347.601562 216.40625 349.84375 216.550781 349.84375 216.847656 Z M 358 255.101562 C 361.964844 257.492188 365.097656 258.6875 367.390625 258.6875 C 368.863281 258.6875 369.597656 258.179688 369.597656 257.160156 C 369.597656 256.425781 368.328125 255.472656 365.785156 254.300781 C 359.667969 251.816406 356.609375 247.742188 356.609375 242.082031 C 356.609375 238.472656 357.925781 235.71875 360.566406 233.824219 C 363.214844 231.917969 366.382812 230.964844 370.070312 230.964844 C 373.769531 230.964844 376.902344 231.355469 379.464844 232.136719 C 382.035156 232.917969 383.320312 233.941406 383.320312 235.210938 C 383.320312 236.277344 382.792969 237.691406 381.742188 239.453125 C 380.691406 241.207031 379.96875 242.15625 379.578125 242.296875 C 377.476562 241.136719 375.199219 240.554688 372.753906 240.554688 C 371.433594 240.554688 370.773438 241.015625 370.773438 241.941406 C 370.773438 242.523438 371.027344 243.023438 371.535156 243.441406 C 372.050781 243.851562 372.992188 244.359375 374.359375 244.96875 C 375.734375 245.578125 376.871094 246.132812 377.769531 246.628906 C 378.679688 247.113281 379.695312 247.792969 380.824219 248.671875 C 383.175781 250.519531 384.351562 252.933594 384.351562 255.917969 C 384.351562 259.8125 383.050781 262.972656 380.453125 265.390625 C 377.863281 267.800781 373.949219 269.007812 368.710938 269.007812 C 365.238281 269.007812 362.085938 268.421875 359.246094 267.25 C 356.40625 266.078125 354.988281 264.464844 354.988281 262.417969 C 354.988281 261.054688 355.316406 259.621094 355.976562 258.117188 C 356.636719 256.601562 357.3125 255.597656 358 255.101562 Z M 406.375 267.835938 C 406.375 268.425781 404.320312 268.71875 400.210938 268.71875 C 395.316406 268.519531 392.867188 268.199219 392.867188 267.761719 L 392.867188 241.871094 L 389.125 241.871094 C 388.140625 241.871094 387.648438 240.183594 387.648438 236.8125 C 387.648438 235.933594 387.734375 234.863281 387.90625 233.59375 C 388.078125 232.328125 388.4375 231.695312 388.984375 231.695312 L 392.867188 231.695312 L 392.867188 225.25 C 392.867188 224.277344 394.933594 223.792969 399.0625 223.792969 C 403.203125 223.792969 405.269531 224.183594 405.269531 224.964844 L 405.269531 229.652344 L 405.34375 231.695312 L 411.59375 231.695312 C 412.425781 231.695312 412.839844 233.40625 412.839844 236.824219 C 412.839844 240.234375 412.425781 241.941406 411.59375 241.941406 L 406.375 241.941406 Z M 418.046875 255.101562 C 422.015625 257.492188 425.144531 258.6875 427.4375 258.6875 C 428.910156 258.6875 429.648438 258.179688 429.648438 257.160156 C 429.648438 256.425781 428.375 255.472656 425.832031 254.300781 C 419.714844 251.816406 416.65625 247.742188 416.65625 242.082031 C 416.65625 238.472656 417.976562 235.71875 420.613281 233.824219 C 423.261719 231.917969 426.429688 230.964844 430.121094 230.964844 C 433.820312 230.964844 436.949219 231.355469 439.511719 232.136719 C 442.082031 232.917969 443.367188 233.941406 443.367188 235.210938 C 443.367188 236.277344 442.84375 237.691406 441.792969 239.453125 C 440.738281 241.207031 440.019531 242.15625 439.625 242.296875 C 437.523438 241.136719 435.25 240.554688 432.800781 240.554688 C 431.480469 240.554688 430.824219 241.015625 430.824219 241.941406 C 430.824219 242.523438 431.074219 243.023438 431.582031 243.441406 C 432.097656 243.851562 433.039062 244.359375 434.40625 244.96875 C 435.785156 245.578125 436.921875 246.132812 437.820312 246.628906 C 438.726562 247.113281 439.746094 247.792969 440.875 248.671875 C 443.226562 250.519531 444.402344 252.933594 444.402344 255.917969 C 444.402344 259.8125 443.101562 262.972656 440.5 265.390625 C 437.910156 267.800781 433.996094 269.007812 428.757812 269.007812 C 425.289062 269.007812 422.132812 268.421875 419.296875 267.25 C 416.457031 266.078125 415.035156 264.464844 415.035156 262.417969 C 415.035156 261.054688 415.367188 259.621094 416.027344 258.117188 C 416.6875 256.601562 417.359375 255.597656 418.046875 255.101562 Z M 418.046875 255.101562 "/>
+</g>
+</svg>

From da5988c65c0f55cf5f25a4104ae10408726214f9 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Mon, 18 Dec 2023 10:40:45 -0800
Subject: [PATCH 03/13] Update Sty-Lists.js

---
 extensions/SharkPool/Sty-Lists.js | 274 ++++++++++++------------------
 1 file changed, 112 insertions(+), 162 deletions(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index fdc0086e92..f8bbef3772 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,14 +3,11 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 1.0
+// Version 1.1.0
 
 (function (Scratch) {
   "use strict";
-
-  if (!Scratch.extensions.unsandboxed) {
-    throw new Error("Sty-Lists must run unsandboxed!");
-  }
+  if (!Scratch.extensions.unsandboxed) throw new Error("Sty-Lists must run unsandboxed!");
 
   const menuIconURI =
 "data:image/svg+xml;base64,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";
@@ -18,15 +15,32 @@
   const vm = Scratch.vm;
   const runtime = vm.runtime;
   const builtInFonts = [
-    "Scratch",
-    "Sans Serif",
-    "Serif",
-    "Handwriting",
-    "Marker",
-    "Curly",
-    "Pixel"
+    "Scratch", "Sans Serif", "Serif",
+    "Handwriting", "Marker", "Curly", "Pixel"
   ];
 
+  let listDocs;
+  if (runtime.isPackaged) {
+    listDocs = {
+      body : "sc-monitor-root",
+      value : "sc-monitor-row-value-outer", value2 : "sc-monitor-row-value-inner",
+      ind : "sc-monitor-row-index",
+      head : "sc-monitor-list-label", foot : "sc-monitor-list-footer-text",
+      pkg1 : "", addButton : "sc-monitor-list-add",
+      grid : ".sc-monitor-rows-inner", contain : ".sc-monitor-rows-inner",
+      row : "sc-monitor-row-root", span : ""
+    };
+  } else {
+    listDocs = {
+      body : "monitor_list-monitor",
+      value : "monitor_list-value", value2 : "monitor_value-inner",
+      ind : "monitor_list-index",
+      head : "monitor_list-header", foot : "monitor_footer-length_2",
+      pkg1 : `[class*="monitor_"]`, addButton : "monitor_add-button",
+      grid : ".ReactVirtualized__Grid.ReactVirtualized__List", contain : ".ReactVirtualized__Grid__innerScrollContainer",
+      row : "monitor_list-row", span : "span"
+    };
+  }
   class SPlistMonitors {
     getInfo() {
       return {
@@ -71,7 +85,6 @@
               TYPE: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "listTypes",
-                defaultValue: "globally",
               }
             },
           },
@@ -134,7 +147,6 @@
               THING: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "ATTS",
-                defaultValue: "width",
               },
             },
           },
@@ -151,12 +163,10 @@
               THING: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "listUtils",
-                defaultValue: "click events",
               },
               ON_OFF: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "ON_OFF",
-                defaultValue: "off",
               },
             },
           },
@@ -172,7 +182,6 @@
               ALIGN: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "ALIGN",
-                defaultValue: "left",
               },
             },
           },
@@ -211,7 +220,6 @@
               POSITION: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "POSITIONS",
-                defaultValue: "x",
               },
             },
           },
@@ -258,7 +266,6 @@
               DISPLAY: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "list_displays",
-                defaultValue: "header",
               },
               LIST: {
                 type: Scratch.ArgumentType.STRING,
@@ -312,7 +319,6 @@
               FONT: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "allFonts",
-                defaultValue: "Scratch",
               },
               LIST: {
                 type: Scratch.ArgumentType.STRING,
@@ -344,7 +350,6 @@
               EFFECT: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "EFFECTS",
-                defaultValue: "blur",
               },
               LIST: {
                 type: Scratch.ArgumentType.STRING,
@@ -383,7 +388,6 @@
               EFFECT: {
                 type: Scratch.ArgumentType.STRING,
                 menu: "ALL_EFFECTS",
-                defaultValue: "blur",
               },
             },
           }
@@ -391,44 +395,24 @@
         menus: {
           ATTS: {
             acceptReporters: true,
-            items: ["width", "height"],
+            items: ["width", "height"]
           },
           lists: {
             acceptReporters: true,
-            items: "getLists",
+            items: "getLists"
           },
           allFonts: {
             acceptReporters: true,
-            items: "getFonts",
-          },
-          POSITIONS: {
-            acceptReporters: false,
-            items: ["x", "y"],
-          },
-          list_displays: {
-            acceptReporters: false,
-            items: ["header", "footer"],
-          },
-          listTypes: {
-            acceptReporters: false,
-            items: ["globally", "for this sprite only"],
-          },
-          listUtils: {
-            acceptReporters: false,
-            items: [
-              "click events",
-              "text highlighting",
-              "numbered items",
-              "+ and = buttons"
-            ],
-          },
-          ON_OFF: {
-            acceptReporters: false,
-            items: ["on", "off"],
+            items: "getFonts"
           },
+          POSITIONS: ["x", "y"],
+          list_displays: ["header", "footer"],
+          listTypes: ["globally", "for this sprite only"],
+          listUtils: ["click events", "text highlighting", "numbered items", "+ and = buttons"],
+          ON_OFF: ["on", "off"],
           ALIGN: {
             acceptReporters: true,
-            items: ["left", "right", "center"],
+            items: ["left", "right", "center"]
           },
           EFFECTS: {
             acceptReporters: true,
@@ -437,7 +421,7 @@
           ALL_EFFECTS: {
             acceptReporters: true,
             items: this.getEffects(true)
-          },
+          }
         }
       }
     }
@@ -451,85 +435,63 @@
         (x) => x.type == "list"
       );
       const uniqueLists = [...new Set([...globalLists, ...localLists])];
-      if (uniqueLists.length === 0) {
-        return [
-          { text: "make a list", value: "make a list" },
-        ];
-      }
-      return uniqueLists.map((i) => ({
-        text: i.name,
-        value: i.id,
-      }));
+      if (uniqueLists.length === 0) return [{ text: "make a list", value: "make a list" }];
+      return uniqueLists.map((i) => ({ text: i.name, value: i.id }));
     }
 
     lookForList(list, util) {
       const byId = util.target.lookupVariableById(list);
-      if (byId && byId.type === "list") {
-        return JSON.stringify(byId.id);
-      }
+      if (byId && byId.type === "list") return JSON.stringify(byId.id);
       const byName = util.target.lookupVariableByNameAndType(list, "list");
-      if (byName) {
-        return JSON.stringify(byName.id);
-      }
+      if (byName) return JSON.stringify(byName.id);
       return;
     }
 
     getFonts() {
       const customFonts = Scratch.vm.runtime.fontManager
         ? Scratch.vm.runtime.fontManager.getFonts().map((i) => ({
-            text: i.name,
-            value: i.family,
-          }))
-        : [];
-      return [
-        ...builtInFonts,
-        ...customFonts,
-      ];
+        text: i.name, value: i.family })) : [];
+      return [...builtInFonts, ...customFonts];
     }
 
     getEffects(enable) {
       return [
-        "blur",
-        "saturation",
-        "contrast",
-        "brightness",
-        "hue",
-        "opacity",
-        "sepia",
-        "invert",
-        "direction",
+        "blur", "saturation", "contrast",
+        "brightness", "hue", "opacity",
+        "sepia", "invert", "direction",
         ...(enable ? ["scale x", "scale y"] : []),
-        "skew x",
-        "skew y"
+        "skew x", "skew y"
       ];
     }
 
     renderList(args, util) {
       let list = this.lookForList(args.LIST, util);
       if (!list) return;
+      const footer = runtime.isPackaged ? document.querySelector(`[data-id=${list}] [class^="${listDocs.foot}"]`).getBoundingClientRect() : "";
       args.NUM = args.NUM > 0 ? Math.round(args.NUM) : 1;
-      const parentList = document.querySelector(`[data-id=${list}] .ReactVirtualized__Grid.ReactVirtualized__List`);
+      const parentList = document.querySelector(`[data-id=${list}] ${listDocs.grid}`);
       if (parentList === null) return;
-      let listWidth = parseInt(parentList.style.width, 10);
+      let listWidth = parseFloat(parentList.style.width) || parentList.getBoundingClientRect().width / 2;
       listWidth = listWidth / args.NUM;
-      list = document.querySelector(`[data-id=${list}] .ReactVirtualized__Grid__innerScrollContainer`);
+      list = document.querySelector(`[data-id=${list}] ${listDocs.contain}`);
       if (list === null) return;
       const itemsHTML = this.getListArray(args.LIST, util);
       const newContainer = document.createElement("div");
-      newContainer.className = "ReactVirtualized__Grid__innerScrollContainer";
+      newContainer.className = listDocs.contain;
 
       newContainer.setAttribute("role", "rowgroup");
       newContainer.style.width = "auto";
-      newContainer.style.height = `${((itemsHTML[1] * 24) / args.NUM) + 24}px`;
+      newContainer.style.height = runtime.isPackaged ? `${(footer.top - (footer.height * 2)) / 2}px` :
+        `${((itemsHTML[1] * 24) / args.NUM) + 24}px`;
       newContainer.style.maxWidth = parentList.style.width;
       newContainer.style.maxHeight = list.style.maxHeight;
-      newContainer.style.overflow = "hidden";
+      newContainer.style.overflow = "scroll"; // always use scroll
       newContainer.style.position = "relative";
 
       newContainer.innerHTML = itemsHTML[0];
       list.parentNode.replaceChild(newContainer, list);
       function reorderIntoColumns(numColumns) {
-        const items = newContainer.querySelectorAll(`[class^="monitor_list-row"]`);
+        const items = newContainer.querySelectorAll(`[class^="${listDocs.row}"]`);
         for (let i = 0; i < items.length; i++) {
           const column = i % numColumns;
           const top = Math.floor(i / numColumns) * items[0].offsetHeight;
@@ -547,10 +509,10 @@
       if (!list) return 0;
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      list = list.querySelector(".ReactVirtualized__Grid__innerScrollContainer");
+      list = list.querySelector(`[class^="${listDocs.contain}"]`);
       if (list === null) return 1;
 
-      const items = Array.from(list.querySelectorAll(`[class^="monitor_list-row"]`));
+      const items = Array.from(list.querySelectorAll(`[class^="${listDocs.row}"]`));
       if (items.length === 0) return 1;
       const firstItem = items[0];
       const itemWidth = parseFloat(firstItem.style.width);
@@ -565,15 +527,21 @@
       const items = util.target.lookupVariableById(list).value;
       let allItems = document.querySelectorAll(`[data-id="${list}"]`);
       allItems = allItems[allItems.length - 1];
-      allItems = allItems.querySelectorAll(`[class^="monitor_list-index"`);
+      allItems = allItems.querySelectorAll(`[class^="${listDocs.ind}"`);
       let html = "";
+      const elementClasses = {
+        row : allItems[0].parentNode.className,
+        index : allItems[0].className,
+        outerV : allItems[0].nextElementSibling.className,
+        innerV : allItems[0].nextElementSibling.children[0].className
+      };
       for (let i = 0; i < items.length; i++) {
         const value = allItems[i] ? allItems[i].textContent : i + 1;
         html += `
-          <div class="monitor_list-row_okCNn" style="height: 24px; left: 0px; position: absolute; top: ${i * 24}px; width: 100%;">
-            <div class="monitor_list-index_7tKdl">${value}</div>
-            <div class="monitor_list-value_1zGfI" dataindex="${i}" style="background: rgb(252, 102, 44);">
-              <div class="monitor_value-inner_3E9Ou">${items[i]}</div>
+          <div class="${elementClasses.row}" style="height: 24px; left: 0px; position: absolute; top: ${i * 24}px; width: 100%;">
+            <div class="${elementClasses.index}">${value}</div>
+            <div class="${elementClasses.outerV}" dataindex="${i}" style="background: rgb(252, 102, 44);">
+              <div class="${elementClasses.innerV}">${items[i]}</div>
             </div>
           </div>`;
       }
@@ -588,10 +556,7 @@
       return list.visible;
     }
 
-    listExists(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      return Scratch.Cast.toBoolean(list);
-    }
+    listExists(args, util) { return Scratch.Cast.toBoolean(this.lookForList(args.LIST, util)) }
 
     stretchList(args, util) {
       let list = this.lookForList(args.LIST, util);
@@ -602,18 +567,19 @@
 
       runtime.requestUpdateMonitor(new Map([
         ["id", list.match(/"([^"]+)"/)[1]],
-        ["width", args.WIDTH],
-        ["height", args.HEIGHT]
+        ["width", args.WIDTH], ["height", args.HEIGHT]
       ]));
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
       if (list.classList.contains("blocklyDraggable")) return;
-      list = list.querySelector(`[class^="monitor_list-monitor"]`);
-      list.style.cssText = `width: ${args.WIDTH}px; height: ${args.HEIGHT}px;`;
-      let items = list.querySelector(".ReactVirtualized__Grid.ReactVirtualized__List");
-      if (items) items.style.cssText = `width: ${args.WIDTH}px;`;
-      items = list.querySelector(".ReactVirtualized__Grid__innerScrollContainer");
-      if (items) items.style.cssText = `width: auto; height: ${Scratch.vm.runtime.stageHeight}px; max-width: ${args.WIDTH}px; max-height: ${Scratch.vm.runtime.stageHeight}px; overflow: hidden; position: relative;`;
+      if (!runtime.isPackaged) {
+        list = list.querySelector(`[class^="${listDocs.body}"]`);
+        list.style.cssText = `width: ${args.WIDTH}px; height: ${args.HEIGHT}px;`;
+        let items = list.querySelector(listDocs.grid);
+        if (items) items.style.cssText = `width: ${args.WIDTH}px;`;
+        items = list.querySelector(listDocs.contain);
+        if (items) items.style.cssText = `width: auto; height: ${Scratch.vm.runtime.stageHeight}px; max-width: ${args.WIDTH}px; max-height: ${Scratch.vm.runtime.stageHeight}px; overflow: hidden; position: relative;`;
+      }
       this.renderList({"LIST":args.LIST, "NUM": this.getColumns(args, util)}, util);
     }
 
@@ -623,14 +589,8 @@
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
       if (list.classList.contains("blocklyDraggable")) return "";
-      list = list.querySelector(`[class^="monitor_list-monitor"]`);
-      let value;
-      if (args.THING === "width") {
-        value = parseInt(list.style.width, 10);
-      } else {
-        value = parseInt(list.style.height, 10);
-      }
-      return value;
+      list = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
+      return parseFloat(list.style[args.THING]);
     }
 
     chooseOption(args, util) {
@@ -641,29 +601,25 @@
       if (args.THING === "click events") {
         list.style.pointerEvents = args.ON_OFF === "off" ? "none" : "auto";
       } else if (args.THING === "text highlighting") {
-        const items = list.querySelectorAll(`[class^="monitor_value-inner"]`);
+        const items = list.querySelectorAll(`[class^="${listDocs.value2}"]`);
         items.forEach(item => {
           item.style.userSelect = args.ON_OFF === "off" ? "none " : "auto";
           item.style.webkitUserSelect = args.ON_OFF === "off" ? "none" : "auto"; //apple devices need this for some reason
         });
       } else if (args.THING === "numbered items") {
-        const numberedItems = list.querySelectorAll(`[class^="monitor_list-index"]`);
-        numberedItems.forEach(item => {
-          item.style.display = args.ON_OFF === "off" ? "none" : "block";
-        });
+        const numberedItems = list.querySelectorAll(`[class^="${listDocs.ind}"]`);
+        numberedItems.forEach(item => { item.style.display = args.ON_OFF === "off" ? "none" : "block" });
       } else {
-        let button1 = list.querySelector(`[class^="monitor_add-button"]`);
-        let button2 = list.querySelector(`[class^="monitor_resize-handle"]`);
+        let button1 = list.querySelector(`[class^="${listDocs.addButton}"]`);
+        let button2 = runtime.isPackaged ? button1 : list.querySelector(`[class^="monitor_resize-handle"]`);
         if (button1 === null || button2 === null) {
           const buttons = list.querySelectorAll(".no-drag");
-          buttons.forEach(button => {
-            button.style.display = args.ON_OFF === "off" ? "none" : "block";
-          });
+          buttons.forEach(button => { button.style.display = args.ON_OFF === "off" ? "none" : "block" });
         } else {
           button1.style.display = args.ON_OFF === "off" ? "none" : "block";
           button2.style.display = args.ON_OFF === "off" ? "none" : "block";
         }
-        let text = list.querySelector(`[class^="monitor_footer-length_2"]`);
+        let text = list.querySelector(`[class^="${listDocs.foot}"]`);
         text.style.margin = "0 auto";
       }
     }
@@ -673,9 +629,9 @@
       if (!list) return;
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      list = list.querySelector(".ReactVirtualized__Grid__innerScrollContainer");
+      list = list.querySelector(listDocs.contain);
       if (list === null) return;
-      const items = Array.from(list.querySelectorAll(`[class^="monitor_list-value"]`));
+      const items = Array.from(list.querySelectorAll(`[class^="${listDocs.value}"]`));
       function reorder() {
         for (let i = 0; i < items.length; i++) {
           items[i].style.textAlign = args.ALIGN;
@@ -692,13 +648,13 @@
       list = list[list.length - 1];
       if (list.classList.contains("blocklyDraggable")) return;
 
-      const box = list.querySelector(`[class^="monitor_list-monitor"]`);
-      const sizeOffset = [parseInt(box.style.width, 10), parseInt(box.style.height, 10)];
+      const box = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
+      const sizeOffset = [parseFloat(box.style.width), parseFloat(box.style.height)];
       let x = Scratch.Cast.toNumber(args.x) + canvas[0] - (sizeOffset[0] / 2);
       let y = (Scratch.Cast.toNumber(args.y) - canvas[1] + (sizeOffset[1] / 2)) * -1;
 
       let styleAttribute = list.getAttribute("style");
-      const transformRegex = /transform:([^;]+); top:([^;]+); left:([^;]+);/;
+      const transformRegex = runtime.isPackaged ? /transform:([^;]+);/ : /transform:([^;]+); top:([^;]+); left:([^;]+);/;
       const transformMatch = styleAttribute.match(transformRegex);
       if (transformMatch) {
         const updatedTransform = transformMatch[1].replace(/translate\([^)]+\)/, `translate(${x}px, ${y}px)`);
@@ -715,8 +671,8 @@
       list = list[list.length - 1];
       if (list.classList.contains("blocklyDraggable")) return "";
 
-      const box = list.querySelector(`[class^="monitor_list-monitor"]`);
-      const sizeOffset = [parseInt(box.style.width, 10), parseInt(box.style.height, 10)];
+      const box = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
+      const sizeOffset = [parseFloat(box.style.width), parseFloat(box.style.height)];
       const styleAttribute = list.getAttribute("style");
       if (styleAttribute) {
         const match = styleAttribute.match(/transform\s*:\s*translate\((-?\d+(?:\.\d+)?px),\s*(-?\d+(?:\.\d+)?px)\)/);
@@ -734,9 +690,8 @@
     setScroll(args, util) {
       let list = this.lookForList(args.LIST, util);
       if (!list) return;
-      list = document.querySelector(`[data-id=${list}] .ReactVirtualized__Grid.ReactVirtualized__List`);
+      list = document.querySelector(`[data-id=${list}] ${listDocs.grid}`);
       if (list === null) return;
-      const inner = list.querySelector(".ReactVirtualized__Grid__innerScrollContainer");
       const scroll = (args.SCROLL / 100) * (list.scrollHeight - list.clientHeight);
       list.scrollTop = scroll;
     }
@@ -744,18 +699,19 @@
     resetAll(args, util) {
       let list = this.lookForList(args.LIST, util);
       if (!list) return;
-      list = list.match(/"([^"]+)"/)[1];
-      this.changeMonitorVisibility(list, false);
-      setTimeout(() => {
-        this.changeMonitorVisibility(list, true);
-      }, 25);
+      return new Promise(resolve => {
+        list = list.match(/"([^"]+)"/)[1];
+        this.changeMonitorVisibility(list, false);
+        setTimeout(() => {
+          this.changeMonitorVisibility(list, true);
+          resolve();
+        }, 25);
+      });
     }
 
     changeMonitorVisibility(id, visible) {
       runtime.monitorBlocks.changeBlock({
-        id: id,
-        element: "checkbox",
-        value: visible
+        id: id, element: "checkbox", value: visible
       }, runtime);
     }
 
@@ -764,9 +720,9 @@
       if (!list) return;
       let label;
       if (args.DISPLAY === "header") {
-        label = document.querySelector(`[data-id=${list}] [class*="monitor_"][class^="monitor_list-header"]`);
+        label = document.querySelector(`[data-id=${list}] ${listDocs.pkg1}[class^="${listDocs.head}"]`);
       } else {
-        label = document.querySelector(`[data-id=${list}] [class*="monitor_"][class^="monitor_footer-length_2"] span`);
+        label = document.querySelector(`[data-id=${list}] ${listDocs.pkg1}[class^="${listDocs.foot}"] ${listDocs.span}`);
       }
       if (label) label.textContent = args.NAME;
     }
@@ -780,9 +736,7 @@
       list.style.transform = translation;
     }
 
-    setEffect(args, util) {
-      this.listEffect(args.LIST, args.EFFECT, args.AMOUNT, util);
-    }
+    setEffect(args, util) { this.listEffect(args.LIST, args.EFFECT, args.AMOUNT, util) }
 
     listEffect(LIST, EFFECT, AMOUNT, util) {
       let list = this.lookForList(LIST, util);
@@ -907,10 +861,8 @@
       }
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      const targetElement = list.querySelector(`[class^="monitor_list-monitor"] [class^="monitor_list-value"][dataindex="${args.NUM - 1}"]`);
-      if (targetElement) {
-        targetElement.style.background = args.COLOR;
-      }
+      const targetElement = list.querySelectorAll(`[class^="${listDocs.body}"] [class^="${listDocs.value}"]`)[args.NUM - 1];
+      if (targetElement) targetElement.style.background = args.COLOR;
     }
 
     setLabel(args, util) {
@@ -919,10 +871,8 @@
       args.NUM = Math.abs(args.NUM);
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      const targetElement = list.querySelectorAll(`[class^="monitor_list-index"`)[args.NUM - 1];
-      if (targetElement) {
-        targetElement.textContent = args.VALUE;
-      }
+      const targetElement = list.querySelectorAll(`[class^="${listDocs.ind}"`)[args.NUM - 1];
+      if (targetElement) targetElement.textContent = args.VALUE;
     }
 
     makeList(args, util) {
@@ -932,7 +882,7 @@
         //creating this kind of list doesnt show until you switch back from editing a sprite to another for some reason...
         return util.target.createVariable(this.generateId(), args.LIST, "list");
       } else {
-        Blockly.getMainWorkspace().createVariable(args.LIST, "list");
+        runtime.getTargetForStage().createVariable(this.generateId(), args.LIST, "list");
       }
     }
 

From b873aef750eea5653abafee7dced24707b0ef004 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Fri, 5 Jan 2024 13:14:58 -0800
Subject: [PATCH 04/13] Update Sty-Lists.js

---
 extensions/SharkPool/Sty-Lists.js | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index f8bbef3772..40ae88f73e 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,7 +3,7 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 1.1.0
+// Version 1.1.1
 
 (function (Scratch) {
   "use strict";
@@ -474,8 +474,8 @@
       let listWidth = parseFloat(parentList.style.width) || parentList.getBoundingClientRect().width / 2;
       listWidth = listWidth / args.NUM;
       list = document.querySelector(`[data-id=${list}] ${listDocs.contain}`);
-      if (list === null) return;
       const itemsHTML = this.getListArray(args.LIST, util);
+      if (itemsHTML[1] === 0 || list === null) return;
       const newContainer = document.createElement("div");
       newContainer.className = listDocs.contain;
 
@@ -485,7 +485,7 @@
         `${((itemsHTML[1] * 24) / args.NUM) + 24}px`;
       newContainer.style.maxWidth = parentList.style.width;
       newContainer.style.maxHeight = list.style.maxHeight;
-      newContainer.style.overflow = "scroll"; // always use scroll
+      newContainer.style.overflow = "scroll";
       newContainer.style.position = "relative";
 
       newContainer.innerHTML = itemsHTML[0];
@@ -525,16 +525,19 @@
 
     getListArray(list, util) {
       const items = util.target.lookupVariableById(list).value;
+      if (items.length === 0) return ["", 0];
       let allItems = document.querySelectorAll(`[data-id="${list}"]`);
       allItems = allItems[allItems.length - 1];
       allItems = allItems.querySelectorAll(`[class^="${listDocs.ind}"`);
       let html = "";
-      const elementClasses = {
-        row : allItems[0].parentNode.className,
-        index : allItems[0].className,
-        outerV : allItems[0].nextElementSibling.className,
-        innerV : allItems[0].nextElementSibling.children[0].className
-      };
+      try {
+        const elementClasses = {
+          row : allItems[0].parentNode.className,
+          index : allItems[0].className,
+          outerV : allItems[0].nextElementSibling.className,
+          innerV : allItems[0].nextElementSibling.children[0].className
+        };
+      } catch { return ["", 0] }
       for (let i = 0; i < items.length; i++) {
         const value = allItems[i] ? allItems[i].textContent : i + 1;
         html += `
@@ -704,7 +707,7 @@
         this.changeMonitorVisibility(list, false);
         setTimeout(() => {
           this.changeMonitorVisibility(list, true);
-          resolve();
+          setTimeout(() => { resolve() }, 0);
         }, 25);
       });
     }
@@ -825,12 +828,8 @@
         } else if (setEffect === "scale") {
           const arr = valueWithUnits.split(", ");
           return arr[args.EFFECT.includes("x") ? 0 : 1] * 100;
-        } else {
-          return numericValue;
-        }
-      } else {
-        return defaultV;
-      }
+        } else { return numericValue }
+      } else { return defaultV }
     }
 
     resetEffect(args, util) {

From b9a36f59c5c965aa462b97dbd97ae0611619f9ff Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sat, 6 Jan 2024 01:35:26 -0800
Subject: [PATCH 05/13] Update Sty-Lists.js

---
 extensions/SharkPool/Sty-Lists.js | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index 40ae88f73e..c19581196b 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,7 +3,7 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 1.1.1
+// Version 1.1.2
 
 (function (Scratch) {
   "use strict";
@@ -467,7 +467,7 @@
     renderList(args, util) {
       let list = this.lookForList(args.LIST, util);
       if (!list) return;
-      const footer = runtime.isPackaged ? document.querySelector(`[data-id=${list}] [class^="${listDocs.foot}"]`).getBoundingClientRect() : "";
+      let footer = runtime.isPackaged ? document.querySelector(`[data-id=${list}] ${listDocs.grid}`) : "";
       args.NUM = args.NUM > 0 ? Math.round(args.NUM) : 1;
       const parentList = document.querySelector(`[data-id=${list}] ${listDocs.grid}`);
       if (parentList === null) return;
@@ -481,7 +481,7 @@
 
       newContainer.setAttribute("role", "rowgroup");
       newContainer.style.width = "auto";
-      newContainer.style.height = runtime.isPackaged ? `${(footer.top - (footer.height * 2)) / 2}px` :
+      newContainer.style.height = runtime.isPackaged && footer ? window.getComputedStyle(footer).height :
         `${((itemsHTML[1] * 24) / args.NUM) + 24}px`;
       newContainer.style.maxWidth = parentList.style.width;
       newContainer.style.maxHeight = list.style.maxHeight;
@@ -525,11 +525,11 @@
 
     getListArray(list, util) {
       const items = util.target.lookupVariableById(list).value;
-      if (items.length === 0) return ["", 0];
       let allItems = document.querySelectorAll(`[data-id="${list}"]`);
       allItems = allItems[allItems.length - 1];
       allItems = allItems.querySelectorAll(`[class^="${listDocs.ind}"`);
       let html = "";
+      if (items.length === 0) return ["", 0];
       try {
         const elementClasses = {
           row : allItems[0].parentNode.className,
@@ -537,17 +537,17 @@
           outerV : allItems[0].nextElementSibling.className,
           innerV : allItems[0].nextElementSibling.children[0].className
         };
+        for (let i = 0; i < items.length; i++) {
+          const value = allItems[i] ? allItems[i].textContent : i + 1;
+          html += `
+            <div class="${elementClasses.row}" style="height: 24px; left: 0px; position: absolute; top: ${i * 24}px; width: 100%;">
+              <div class="${elementClasses.index}">${value}</div>
+              <div class="${elementClasses.outerV}" dataindex="${i}" style="background: rgb(252, 102, 44);">
+                <div class="${elementClasses.innerV}">${items[i]}</div>
+              </div>
+            </div>`;
+        }
       } catch { return ["", 0] }
-      for (let i = 0; i < items.length; i++) {
-        const value = allItems[i] ? allItems[i].textContent : i + 1;
-        html += `
-          <div class="${elementClasses.row}" style="height: 24px; left: 0px; position: absolute; top: ${i * 24}px; width: 100%;">
-            <div class="${elementClasses.index}">${value}</div>
-            <div class="${elementClasses.outerV}" dataindex="${i}" style="background: rgb(252, 102, 44);">
-              <div class="${elementClasses.innerV}">${items[i]}</div>
-            </div>
-          </div>`;
-      }
       return [html, items.length];
     }
 
@@ -707,7 +707,7 @@
         this.changeMonitorVisibility(list, false);
         setTimeout(() => {
           this.changeMonitorVisibility(list, true);
-          setTimeout(() => { resolve() }, 0);
+          setTimeout(() => { resolve() }, 1);
         }, 25);
       });
     }

From dbc75d49e7a08519e30e05bbdf074d2c6422add0 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sat, 6 Jan 2024 13:58:47 -0800
Subject: [PATCH 06/13] Update Sty-Lists.js

---
 extensions/SharkPool/Sty-Lists.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index c19581196b..9fc80514ed 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,7 +3,7 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 1.1.2
+// Version 1.1.3
 
 (function (Scratch) {
   "use strict";
@@ -574,7 +574,7 @@
       ]));
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      if (list.classList.contains("blocklyDraggable")) return;
+      if (!list || (list && list.classList.contains("blocklyDraggable"))) return;
       if (!runtime.isPackaged) {
         list = list.querySelector(`[class^="${listDocs.body}"]`);
         list.style.cssText = `width: ${args.WIDTH}px; height: ${args.HEIGHT}px;`;
@@ -591,7 +591,7 @@
       if (!list) return "";
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      if (list.classList.contains("blocklyDraggable")) return "";
+      if (!list || (list && list.classList.contains("blocklyDraggable"))) return "";
       list = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
       return parseFloat(list.style[args.THING]);
     }
@@ -649,7 +649,7 @@
       if (!list) return;
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      if (list.classList.contains("blocklyDraggable")) return;
+      if (!list || (list && list.classList.contains("blocklyDraggable"))) return;
 
       const box = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
       const sizeOffset = [parseFloat(box.style.width), parseFloat(box.style.height)];
@@ -672,7 +672,7 @@
       if (!list) return "";
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      if (list.classList.contains("blocklyDraggable")) return "";
+      if (!list || (list && list.classList.contains("blocklyDraggable"))) return "";
 
       const box = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
       const sizeOffset = [parseFloat(box.style.width), parseFloat(box.style.height)];
@@ -781,7 +781,7 @@
       if (!list) return;
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
-      if (list.classList.contains("blocklyDraggable")) return;
+      if (!list || (list && list.classList.contains("blocklyDraggable"))) return;
       let existingTransform = list.style.transform || "";
       existingTransform = existingTransform.replace(/scale\([^)]*\)/g, "");
       list.style.transform = `${existingTransform} scale(${args.x / 100}, ${args.y / 100})`;

From ecaf5f5b238add7c27d3c90df4f823b02774b913 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sat, 3 Feb 2024 19:36:53 -0800
Subject: [PATCH 07/13] Update Sty-Lists.js

---
 extensions/SharkPool/Sty-Lists.js | 101 ++++++++++++++++--------------
 1 file changed, 53 insertions(+), 48 deletions(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index 9fc80514ed..0c0b11910d 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,7 +3,7 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 1.1.3
+// Version 1.1.4
 
 (function (Scratch) {
   "use strict";
@@ -19,6 +19,18 @@
     "Handwriting", "Marker", "Curly", "Pixel"
   ];
 
+  const xmlEscape = function (unsafe) {
+    return unsafe.replace(/[<>&'"]/g, c => {
+      switch (c) {
+        case "<": return "&lt;";
+        case ">": return "&gt;";
+        case "&": return "&amp;";
+        case "'": return "&apos;";
+        case "\"": return "&quot;";
+      }
+    });
+  };
+
   let listDocs;
   if (runtime.isPackaged) {
     listDocs = {
@@ -538,12 +550,12 @@
           innerV : allItems[0].nextElementSibling.children[0].className
         };
         for (let i = 0; i < items.length; i++) {
-          const value = allItems[i] ? allItems[i].textContent : i + 1;
+          const value = allItems[i] ? xmlEscape(allItems[i].textContent) : i + 1;
           html += `
             <div class="${elementClasses.row}" style="height: 24px; left: 0px; position: absolute; top: ${i * 24}px; width: 100%;">
               <div class="${elementClasses.index}">${value}</div>
               <div class="${elementClasses.outerV}" dataindex="${i}" style="background: rgb(252, 102, 44);">
-                <div class="${elementClasses.innerV}">${items[i]}</div>
+                <div class="${elementClasses.innerV}">${xmlEscape(items[i])}</div>
               </div>
             </div>`;
         }
@@ -680,11 +692,8 @@
       if (styleAttribute) {
         const match = styleAttribute.match(/transform\s*:\s*translate\((-?\d+(?:\.\d+)?px),\s*(-?\d+(?:\.\d+)?px)\)/);
         if (match) {
-          if (args.POSITION === "x") {
-            return parseInt(match[1]) - canvas[0] + (sizeOffset[0] / 2);
-          } else {
-            return ((parseInt(match[2]) * -1) + canvas[1]) - (sizeOffset[1] / 2);
-          }
+          if (args.POSITION === "x") return parseInt(match[1]) - canvas[0] + (sizeOffset[0] / 2);
+          else return ((parseInt(match[2]) * -1) + canvas[1]) - (sizeOffset[1] / 2);
         }
       }
       return "";
@@ -727,7 +736,7 @@
       } else {
         label = document.querySelector(`[data-id=${list}] ${listDocs.pkg1}[class^="${listDocs.foot}"] ${listDocs.span}`);
       }
-      if (label) label.textContent = args.NAME;
+      if (label) label.textContent = xmlEscape(args.NAME);
     }
 
     resetEffects(list, currentTransform) {
@@ -750,20 +759,15 @@
       let currentFilterEffect = list.style.filter || "";
       let setEffect = EFFECT;
       let amountIn = AMOUNT;
-      if (setEffect === "saturation") {
-        setEffect = "saturate";
-      } else if (setEffect === "hue") {
-        setEffect = "hue-rotate";
-      } else if (setEffect === "direction") {
+      if (setEffect === "saturation") setEffect = "saturate";
+      else if (setEffect === "hue") setEffect = "hue-rotate";
+      else if (setEffect === "direction") {
         setEffect = "rotate";
         amountIn = AMOUNT - 90;
-      } else if (setEffect === "brightness") {
-        amountIn = AMOUNT + 100;
-      } else if (setEffect === "skew x") {
-        setEffect = "skewX";
-      } else if (setEffect === "skew y") {
-        setEffect = "skewY";
       }
+      else if (setEffect === "brightness") amountIn = AMOUNT + 100;
+      else if (setEffect === "skew x") setEffect = "skewX";
+      else if (setEffect === "skew y") setEffect = "skewY";
       const regex = new RegExp(`${setEffect}\\([^)]+\\)`, "g");
       currentTransform = currentTransform.replace(regex, "").trim();
       currentFilterEffect = currentFilterEffect.replace(regex, "").trim();
@@ -796,23 +800,16 @@
       const currentFilterEffect = list.style.filter || "";
       const setEffect = {
         saturation: "saturate",
-        hue: "hue-rotate",
-        direction: "rotate",
-        "scale x": "scale",
-        "scale y": "scale",
+        hue: "hue-rotate", direction: "rotate",
+        "scale x": "scale", "scale y": "scale",
         brightness: "brightness",
         opacity: "opacity",
-        "skew x": "skewX",
-        "skew y": "skewY",
+        "skew x": "skewX", "skew y": "skewY",
       }[args.EFFECT] || args.EFFECT;
       const defaultV = {
-        saturation: 100,
-        hue: 0,
-        direction: 90,
-        "scale x": 100,
-        "scale y": 100,
-        brightness: 0,
-        opacity: 100,
+        saturation: 100, hue: 0, direction: 90,
+        "scale x": 100, "scale y": 100,
+        brightness: 0, opacity: 100,
       }[args.EFFECT] || 0;
 
       const regex = new RegExp(`${setEffect}\\(([^)]+)\\)`);
@@ -821,11 +818,9 @@
       if (filterMatch || transformMatch) {
         const valueWithUnits = (filterMatch || transformMatch)[1];
         const numericValue = parseFloat(valueWithUnits.replace(/[^0-9.-]/g, ""));
-        if (setEffect === "brightness") {
-          return numericValue - 100;
-        } else if (setEffect === "rotate") {
-          return numericValue + 90;
-        } else if (setEffect === "scale") {
+        if (setEffect === "brightness") return numericValue - 100;
+        else if (setEffect === "rotate") return numericValue + 90;
+        else if (setEffect === "scale") {
           const arr = valueWithUnits.split(", ");
           return arr[args.EFFECT.includes("x") ? 0 : 1] * 100;
         } else { return numericValue }
@@ -861,7 +856,7 @@
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
       const targetElement = list.querySelectorAll(`[class^="${listDocs.body}"] [class^="${listDocs.value}"]`)[args.NUM - 1];
-      if (targetElement) targetElement.style.background = args.COLOR;
+      if (targetElement) targetElement.style.background = xmlEscape(args.COLOR);
     }
 
     setLabel(args, util) {
@@ -871,27 +866,37 @@
       list = document.querySelectorAll(`[data-id=${list}]`);
       list = list[list.length - 1];
       const targetElement = list.querySelectorAll(`[class^="${listDocs.ind}"`)[args.NUM - 1];
-      if (targetElement) targetElement.textContent = args.VALUE;
+      if (targetElement) targetElement.textContent = xmlEscape(args.VALUE);
     }
 
     makeList(args, util) {
       let list = this.lookForList(args.LIST, util);
       if (list) return;
       if (args.TYPE === "for this sprite only") {
-        //creating this kind of list doesnt show until you switch back from editing a sprite to another for some reason...
-        return util.target.createVariable(this.generateId(), args.LIST, "list");
+        util.target.createVariable(this.generateId(), args.LIST, "list");
       } else {
         runtime.getTargetForStage().createVariable(this.generateId(), args.LIST, "list");
       }
+      return this.refresh();
+    }
+
+    refresh() {
+      if (!runtime.isPackaged) {
+        Scratch.vm.emitWorkspaceUpdate();
+        window.ScratchBlocks.getMainWorkspace().toolboxRefreshEnabled_ = true;
+        window.ScratchBlocks.getMainWorkspace().refreshToolboxSelection_();
+        window.ScratchBlocks.getMainWorkspace().toolboxRefreshEnabled_ = false;
+        setTimeout(function() { vm.runtime.requestBlocksUpdate() }, 10);
+      }
     }
 
     generateId() {
-      const chars = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "/", "|", ",", ".", "{", "}", "[", "]", "(", ")", "+", "-", "!", "?", "`"];
-      const array = Array.from(Array(20).keys());
-      const normalArray = array.map(() => {
-        return chars[Math.round(Math.random() * (chars.length - 1))]
-      })
-      return normalArray.join("");
+      const soup = "!#%()*+,-./:;=?@[]^_`{|}~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+      const id = [];
+      for (let i = 0; i < 20; i++) {
+        id[i] = soup.charAt(Math.random() * soup.length);
+      }
+      return id.join("");
     }
   }
 

From 8e0238677b0abb7d837c1a28a987b8fa1a66735e Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sun, 4 Feb 2024 14:41:08 -0800
Subject: [PATCH 08/13] Update Sty-Lists.js

---
 extensions/SharkPool/Sty-Lists.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index 0c0b11910d..014bfc4a37 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -20,7 +20,7 @@
   ];
 
   const xmlEscape = function (unsafe) {
-    return unsafe.replace(/[<>&'"]/g, c => {
+    return Scratch.Cast.toString(unsafe).replace(/[<>&'"]/g, c => {
       switch (c) {
         case "<": return "&lt;";
         case ">": return "&gt;";

From a6505526ed3b3bc93e0dfdabbebd41663fa8a113 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sun, 21 Jul 2024 21:13:25 -0700
Subject: [PATCH 09/13] Sty-Lists -- V2.0 Rewrite

---
 extensions/SharkPool/Sty-Lists.js | 1015 ++++++++++++-----------------
 1 file changed, 411 insertions(+), 604 deletions(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index 014bfc4a37..9ac3633521 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,14 +3,14 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 1.1.4
+// Version 2.0.0
 
 (function (Scratch) {
   "use strict";
   if (!Scratch.extensions.unsandboxed) throw new Error("Sty-Lists must run unsandboxed!");
 
   const menuIconURI =
-"data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHdpZHRoPSI2Mi4xNDI4NiIgaGVpZ2h0PSI2Mi4xNDI4NiIgdmlld0JveD0iMCwwLDYyLjE0Mjg2LDYyLjE0Mjg2Ij48ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgtMjA4LjkyODU3LC0xNDguOTI4NTcpIj48ZyBkYXRhLXBhcGVyLWRhdGE9InsmcXVvdDtpc1BhaW50aW5nTGF5ZXImcXVvdDs6dHJ1ZX0iIGZpbGwtcnVsZT0ibm9uemVybyIgc3Ryb2tlLWxpbmVjYXA9ImJ1dHQiIHN0cm9rZS1saW5lam9pbj0ibWl0ZXIiIHN0cm9rZS1taXRlcmxpbWl0PSIxMCIgc3Ryb2tlLWRhc2hhcnJheT0iIiBzdHJva2UtZGFzaG9mZnNldD0iMCIgc3R5bGU9Im1peC1ibGVuZC1tb2RlOiBub3JtYWwiPjxwYXRoIGQ9Ik0yMDguOTI4NTcsMTgwYzAsLTE3LjE2MDI3IDEzLjkxMTE2LC0zMS4wNzE0MyAzMS4wNzE0MywtMzEuMDcxNDNjMTcuMTYwMjcsMCAzMS4wNzE0MywxMy45MTExNiAzMS4wNzE0MywzMS4wNzE0M2MwLDE3LjE2MDI3IC0xMy45MTExNiwzMS4wNzE0MyAtMzEuMDcxNDMsMzEuMDcxNDNjLTE3LjE2MDI3LDAgLTMxLjA3MTQzLC0xMy45MTExNiAtMzEuMDcxNDMsLTMxLjA3MTQzeiIgZmlsbD0iI2NjNDYwMiIgc3Ryb2tlPSIjMDAwMDAwIiBzdHJva2Utd2lkdGg9IjAiLz48cGF0aCBkPSJNMjEyLjQ5Mjg4LDE4MGMwLC0xNS4xOTE3NiAxMi4zMTUzNiwtMjcuNTA3MTIgMjcuNTA3MTIsLTI3LjUwNzEyYzE1LjE5MTc2LDAgMjcuNTA3MTIsMTIuMzE1MzYgMjcuNTA3MTIsMjcuNTA3MTJjMCwxNS4xOTE3NiAtMTIuMzE1MzYsMjcuNTA3MTIgLTI3LjUwNzEyLDI3LjUwNzEyYy0xNS4xOTE3NiwwIC0yNy41MDcxMiwtMTIuMzE1MzYgLTI3LjUwNzEyLC0yNy41MDcxMnoiIGZpbGw9IiNmZjY2MWEiIHN0cm9rZT0ibm9uZSIgc3Ryb2tlLXdpZHRoPSIwIi8+PHBhdGggZD0iTTI1My4xNjc2NiwxODcuNTc0NDFjMCwwLjAxNTY1IC0wLjAwMzY3LDAuMDMwODMgLTAuMDA0NiwwLjA0NjQ3djQuNzYzNzljMC4wMDAwMSwwLjU3MzggLTAuNDYzMjYsMS4wMzk5NSAtMS4wMzcwNSwxLjA0MzV2MC4wMDA5MmgtMTYuMjg3MjZ2LTAuMDAwNDVjLTAuNTczNzksLTAuMDAzNTQgLTEuMDM3MDYsLTAuNDY5NyAtMS4wMzcwNSwtMS4wNDM1aC0wLjAwNTA2di00Ljc1NDU5Yy0wLjAwMDkyLC0wLjAxODg3IC0wLjAwNTUyLC0wLjAzNjM1IC0wLjAwNTUyLC0wLjA1NTY3YzAuMDAwMjYsLTAuNTc2NDUgMC40Njc1LC0xLjA0MzY5IDEuMDQzOTUsLTEuMDQzOTRsMC4wMDQxNCwwLjAwMDQ2di0wLjAwMDQ2bDE2LjI4NzI0LDAuMDAwNDZjMC41NzUzMywwLjAwMTAyIDEuMDQxMTgsMC40Njc3IDEuMDQxMTgsMS4wNDMwMnpNMjI5LjkwMzkxLDE4Ni44MzU4MmMwLjE5NTY0LDAuMTk1OCAwLjMwNTQxLDAuNDYxMzQgMC4zMDUxNywwLjczODEzdjQuODA5OGMtMC4wMDAyNiwwLjU3NjQ1IC0wLjQ2NzQ5LDEuMDQzNjkgLTEuMDQzOTQsMS4wNDM5NWgtNC44MTAyNmMtMC41NzYzNywtMC4wMDAyNiAtMS4wNDM0OSwtMC40Njc1NyAtMS4wNDM0OSwtMS4wNDM5NXYtNC44MDk4YzAuMDAwMjYsLTAuNTc2NDUgMC40Njc1LC0xLjA0MzY5IDEuMDQzOTUsLTEuMDQzOTRoNC44MTA3MWMwLjI3Njc4LDAgMC41NDIyMiwwLjExMDAxIDAuNzM3ODYsMC4zMDU4MXpNMjUzLjE2NzY2LDE3Ni4wNzY3MmMwLDAuMDE1NjUgLTAuMDAzNjcsMC4wMzA4MiAtMC4wMDQ2LDAuMDQ2NDd2NC43NjM3OWMwLjAwMDAxLDAuNTczOCAtMC40NjMyNiwxLjAzOTk0IC0xLjAzNzA1LDEuMDQzNDl2MC4wMDA5MmgtMTYuMjg3MjZ2LTAuMDAwNDVjLTAuNTczNzksLTAuMDAzNTQgLTEuMDM3MDYsLTAuNDY5NyAtMS4wMzcwNSwtMS4wNDM0OWgtMC4wMDUwNnYtNC43NTQ1OGMtMC4wMDA5MiwtMC4wMTg4NyAtMC4wMDU1MiwtMC4wMzYzNSAtMC4wMDU1MiwtMC4wNTU2OGMwLjAwMDI2LC0wLjU3NjQ1IDAuNDY3NSwtMS4wNDM2OSAxLjA0Mzk1LC0xLjA0Mzk0bDAuMDA0MTQsMC4wMDA0NnYtMC4wMDA0NmwxNi4yODcyNCwwLjAwMDQ2YzAuNTc1MzMsMC4wMDEwMiAxLjA0MTE4LDAuNDY3NyAxLjA0MTE4LDEuMDQzMDN6TTIyOS45MDM5MSwxNzUuMzM4MTNjMC4xOTU2NCwwLjE5NTggMC4zMDU0MSwwLjQ2MTM0IDAuMzA1MTcsMC43MzgxM3Y0LjgwOThjLTAuMDAwMjYsMC41NzY0NSAtMC40Njc0OSwxLjA0MzcgLTEuMDQzOTQsMS4wNDM5NWgtNC44MTAyNmMtMC41NzYzNywtMC4wMDAyNiAtMS4wNDM0OSwtMC40Njc1OCAtMS4wNDM0OSwtMS4wNDM5NXYtNC44MDk4YzAuMDAwMjYsLTAuNTc2NDUgMC40Njc1LC0xLjA0MzcgMS4wNDM5NSwtMS4wNDM5NWg0LjgxMDcxYzAuMjc2NzgsMCAwLjU0MjIyLDAuMTEwMDIgMC43Mzc4NiwwLjMwNTgyek0yMzQuNzk2MiwxNjkuNDI0NzJ2LTQuNzU1MDVjLTAuMDAwOTIsLTAuMDE4ODcgLTAuMDA1NTIsLTAuMDM2MzUgLTAuMDA1NTIsLTAuMDU1NjdjMC4wMDAyNiwtMC41NzY0NSAwLjQ2NzUsLTEuMDQzNjkgMS4wNDM5NSwtMS4wNDM5NWwwLjAwNDE0LDAuMDAwNDV2LTAuMDAwNDVoMTYuMjg3MjZ2MC4wMDA0NWMwLjU3NTQ3LDAuMDAxMjYgMS4wNDEzOSwwLjQ2ODAxIDEuMDQxNjUsMS4wNDM1YzAsMC4wMTU2NSAtMC4wMDM2NywwLjAzMDgzIC0wLjAwNDYsMC4wNDY0N3Y0Ljc2Mzc5YzAuMDAwMDEsMC41NzM4IC0wLjQ2MzI2LDEuMDM5OTQgLTEuMDM3MDUsMS4wNDM0OXYwLjAwMDkyaC0xNi4yODcyNnYtMC4wMDA0NmMtMC41NzM3OSwtMC4wMDM1NCAtMS4wMzcwNiwtMC40Njk2OSAtMS4wMzcwNSwtMS4wNDM0OWgtMC4wMDUwNnpNMjI5LjkwNDA1LDE2My44NzU3M2MwLjE5NTY2LDAuMTk1ODMgMC4zMDU0LDAuNDYxNDQgMC4zMDUwMywwLjczODI2djQuODA5OGMtMC4wMDAyNiwwLjU3NjQ1IC0wLjQ2NzQ5LDEuMDQzNjkgLTEuMDQzOTQsMS4wNDM5NWgtNC44MTAyNmMtMC41NzYzNywtMC4wMDAyNiAtMS4wNDM0OSwtMC40Njc1NyAtMS4wNDM0OSwtMS4wNDM5NXYtNC44MDk4YzAuMDAwMjYsLTAuNTc2NDUgMC40Njc1LC0xLjA0MzY5IDEuMDQzOTUsLTEuMDQzOTVoNC44MTA3MWMwLjI3NjgzLC0wLjAwMDEyIDAuNTQyMzQsMC4xMDk4NSAwLjczOCwwLjMwNTY4eiIgZmlsbD0iI2ZmZmZmZiIgc3Ryb2tlPSJub25lIiBzdHJva2Utd2lkdGg9IjEiLz48cGF0aCBkPSJNMjU1LjY5MDQxLDE4MS45OTEzYzAuNTIwODgsMC4wMDAyMyAwLjk0MzA5LDAuNDIyNDQgMC45NDMzMiwwLjk0MzMxdjQuMjQyNjJ2Ni4yMzM1OWgtNi4yMzM2bC00LjI0NDcxLC0wLjAwMDQxYy0wLjUyLC0wLjAwMTE1IC0wLjk0MSwtMC4zMzMwNCAtMC45NDEyMywtMC44NTMwNWMwLC0wLjAxNDE0IDAuMDA0MTYsLTQuNDM2NDEgMC4wMDQxNiwtNC40MzY0MWMtMC4wMDAwMSwtMC41MTg0OCAwLjQ2MzUzLC0wLjk4NDYzIDAuOTgyLC0wLjk4NzgzbDQuMTk5NzcsMC4wNDQxbDAuMDAwNDEsLTQuMjM4ODhjMC4wMDMyLC0wLjUxODQ3IDAuNDI0NDIsLTAuOTM3MDggMC45NDI5LC0wLjkzNzA3YzAsMCA0LjMyOTUxLC0wLjAwOTk3IDQuMzQ2OTcsLTAuMDA5OTd6IiBmaWxsPSIjZmZmZmZmIiBzdHJva2U9IiNmZjY2MWEiIHN0cm9rZS13aWR0aD0iNiIvPjxwYXRoIGQ9Ik0yNTUuNjkwNDEsMTgxLjk5MTNjMC41MjA4OCwwLjAwMDIzIDAuOTQzMDksMC40MjI0NCAwLjk0MzMyLDAuOTQzMzF2NC4yNDI2Mmw0LjIzODg3LDAuMDAwNDFjMC41MTg0NywwLjAwMzIgMC45MzcwOCwwLjQyNDQxIDAuOTM3MDgsMC45NDI4OWMwLDAgMC4wMDk5Nyw0LjMyOTUyIDAuMDA5OTcsNC4zNDY5N2MtMC4wMDAyMywwLjUyMDg4IC0wLjQyMjQzLDAuOTQzMDggLTAuOTQzMzEsMC45NDMzMWgtNC4yNDI2MWwtMC4wMDA0Miw0LjI0NDcxYy0wLjAwMTE1LDAuNTIgLTAuNDY3ODIsMC45NDEgLTAuOTg3ODIsMC45NDEyM2MtMC4wMTQxNCwwIC00LjI1NjcsLTAuMDA0MTYgLTQuMjU2NywtMC4wMDQxNmMtMC41MTg0OCwwLjAwMDAxIC0wLjk4NDYyLC0wLjQxODYgLTAuOTg3ODIsLTAuOTM3MDdsLTAuMDAwODMsLTQuMjQ0NzFsLTQuMjQ0NzEsLTAuMDAwNDFjLTAuNTIsLTAuMDAxMTUgLTAuOTQxLC0wLjMzMzA0IC0wLjk0MTIzLC0wLjg1MzA1YzAsLTAuMDE0MTQgMC4wMDQxNiwtNC40MzY0MSAwLjAwNDE2LC00LjQzNjQxYy0wLjAwMDAxLC0wLjUxODQ4IDAuNDYzNTMsLTAuOTg0NjMgMC45ODIwMSwtMC45ODc4M2w0LjE5OTc3LDAuMDQ0MWwwLjAwMDQxLC00LjIzODg4YzAuMDAzMiwtMC41MTg0NyAwLjQyNDQyLC0wLjkzNzA4IDAuOTQyOSwtMC45MzcwN2MwLDAgNC4zMjk1MSwtMC4wMDk5NyA0LjM0Njk3LC0wLjAwOTk3eiIgZmlsbD0iI2ZmZmZmZiIgc3Ryb2tlPSIjZmY2NjFhIiBzdHJva2Utd2lkdGg9IjAiLz48L2c+PC9nPjwvc3ZnPg==";
+"data:image/svg+xml;base64,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";
 
   const vm = Scratch.vm;
   const runtime = vm.runtime;
@@ -18,21 +18,8 @@
     "Scratch", "Sans Serif", "Serif",
     "Handwriting", "Marker", "Curly", "Pixel"
   ];
-
-  const xmlEscape = function (unsafe) {
-    return Scratch.Cast.toString(unsafe).replace(/[<>&'"]/g, c => {
-      switch (c) {
-        case "<": return "&lt;";
-        case ">": return "&gt;";
-        case "&": return "&amp;";
-        case "'": return "&apos;";
-        case "\"": return "&quot;";
-      }
-    });
-  };
-
   let listDocs;
-  if (runtime.isPackaged) {
+  if (typeof scaffolding !== "undefined") {
     listDocs = {
       body : "sc-monitor-root",
       value : "sc-monitor-row-value-outer", value2 : "sc-monitor-row-value-inner",
@@ -53,7 +40,26 @@
       row : "monitor_list-row", span : "span"
     };
   }
+  let visualLists = {};
+
   class SPlistMonitors {
+    constructor() {
+      runtime.on("MONITORS_UPDATE", () =>{
+        for (const [id, { util }] of Object.entries(visualLists)) {
+          const monitor = document.querySelector(`div[data-id="${id}"][class*="monitor"]`);
+          if (!monitor) delete visualLists[id];
+          else {
+            const monBody = typeof scaffolding !== "undefined" ? monitor : monitor.querySelector(`div[class^="${listDocs.body}"]`);
+            this.stretchList({
+              LIST: id, WIDTH: parseFloat(monBody.style.width),
+              HEIGHT: parseFloat(monBody.style.height), SECRET: true
+            }, util);
+            const columns = monitor.getAttribute("SPcolumnCnt") || 1;
+            if (columns > 1) this.renderList({ LIST: id, NUM: columns, SECRET: true }, util);
+          }
+        }
+      });
+    }
     getInfo() {
       return {
         id: "SPlistMonitors",
@@ -68,10 +74,7 @@
             blockType: Scratch.BlockType.BOOLEAN,
             text: "does [LIST] exist?",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                defaultValue: "my list"
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, defaultValue: "my list" },
             },
           },
           {
@@ -79,10 +82,7 @@
             blockType: Scratch.BlockType.BOOLEAN,
             text: "is [LIST] showing?",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
             },
           },
           {
@@ -90,14 +90,16 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "create list named [LIST] [TYPE]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                defaultValue: "my list",
-              },
-              TYPE: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "listTypes",
-              }
+              LIST: { type: Scratch.ArgumentType.STRING, defaultValue: "my list" },
+              TYPE: { type: Scratch.ArgumentType.STRING, menu: "listTypes" }
+            },
+          },
+          {
+            opcode: "deleteList",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "delete list [LIST]",
+            arguments: {
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           "---",
@@ -106,14 +108,8 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "render [LIST] with [NUM] columns",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
-              NUM: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 2,
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              NUM: { type: Scratch.ArgumentType.NUMBER, defaultValue: 2 }
             },
           },
           {
@@ -121,10 +117,7 @@
             blockType: Scratch.BlockType.REPORTER,
             text: "# of columns in [LIST]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           "---",
@@ -133,18 +126,9 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "stretch [LIST] to width: [WIDTH] and height: [HEIGHT]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
-              WIDTH: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 200,
-              },
-              HEIGHT: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 200,
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              WIDTH: { type: Scratch.ArgumentType.NUMBER, defaultValue: 200 },
+              HEIGHT: { type: Scratch.ArgumentType.NUMBER, defaultValue: 200 }
             },
           },
           {
@@ -152,14 +136,8 @@
             blockType: Scratch.BlockType.REPORTER,
             text: "get [THING] of [LIST]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
-              THING: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "ATTS",
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              THING: { type: Scratch.ArgumentType.STRING, menu: "ATTS" }
             },
           },
           "---",
@@ -168,56 +146,20 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "turn [THING] in [LIST] [ON_OFF]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
-              THING: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "listUtils",
-              },
-              ON_OFF: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "ON_OFF",
-              },
-            },
-          },
-          {
-            opcode: "formatItems",
-            blockType: Scratch.BlockType.COMMAND,
-            text: "align item text to [ALIGN] in [LIST]",
-            arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
-              ALIGN: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "ALIGN",
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              THING: { type: Scratch.ArgumentType.STRING, menu: "listUtils" },
+              ON_OFF: { type: Scratch.ArgumentType.STRING, menu: "ON_OFF" }
             },
           },
-          {
-            blockType: Scratch.BlockType.XML,
-            xml: "<sep gap=\"6\"/><label text=\"Positioning\"/><sep gap=\"-12\"/><sep gap=\"12\"/>",
-          },
+          { blockType: Scratch.BlockType.LABEL, text: "Positioning" },
           {
             opcode: "setPosition",
             blockType: Scratch.BlockType.COMMAND,
             text: "set position of [LIST] to x: [x] y: [y]",
             arguments: {
-              x: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0,
-              },
-              y: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 0,
-              },
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              x: { type: Scratch.ArgumentType.NUMBER, defaultValue: 0 },
+              y: { type: Scratch.ArgumentType.NUMBER, defaultValue: 0 }
             },
           },
           {
@@ -225,14 +167,8 @@
             blockType: Scratch.BlockType.REPORTER,
             text: "current [POSITION] of [LIST]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
-              POSITION: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "POSITIONS",
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              POSITION: { type: Scratch.ArgumentType.STRING, menu: "POSITIONS" }
             },
           },
           "---",
@@ -241,29 +177,26 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "set scrollbar position of [LIST] to [SCROLL]%",
             arguments: {
-              SCROLL: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 50,
-              },
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              SCROLL: { type: Scratch.ArgumentType.NUMBER, defaultValue: 50 }
             },
           },
-          {
-            blockType: Scratch.BlockType.XML,
-            xml: "<sep gap=\"6\"/><label text=\"Effects\"/><sep gap=\"-12\"/><sep gap=\"12\"/>",
-          },
+          { blockType: Scratch.BlockType.LABEL, text: "Formatting and Effects" },
           {
             opcode: "resetAll",
             blockType: Scratch.BlockType.COMMAND,
             text: "reset all changes to [LIST]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+            },
+          },
+          {
+            opcode: "formatItems",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "align item text to [ALIGN] in [LIST]",
+            arguments: {
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              ALIGN: { type: Scratch.ArgumentType.STRING, menu: "ALIGN" }
             },
           },
           {
@@ -271,18 +204,9 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "set [DISPLAY] name of [LIST] to [NAME]",
             arguments: {
-              NAME: {
-                type: Scratch.ArgumentType.STRING,
-                defaultValue: "my cooler list",
-              },
-              DISPLAY: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "list_displays",
-              },
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              NAME: { type: Scratch.ArgumentType.STRING, defaultValue: "my cooler list" },
+              DISPLAY: { type: Scratch.ArgumentType.STRING, menu: "list_displays" },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           {
@@ -290,18 +214,9 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "set color of item # [NUM] in [LIST] to [COLOR]",
             arguments: {
-              NUM: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 1,
-              },
-              COLOR: {
-                type: Scratch.ArgumentType.COLOR,
-                defaultValue: "#0000ff",
-              },
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              NUM: { type: Scratch.ArgumentType.NUMBER, defaultValue: 1 },
+              COLOR: { type: Scratch.ArgumentType.COLOR, defaultValue: "#0000ff" },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           {
@@ -309,18 +224,9 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "set name of label # [NUM] in [LIST] to [VALUE]",
             arguments: {
-              NUM: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 1,
-              },
-              VALUE: {
-                type: Scratch.ArgumentType.STRING,
-                defaultValue: "item 1",
-              },
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              NUM: { type: Scratch.ArgumentType.NUMBER, defaultValue: 1 },
+              VALUE: { type: Scratch.ArgumentType.STRING, defaultValue: "item 1" },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           {
@@ -328,14 +234,8 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "set font of [LIST] to [FONT]",
             arguments: {
-              FONT: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "allFonts",
-              },
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              FONT: { type: Scratch.ArgumentType.STRING, menu: "allFonts" },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           "---",
@@ -344,10 +244,7 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "reset effects of [LIST]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           {
@@ -355,18 +252,9 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "set [EFFECT] of [LIST] to [AMOUNT]",
             arguments: {
-              AMOUNT: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 5,
-              },
-              EFFECT: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "EFFECTS",
-              },
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              AMOUNT: { type: Scratch.ArgumentType.NUMBER, defaultValue: 5 },
+              EFFECT: { type: Scratch.ArgumentType.STRING, menu: "EFFECTS" },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           {
@@ -374,18 +262,9 @@
             blockType: Scratch.BlockType.COMMAND,
             text: "scale [LIST] to x: [x] y: [y]",
             arguments: {
-              x: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 200,
-              },
-              y: {
-                type: Scratch.ArgumentType.NUMBER,
-                defaultValue: 100,
-              },
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
+              x: { type: Scratch.ArgumentType.NUMBER, defaultValue: 200 },
+              y: { type: Scratch.ArgumentType.NUMBER, defaultValue: 100 },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
           {
@@ -393,511 +272,439 @@
             blockType: Scratch.BlockType.REPORTER,
             text: "current [EFFECT] of [LIST]",
             arguments: {
-              LIST: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "lists"
-              },
-              EFFECT: {
-                type: Scratch.ArgumentType.STRING,
-                menu: "ALL_EFFECTS",
-              },
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              EFFECT: { type: Scratch.ArgumentType.STRING, menu: "ALL_EFFECTS" }
             },
           }
         ],
         menus: {
-          ATTS: {
-            acceptReporters: true,
-            items: ["width", "height"]
-          },
-          lists: {
-            acceptReporters: true,
-            items: "getLists"
-          },
-          allFonts: {
-            acceptReporters: true,
-            items: "getFonts"
-          },
+          lists: { acceptReporters: true, items: "getLists" },
+          allFonts: { acceptReporters: true, items: "getFonts" },
+          EFFECTS: { acceptReporters: true, items: this.getEffects(false) },
+          ALL_EFFECTS: { acceptReporters: true, items: this.getEffects(true) },
           POSITIONS: ["x", "y"],
           list_displays: ["header", "footer"],
           listTypes: ["globally", "for this sprite only"],
           listUtils: ["click events", "text highlighting", "numbered items", "+ and = buttons"],
           ON_OFF: ["on", "off"],
-          ALIGN: {
-            acceptReporters: true,
-            items: ["left", "right", "center"]
-          },
-          EFFECTS: {
-            acceptReporters: true,
-            items: this.getEffects(false)
-          },
-          ALL_EFFECTS: {
-            acceptReporters: true,
-            items: this.getEffects(true)
-          }
+          ATTS: { acceptReporters: true, items: ["width", "height"] },
+          ALIGN: { acceptReporters: true, items: ["left", "right", "center"] }
         }
       }
     }
 
-    // Thank you SkyHigh173 for the getLists and find list functions :))
+    // Helper Funcs
     getLists() {
-      const globalLists = Object.values(
-        vm.runtime.getTargetForStage().variables
-      ).filter((x) => x.type == "list");
-      const localLists = Object.values(vm.editingTarget.variables).filter(
-        (x) => x.type == "list"
-      );
-      const uniqueLists = [...new Set([...globalLists, ...localLists])];
-      if (uniqueLists.length === 0) return [{ text: "make a list", value: "make a list" }];
-      return uniqueLists.map((i) => ({ text: i.name, value: i.id }));
-    }
-
-    lookForList(list, util) {
-      const byId = util.target.lookupVariableById(list);
-      if (byId && byId.type === "list") return JSON.stringify(byId.id);
-      const byName = util.target.lookupVariableByNameAndType(list, "list");
-      if (byName) return JSON.stringify(byName.id);
-      return;
+      const globalLists = Object.values(runtime.getTargetForStage().variables).filter((x) => x.type == "list");
+      const localLists = Object.values(vm.editingTarget.variables).filter((x) => x.type == "list");
+      const listMenu = [...new Set([...globalLists, ...localLists])];
+      if (listMenu.length === 0) return [{ text: "make a list", value: "make a list" }];
+      return listMenu.map((i) => ({ text: i.name, value: i.id }));
     }
 
     getFonts() {
-      const customFonts = Scratch.vm.runtime.fontManager
-        ? Scratch.vm.runtime.fontManager.getFonts().map((i) => ({
-        text: i.name, value: i.family })) : [];
+      const customFonts = runtime.fontManager ? runtime.fontManager.getFonts().map((i) => ({ text: i.name, value: i.family })) : [];
       return [...builtInFonts, ...customFonts];
     }
 
     getEffects(enable) {
       return [
-        "blur", "saturation", "contrast",
-        "brightness", "hue", "opacity",
-        "sepia", "invert", "direction",
+        "blur", "saturation", "contrast", "brightness",
+        "hue", "opacity", "sepia", "invert", "direction",
         ...(enable ? ["scale x", "scale y"] : []),
         "skew x", "skew y"
       ];
     }
 
-    renderList(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      let footer = runtime.isPackaged ? document.querySelector(`[data-id=${list}] ${listDocs.grid}`) : "";
-      args.NUM = args.NUM > 0 ? Math.round(args.NUM) : 1;
-      const parentList = document.querySelector(`[data-id=${list}] ${listDocs.grid}`);
-      if (parentList === null) return;
-      let listWidth = parseFloat(parentList.style.width) || parentList.getBoundingClientRect().width / 2;
-      listWidth = listWidth / args.NUM;
-      list = document.querySelector(`[data-id=${list}] ${listDocs.contain}`);
-      const itemsHTML = this.getListArray(args.LIST, util);
-      if (itemsHTML[1] === 0 || list === null) return;
-      const newContainer = document.createElement("div");
-      newContainer.className = listDocs.contain;
-
-      newContainer.setAttribute("role", "rowgroup");
-      newContainer.style.width = "auto";
-      newContainer.style.height = runtime.isPackaged && footer ? window.getComputedStyle(footer).height :
-        `${((itemsHTML[1] * 24) / args.NUM) + 24}px`;
-      newContainer.style.maxWidth = parentList.style.width;
-      newContainer.style.maxHeight = list.style.maxHeight;
-      newContainer.style.overflow = "scroll";
-      newContainer.style.position = "relative";
-
-      newContainer.innerHTML = itemsHTML[0];
-      list.parentNode.replaceChild(newContainer, list);
-      function reorderIntoColumns(numColumns) {
-        const items = newContainer.querySelectorAll(`[class^="${listDocs.row}"]`);
-        for (let i = 0; i < items.length; i++) {
-          const column = i % numColumns;
-          const top = Math.floor(i / numColumns) * items[0].offsetHeight;
-          items[i].style.top = top + "px";
-          items[i].style.left = (column * listWidth) + "px";
-          items[i].style.width = 100 / numColumns + "%";
-        }
+    getListID(idName, util) {
+      const byId = util.target.lookupVariableById(idName);
+      if (byId && byId.type === "list") return byId.id;
+      const byName = util.target.lookupVariableByNameAndType(idName, "list");
+      return byName ? byName.id : undefined;
+    }
+
+    getMonitor(id, util, returnID) {
+      id = this.getListID(id, util);
+      if (!id) return returnID ? {} : undefined;
+      if (returnID) return { id, listMon: document.querySelector(`div[data-id="${id}"][class*="monitor"]`) };
+      else return document.querySelector(`div[data-id="${id}"][class*="monitor"]`);
+    }
+
+    applyChanges(listMon, id) {
+      const list = visualLists[id];
+      if (list === undefined) return;
+      if (list.listenerApplied === undefined) {
+        list.listenerApplied = true;
+        const container = listMon.querySelector(listDocs.grid);
+        container.addEventListener("scroll", () => { this.applyChanges(listMon, id) });
       }
-      reorderIntoColumns(args.NUM);
-      parentList.scrollTop = 0;
+      const allItems = listMon.querySelectorAll(`div[class^="${listDocs.body}"] [class^="${listDocs.value}"]`);
+      const changedLabels = list.labels, changedColors = list.colors;
+      const isPackaged = typeof scaffolding !== "undefined";
+      allItems.forEach((item, i) => {
+        if (isPackaged ? item.parentNode.getAttribute("data-index") == i : item.getAttribute("dataindex") == i) {
+          if (changedLabels && changedLabels[i]) item.previousSibling.textContent = changedLabels[i];
+          if (changedColors && changedColors[i]) item.style.background = changedColors[i];
+        }
+      });
     }
 
-    getColumns(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return 0;
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      list = list.querySelector(`[class^="${listDocs.contain}"]`);
-      if (list === null) return 1;
-
-      const items = Array.from(list.querySelectorAll(`[class^="${listDocs.row}"]`));
-      if (items.length === 0) return 1;
-      const firstItem = items[0];
-      const itemWidth = parseFloat(firstItem.style.width);
-      if (!isNaN(itemWidth) && itemWidth > 0) {
-        const numColumns = 100 / itemWidth;
-        return Math.round(numColumns);
+    genId() {
+      // Used for creating IDs for variables
+      const soup = "!#%()*+,-./:;=?@[]^_`{|}~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+      const id = [];
+      for (let i = 0; i < 20; i++) {
+        id[i] = soup.charAt(Math.random() * soup.length);
       }
-      return 1;
+      return id.join("");
     }
 
-    getListArray(list, util) {
-      const items = util.target.lookupVariableById(list).value;
-      let allItems = document.querySelectorAll(`[data-id="${list}"]`);
-      allItems = allItems[allItems.length - 1];
-      allItems = allItems.querySelectorAll(`[class^="${listDocs.ind}"`);
-      let html = "";
-      if (items.length === 0) return ["", 0];
-      try {
-        const elementClasses = {
-          row : allItems[0].parentNode.className,
-          index : allItems[0].className,
-          outerV : allItems[0].nextElementSibling.className,
-          innerV : allItems[0].nextElementSibling.children[0].className
-        };
-        for (let i = 0; i < items.length; i++) {
-          const value = allItems[i] ? xmlEscape(allItems[i].textContent) : i + 1;
-          html += `
-            <div class="${elementClasses.row}" style="height: 24px; left: 0px; position: absolute; top: ${i * 24}px; width: 100%;">
-              <div class="${elementClasses.index}">${value}</div>
-              <div class="${elementClasses.outerV}" dataindex="${i}" style="background: rgb(252, 102, 44);">
-                <div class="${elementClasses.innerV}">${xmlEscape(items[i])}</div>
-              </div>
-            </div>`;
-        }
-      } catch { return ["", 0] }
-      return [html, items.length];
+    refresh() {
+      // Use to refresh the toolbox to show new/deleted lists
+      if (typeof scaffolding === "undefined") {
+        vm.emitWorkspaceUpdate();
+        const workspace = ScratchBlocks.getMainWorkspace();
+        workspace.toolboxRefreshEnabled_ = true;
+        workspace.refreshToolboxSelection_();
+        workspace.toolboxRefreshEnabled_ = false;
+        setTimeout(function() { runtime.requestBlocksUpdate() }, 10);
+      }
     }
 
+    // Block Funcs
     isShowing(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return false;
-      list = runtime.getMonitorState().get(args.LIST);
-      if (!list) return false;
-      return list.visible;
+      const id = this.getListID(args.LIST, util);
+      if (!id) return false;
+      return runtime.getMonitorState().get(id)?.visible || false;
+    }
+
+    listExists(args, util) { return Scratch.Cast.toBoolean(this.getListID(args.LIST, util)) }
+
+    makeList(args, util) {
+      const listName = Scratch.Cast.toString(args.LIST);
+      if (this.getListID(args.LIST, util)) return;
+      if (args.TYPE === "for this sprite only") util.target.createVariable(this.genId(), listName, "list");
+      else runtime.getTargetForStage().createVariable(this.genId(), listName, "list");
+      return this.refresh();
+    }
+
+    deleteList(args, util) {
+      const id = this.getListID(args.LIST, util);
+      if (!id) return;
+      runtime.getTargetForStage().deleteVariable(id)
+      util.target.deleteVariable(id);
+      return this.refresh();
     }
 
-    listExists(args, util) { return Scratch.Cast.toBoolean(this.lookForList(args.LIST, util)) }
+    renderList(args, util) {
+      const { id, listMon } = this.getMonitor(args.LIST, util, true);
+      if (!listMon) return;
+      const items = util.target.lookupVariableById(id).value;
+      const columnCnt = Math.min(100, Math.round(Scratch.Cast.toNumber(args.NUM)));
+      listMon.setAttribute("SPcolumnCnt", columnCnt);
+      let container = listMon.querySelector(`div[class^="SPstyLists-columnRender"`);
+      if (container) container.parentNode.removeChild(container);
+      if (items.length === 0) return;
+      // From this point onward, we know theres at least 1 item present. We can grab the classnames from that item,
+      // that way we dont lose CSS properties and support for Custom Styles
+      let itemDiv = [], listContain = listMon.querySelector(listDocs.contain);
+      if (!listContain) return; // shouldnt happen, but check just in case
+      const firstItem = listMon.querySelector(`[class^="${listDocs.row}"]`);
+      const itemClasses = [firstItem.className]; // Always 4 Items
+      firstItem.querySelectorAll("*").forEach(el => {itemClasses.push(el.className) });
+      if (columnCnt === 1) listContain.style.display = "";
+      else {
+        const isPackaged = typeof scaffolding !== "undefined";
+        listContain.style.display = "none";
+        container = document.createElement("div");
+        container.className = "SPstyLists-columnRender";
+        container.style.overflow = "scroll";
+        container.style.overflowX = "hidden";
+        container.style.height = "100%";
+        container.style.position = "relative";
+        container.addEventListener("scroll", () => { this.applyChanges(listMon, id) });
+        for (let i = 0; i < Math.ceil(items.length / columnCnt); i++) {
+          const row = document.createElement("div");
+          row.className = itemClasses[0];
+          row.style.position = "absolute";
+          row.style.width = "100%";
+          row.style.height = "24px";
+          row.style.top = `${i * 24}px`;
+          for (let j = 0; j < columnCnt; j++) {
+            const listItem = items[i * columnCnt + j];
+            const item = document.createElement("div");
+            item.className = itemClasses[0];
+            item.setAttribute("data-index", i * columnCnt + j);
+            item.style.width = `${100 / columnCnt}%`;
+            item.style.left = `${(100 / columnCnt) * j}%`;
+            const index = document.createElement("div");
+            index.className = itemClasses[1];
+            index.textContent = i * columnCnt + j + 1;
+            item.appendChild(index);
+
+            const value = document.createElement("div");
+            value.className = itemClasses[2];
+            value.style.background = "#ff661a";
+            value.style.color = "#fff";
+            value.setAttribute("dataindex", i * columnCnt + j);
+            const valueInner = document.createElement("div");
+            valueInner.className = itemClasses[3];
+            valueInner.textContent = listItem || "";
+            value.appendChild(valueInner);
+            item.appendChild(value);
+            if (!listItem) item.style.opacity = "0"; // Use Ghost Items to keep items separated
+            row.appendChild(item);
+          }
+          itemDiv.push(row)
+        }
+        container.append(...itemDiv);
+        listContain.parentNode.insertBefore(container, listContain);
+        if (args.SECRET === undefined) visualLists[id] = { ...visualLists[id], util };
+        this.applyChanges(listMon, id);
+      }
+    }
+
+    getColumns(args, util) {
+      const listMon= this.getMonitor(args.LIST, util);
+      if (!listMon) return 0;
+      return listMon ? listMon.getAttribute("SPcolumnCnt") || 1 : 1;
+    }
 
     stretchList(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      args.WIDTH = Scratch.Cast.toNumber(args.WIDTH), args.HEIGHT = Scratch.Cast.toNumber(args.HEIGHT);
-      args.WIDTH = args.WIDTH < 1 || args.WIDTH === Infinity ? 100 : args.WIDTH;
-      args.HEIGHT = args.HEIGHT < 1 || args.HEIGHT === Infinity ? 200 : args.HEIGHT;
-
-      runtime.requestUpdateMonitor(new Map([
-        ["id", list.match(/"([^"]+)"/)[1]],
-        ["width", args.WIDTH], ["height", args.HEIGHT]
-      ]));
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      if (!list || (list && list.classList.contains("blocklyDraggable"))) return;
-      if (!runtime.isPackaged) {
-        list = list.querySelector(`[class^="${listDocs.body}"]`);
-        list.style.cssText = `width: ${args.WIDTH}px; height: ${args.HEIGHT}px;`;
-        let items = list.querySelector(listDocs.grid);
-        if (items) items.style.cssText = `width: ${args.WIDTH}px;`;
-        items = list.querySelector(listDocs.contain);
-        if (items) items.style.cssText = `width: auto; height: ${Scratch.vm.runtime.stageHeight}px; max-width: ${args.WIDTH}px; max-height: ${Scratch.vm.runtime.stageHeight}px; overflow: hidden; position: relative;`;
+      const id = this.getListID(args.LIST, util);
+      if (!id) return;
+      const width = Math.max(1, Math.min(99999, Scratch.Cast.toNumber(args.WIDTH)));
+      const height = Math.max(1, Math.min(99999, Scratch.Cast.toNumber(args.HEIGHT)));
+      if (args.SECRET === undefined) visualLists[id] = { ...visualLists[id], util };
+      if (typeof scaffolding === "undefined") {
+        // Editor Monitor GUI cant Force Visual Updates, we need to do it Manually
+        const listMon = document.querySelector(`div[data-id="${id}"] [class*="monitor_list"]`);
+        if (!listMon) return;
+        const outerModal = listMon.querySelector(listDocs.grid);
+        const innerModal = listMon.querySelector(listDocs.contain);
+        listMon.style.width = `${width}px`; listMon.style.height = `${height}px`;
+        outerModal.style.width = `${width}px`; outerModal.style.height = `${height}px`;
+        if (innerModal) {
+          innerModal.style.width = "auto";
+          innerModal.style.maxWidth = `${width}px`;
+        }
       }
-      this.renderList({"LIST":args.LIST, "NUM": this.getColumns(args, util)}, util);
+      runtime.requestUpdateMonitor(new Map([["id", id], ["width", width], ["height", height]]));
     }
 
     getAtt(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return "";
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      if (!list || (list && list.classList.contains("blocklyDraggable"))) return "";
-      list = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
-      return parseFloat(list.style[args.THING]);
+      let listMon = this.getMonitor(args.LIST, util);
+      if (!listMon) return "";
+      listMon = typeof scaffolding !== "undefined" ? listMon : listMon.querySelector(`div[class^="${listDocs.body}"]`);
+      return parseFloat(listMon.style[args.THING === "width" ? "width" : "height"]);
     }
 
     chooseOption(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      if (args.THING === "click events") {
-        list.style.pointerEvents = args.ON_OFF === "off" ? "none" : "auto";
-      } else if (args.THING === "text highlighting") {
-        const items = list.querySelectorAll(`[class^="${listDocs.value2}"]`);
+      const listMon = this.getMonitor(args.LIST, util);
+      if (!listMon) return;
+      const disable = args.ON_OFF === "off";
+      if (args.THING === "click events") listMon.style.pointerEvents = disable ? "none" : "auto";
+      else if (args.THING === "text highlighting") {
+        const items = listMon.querySelectorAll(`div[class^="${listDocs.value2}"]`);
         items.forEach(item => {
-          item.style.userSelect = args.ON_OFF === "off" ? "none " : "auto";
-          item.style.webkitUserSelect = args.ON_OFF === "off" ? "none" : "auto"; //apple devices need this for some reason
+          item.style.userSelect = disable ? "none " : "auto";
+          item.style.webkitUserSelect = disable ? "none" : "auto";
         });
       } else if (args.THING === "numbered items") {
-        const numberedItems = list.querySelectorAll(`[class^="${listDocs.ind}"]`);
-        numberedItems.forEach(item => { item.style.display = args.ON_OFF === "off" ? "none" : "block" });
-      } else {
-        let button1 = list.querySelector(`[class^="${listDocs.addButton}"]`);
-        let button2 = runtime.isPackaged ? button1 : list.querySelector(`[class^="monitor_resize-handle"]`);
+        const numberedItems = listMon.querySelectorAll(`div[class^="${listDocs.ind}"]`);
+        numberedItems.forEach(item => { item.style.display = disable ? "none" : "block" });
+      } else if (args.THING === "+ and = buttons") {
+        let button1 = listMon.querySelector(`div[class^="${listDocs.addButton}"]`);
+        let button2 = typeof scaffolding !== "undefined" ? button1 : listMon.querySelector(`div[class^="monitor_resize-handle"]`);
         if (button1 === null || button2 === null) {
-          const buttons = list.querySelectorAll(".no-drag");
-          buttons.forEach(button => { button.style.display = args.ON_OFF === "off" ? "none" : "block" });
+          const buttons = listMon.querySelectorAll(".no-drag");
+          buttons.forEach(button => { button.style.display = disable ? "none" : "block" });
         } else {
-          button1.style.display = args.ON_OFF === "off" ? "none" : "block";
-          button2.style.display = args.ON_OFF === "off" ? "none" : "block";
+          button1.style.display = disable ? "none" : "block";
+          button2.style.display = disable ? "none" : "block";
         }
-        let text = list.querySelector(`[class^="${listDocs.foot}"]`);
+        let text = listMon.querySelector(`div[class^="${listDocs.foot}"]`);
         text.style.margin = "0 auto";
       }
     }
 
-    formatItems(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      list = list.querySelector(listDocs.contain);
-      if (list === null) return;
-      const items = Array.from(list.querySelectorAll(`[class^="${listDocs.value}"]`));
-      function reorder() {
-        for (let i = 0; i < items.length; i++) {
-          items[i].style.textAlign = args.ALIGN;
-        }
-      }
-      reorder();
-    }
-
     setPosition(args, util) {
-      const canvas = [Scratch.vm.runtime.stageWidth / 2, Scratch.vm.runtime.stageHeight / 2];
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      if (!list || (list && list.classList.contains("blocklyDraggable"))) return;
-
-      const box = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
+      const { id, listMon } = this.getMonitor(args.LIST, util, true);
+      if (!listMon) return;
+      const canvas = [runtime.stageWidth / 2, runtime.stageHeight / 2];
+      const regex = /transform:([^;]+);/;
+
+      const box = typeof scaffolding !== "undefined" ? listMon : listMon.querySelector(`div[class^="${listDocs.body}"]`);
       const sizeOffset = [parseFloat(box.style.width), parseFloat(box.style.height)];
-      let x = Scratch.Cast.toNumber(args.x) + canvas[0] - (sizeOffset[0] / 2);
-      let y = (Scratch.Cast.toNumber(args.y) - canvas[1] + (sizeOffset[1] / 2)) * -1;
+      const x = Scratch.Cast.toNumber(args.x) + canvas[0] - (sizeOffset[0] / 2);
+      const y = (Scratch.Cast.toNumber(args.y) - canvas[1] + (sizeOffset[1] / 2)) * -1;
 
-      let styleAttribute = list.getAttribute("style");
-      const transformRegex = runtime.isPackaged ? /transform:([^;]+);/ : /transform:([^;]+); top:([^;]+); left:([^;]+);/;
-      const transformMatch = styleAttribute.match(transformRegex);
+      let styleAtt = listMon.getAttribute("style");
+      const transformMatch = styleAtt.match(regex);
       if (transformMatch) {
-        const updatedTransform = transformMatch[1].replace(/translate\([^)]+\)/, `translate(${x}px, ${y}px)`);
-        styleAttribute = styleAttribute.replace(transformRegex, `transform:${updatedTransform}; top: 5; left: 5;`);
-        list.setAttribute("style", styleAttribute);
+        const newTransform = transformMatch[1].replace(/translate\([^)]+\)/, `translate(${x}px, ${y}px)`);
+        listMon.setAttribute("style", styleAtt.replace(regex, `transform:${newTransform}; top: 5; left: 5;`));
+        runtime.requestUpdateMonitor(new Map([["id", id], ["x", x], ["y", y]]));
       }
     }
 
     currentPos(args, util) {
-      const canvas = [Scratch.vm.runtime.stageWidth / 2, Scratch.vm.runtime.stageHeight / 2];
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return "";
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      if (!list || (list && list.classList.contains("blocklyDraggable"))) return "";
-
-      const box = runtime.isPackaged ? list : list.querySelector(`[class^="${listDocs.body}"]`);
+      const listMon = this.getMonitor(args.LIST, util);
+      if (!listMon) return "";
+      const canvas = [runtime.stageWidth / 2, runtime.stageHeight / 2];
+      const box = typeof scaffolding !== "undefined" ? listMon : listMon.querySelector(`div[class^="${listDocs.body}"]`);
       const sizeOffset = [parseFloat(box.style.width), parseFloat(box.style.height)];
-      const styleAttribute = list.getAttribute("style");
-      if (styleAttribute) {
-        const match = styleAttribute.match(/transform\s*:\s*translate\((-?\d+(?:\.\d+)?px),\s*(-?\d+(?:\.\d+)?px)\)/);
-        if (match) {
-          if (args.POSITION === "x") return parseInt(match[1]) - canvas[0] + (sizeOffset[0] / 2);
-          else return ((parseInt(match[2]) * -1) + canvas[1]) - (sizeOffset[1] / 2);
-        }
+      const styleAtt = listMon.getAttribute("style");
+      if (styleAtt) {
+        const match = styleAtt.match(/transform\s*:\s*translate\((-?\d+(?:\.\d+)?px),\s*(-?\d+(?:\.\d+)?px)\)/);
+        if (match) return args.POSITION === "x" ? parseInt(match[1]) - canvas[0] + (sizeOffset[0] / 2) :
+          ((parseInt(match[2]) * -1) + canvas[1]) - (sizeOffset[1] / 2);
       }
       return "";
     }
 
     setScroll(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      list = document.querySelector(`[data-id=${list}] ${listDocs.grid}`);
-      if (list === null) return;
-      const scroll = (args.SCROLL / 100) * (list.scrollHeight - list.clientHeight);
-      list.scrollTop = scroll;
+      const id = this.getListID(args.LIST, util);
+      if (!id) return;
+      let grid = document.querySelector(`div[data-id="${id}"] ${listDocs.grid}`);
+      let spGrid = document.querySelector(`div[data-id="${id}"] [class^="SPstyLists-columnRender"`);
+      const value = Scratch.Cast.toNumber(args.SCROLL) / 100;
+      if (spGrid !== null) spGrid.scrollTop = value * (spGrid.scrollHeight - spGrid.clientHeight);
+      else if (grid !== null) grid.scrollTop = value * (grid.scrollHeight - grid.clientHeight);
     }
 
     resetAll(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      return new Promise(resolve => {
-        list = list.match(/"([^"]+)"/)[1];
-        this.changeMonitorVisibility(list, false);
-        setTimeout(() => {
-          this.changeMonitorVisibility(list, true);
-          setTimeout(() => { resolve() }, 1);
-        }, 25);
-      });
+      const id = this.getListID(args.LIST, util);
+      if (!id || !this.isShowing(args, util)) return;
+      const setVisible = (id, visible) => {
+        runtime.monitorBlocks.changeBlock({ id: id, element: "checkbox", value: visible }, runtime);
+      }
+      const onVisUpdate = () => {
+        runtime.once("AFTER_EXECUTE", () => { 
+          setVisible(id, true);
+          runtime.off("MONITORS_UPDATE", onVisUpdate);
+        });
+      };
+      runtime.once("MONITORS_UPDATE", onVisUpdate);
+      setVisible(id, false);
     }
 
-    changeMonitorVisibility(id, visible) {
-      runtime.monitorBlocks.changeBlock({
-        id: id, element: "checkbox", value: visible
-      }, runtime);
+    formatItems(args, util) {
+      let listMon = this.getMonitor(args.LIST, util);
+      if (!listMon) return;
+      listMon = listMon.querySelector(listDocs.contain);
+      if (listMon === null) return;
+      const items = Array.from(listMon.querySelectorAll(`div[class^="${listDocs.value}"]`));
+      items.forEach(item => { item.style.textAlign = args.ALIGN });
     }
 
     setDisplay(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
+      const id = this.getListID(args.LIST, util);
+      if (!id) return;
       let label;
-      if (args.DISPLAY === "header") {
-        label = document.querySelector(`[data-id=${list}] ${listDocs.pkg1}[class^="${listDocs.head}"]`);
-      } else {
-        label = document.querySelector(`[data-id=${list}] ${listDocs.pkg1}[class^="${listDocs.foot}"] ${listDocs.span}`);
-      }
-      if (label) label.textContent = xmlEscape(args.NAME);
+      if (args.DISPLAY === "header") label = document.querySelector(`div[data-id="${id}"] ${listDocs.pkg1}[class^="${listDocs.head}"]`);
+      else label = document.querySelector(`div[data-id="${id}"] ${listDocs.pkg1}[class^="${listDocs.foot}"] ${listDocs.span}`);
+      if (label) label.textContent = args.NAME;
+    }
+
+    setColor(args, util) {
+      const { id, listMon } = this.getMonitor(args.LIST, util, true);
+      if (!listMon) return;
+      const index = Math.max(0, Scratch.Cast.toNumber(args.NUM) - 1);
+      const currentList = visualLists[id] || {};
+      visualLists[id] = { ...currentList, util, colors: { ...currentList.colors, [index]: args.COLOR } };
+      this.applyChanges(listMon, id);
+    }
+
+    setLabel(args, util) {
+      const { id, listMon } = this.getMonitor(args.LIST, util, true);
+      if (!listMon) return;
+      const index = Math.max(0, Scratch.Cast.toNumber(args.NUM) - 1);
+      const currentList = visualLists[id] || {};
+      visualLists[id] = { ...currentList, util, labels: { ...currentList.labels, [index]: args.VALUE } };
+      this.applyChanges(listMon, id);
+    }
+
+    setFont(args, util) {
+      const listMon = this.getMonitor(args.LIST, util);
+      if (listMon) listMon.style.fontFamily = args.FONT;
     }
 
-    resetEffects(list, currentTransform) {
-      const translationRegex = /translate\(([^,]+),\s*([^)]+)\)/;
-      const matches = currentTransform.match(translationRegex);
+    resetEffect(args, util) {
+      const listMon = this.getMonitor(args.LIST, util);
+      if (!listMon) return;
+      let curTransform = listMon.style.transform || "";
+      const matches = curTransform.match(/translate\(([^,]+),\s*([^)]+)\)/);
       let translation = matches ? `translate(${matches[1]}, ${matches[2]})` : "";
-      translation = translation.replace(/scale\([^,]+,\s*[^)]+\)/g, "scale(1)");
-      list.style.filter = "";
-      list.style.transform = translation;
+      listMon.style.transform = translation.replace(/scale\([^,]+,\s*[^)]+\)/g, "scale(1)");
+      listMon.style.filter = "";
     }
 
-    setEffect(args, util) { this.listEffect(args.LIST, args.EFFECT, args.AMOUNT, util) }
-
-    listEffect(LIST, EFFECT, AMOUNT, util) {
-      let list = this.lookForList(LIST, util);
-      if (!list) return;
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      let currentTransform = list.style.transform || "";
-      let currentFilterEffect = list.style.filter || "";
-      let setEffect = EFFECT;
-      let amountIn = AMOUNT;
-      if (setEffect === "saturation") setEffect = "saturate";
-      else if (setEffect === "hue") setEffect = "hue-rotate";
-      else if (setEffect === "direction") {
-        setEffect = "rotate";
-        amountIn = AMOUNT - 90;
+    setEffect(args, util) {
+      const listMon = this.getMonitor(args.LIST, util);
+      if (!listMon) return;
+      let curTransform = listMon.style.transform || "";
+      let curFilter = listMon.style.filter || "";
+      let effect = args.EFFECT, amountIn = Scratch.Cast.toNumber(args.AMOUNT);
+      if (effect === "saturation") effect = "saturate";
+      else if (effect === "hue") effect = "hue-rotate";
+      else if (effect === "brightness") amountIn += 100;
+      else if (effect === "skew x") effect = "skewX";
+      else if (effect === "skew y") effect = "skewY";
+      else if (effect === "direction") {
+        effect = "rotate";
+        amountIn -= 90;
       }
-      else if (setEffect === "brightness") amountIn = AMOUNT + 100;
-      else if (setEffect === "skew x") setEffect = "skewX";
-      else if (setEffect === "skew y") setEffect = "skewY";
-      const regex = new RegExp(`${setEffect}\\([^)]+\\)`, "g");
-      currentTransform = currentTransform.replace(regex, "").trim();
-      currentFilterEffect = currentFilterEffect.replace(regex, "").trim();
-      if (setEffect === "rotate" || setEffect.includes("skew")) {
-        currentTransform += ` ${setEffect}(${amountIn}deg)`;
-        list.style.transform = currentTransform.trim();
+      const regex = new RegExp(`${effect}\\([^)]+\\)`, "g");
+      curTransform = curTransform.replace(regex, "").trim();
+      curFilter = curFilter.replace(regex, "").trim();
+      if (effect === "rotate" || effect.includes("skew")) {
+        curTransform += ` ${effect}(${amountIn}deg)`;
+        listMon.style.transform = curTransform.trim();
       } else {
-        currentFilterEffect += ` ${setEffect}(${amountIn}${setEffect === "blur" ? "px" : setEffect === "hue-rotate" ? "deg" : "%"})`;
-        list.style.filter = currentFilterEffect.trim();
+        curFilter += ` ${effect}(${amountIn}${effect === "blur" ? "px" : effect === "hue-rotate" ? "deg" : "%"})`;
+        listMon.style.filter = curFilter.trim();
       }
     }
 
     stretchEffect(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      if (!list || (list && list.classList.contains("blocklyDraggable"))) return;
-      let existingTransform = list.style.transform || "";
-      existingTransform = existingTransform.replace(/scale\([^)]*\)/g, "");
-      list.style.transform = `${existingTransform} scale(${args.x / 100}, ${args.y / 100})`;
+      const listMon = this.getMonitor(args.LIST, util);
+      if (!listMon) return;
+      let curTransform = listMon.style.transform || "";
+      const scaleTxt = `scale(${Scratch.Cast.toNumber(args.x) / 100}, ${Scratch.Cast.toNumber(args.y) / 100})`;
+      listMon.style.transform = `${curTransform.replace(/scale\([^)]*\)/g, "")} ${scaleTxt}`;
     }
 
     currentEffect(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return "";
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      const currentTransform = list.style.transform || "";
-      const currentFilterEffect = list.style.filter || "";
+      const listMon = this.getMonitor(args.LIST, util);
+      if (!listMon) return "";
+      const effect = Scratch.Cast.toString(args.EFFECT);
+      const curTransform = listMon.style.transform || "";
+      const curFilter = listMon.style.filter || "";
       const setEffect = {
-        saturation: "saturate",
-        hue: "hue-rotate", direction: "rotate",
+        saturation: "saturate", hue: "hue-rotate", direction: "rotate",
         "scale x": "scale", "scale y": "scale",
-        brightness: "brightness",
-        opacity: "opacity",
-        "skew x": "skewX", "skew y": "skewY",
-      }[args.EFFECT] || args.EFFECT;
+        brightness: "brightness", opacity: "opacity",
+        "skew x": "skewX", "skew y": "skewY"
+      }[effect] || effect;
       const defaultV = {
         saturation: 100, hue: 0, direction: 90,
         "scale x": 100, "scale y": 100,
-        brightness: 0, opacity: 100,
-      }[args.EFFECT] || 0;
+        brightness: 0, opacity: 100
+      }[effect] || 0;
 
       const regex = new RegExp(`${setEffect}\\(([^)]+)\\)`);
-      const transformMatch = currentTransform.match(regex);
-      const filterMatch = currentFilterEffect.match(regex);
+      const transformMatch = curTransform.match(regex);
+      const filterMatch = curFilter.match(regex);
       if (filterMatch || transformMatch) {
-        const valueWithUnits = (filterMatch || transformMatch)[1];
-        const numericValue = parseFloat(valueWithUnits.replace(/[^0-9.-]/g, ""));
-        if (setEffect === "brightness") return numericValue - 100;
-        else if (setEffect === "rotate") return numericValue + 90;
-        else if (setEffect === "scale") {
-          const arr = valueWithUnits.split(", ");
-          return arr[args.EFFECT.includes("x") ? 0 : 1] * 100;
-        } else { return numericValue }
+        const unitVal = (filterMatch || transformMatch)[1];
+        const pureVal = parseFloat(unitVal.replace(/[^0-9.-]/g, ""));
+        if (setEffect === "brightness") return pureVal - 100;
+        else if (setEffect === "rotate") return pureVal + 90;
+        else if (setEffect === "scale") return unitVal.split(", ")[effect.includes("x") ? 0 : 1] * 100;
+        else return pureVal
       } else { return defaultV }
     }
-
-    resetEffect(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      let currentTransform = list.style.transform || "";
-      this.resetEffects(list, currentTransform);
-    }
-
-    setFont(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      list.style.fontFamily = args.FONT;
-    }
-
-    setColor(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      args.NUM = Math.abs(args.NUM);
-      if (!args.COLOR.includes("gradient")) {
-        args.COLOR = args.COLOR.replace(/^#/, "");
-        const bigint = parseInt(args.COLOR, 16);
-        args.COLOR = `rgb(${(bigint >> 16) & 255}, ${(bigint >> 8) & 255}, ${bigint & 255})`;
-      }
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      const targetElement = list.querySelectorAll(`[class^="${listDocs.body}"] [class^="${listDocs.value}"]`)[args.NUM - 1];
-      if (targetElement) targetElement.style.background = xmlEscape(args.COLOR);
-    }
-
-    setLabel(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (!list) return;
-      args.NUM = Math.abs(args.NUM);
-      list = document.querySelectorAll(`[data-id=${list}]`);
-      list = list[list.length - 1];
-      const targetElement = list.querySelectorAll(`[class^="${listDocs.ind}"`)[args.NUM - 1];
-      if (targetElement) targetElement.textContent = xmlEscape(args.VALUE);
-    }
-
-    makeList(args, util) {
-      let list = this.lookForList(args.LIST, util);
-      if (list) return;
-      if (args.TYPE === "for this sprite only") {
-        util.target.createVariable(this.generateId(), args.LIST, "list");
-      } else {
-        runtime.getTargetForStage().createVariable(this.generateId(), args.LIST, "list");
-      }
-      return this.refresh();
-    }
-
-    refresh() {
-      if (!runtime.isPackaged) {
-        Scratch.vm.emitWorkspaceUpdate();
-        window.ScratchBlocks.getMainWorkspace().toolboxRefreshEnabled_ = true;
-        window.ScratchBlocks.getMainWorkspace().refreshToolboxSelection_();
-        window.ScratchBlocks.getMainWorkspace().toolboxRefreshEnabled_ = false;
-        setTimeout(function() { vm.runtime.requestBlocksUpdate() }, 10);
-      }
-    }
-
-    generateId() {
-      const soup = "!#%()*+,-./:;=?@[]^_`{|}~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-      const id = [];
-      for (let i = 0; i < 20; i++) {
-        id[i] = soup.charAt(Math.random() * soup.length);
-      }
-      return id.join("");
-    }
   }
 
   Scratch.extensions.register(new SPlistMonitors());

From 6718ac2626b9d95bbf6a1e153a725000da9a9926 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sun, 21 Jul 2024 21:14:31 -0700
Subject: [PATCH 10/13] Sty-Lists -- V2.0 Rewrite

---
 extensions/SharkPool/Sty-Lists.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index 9ac3633521..a239701ccb 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -414,7 +414,6 @@
       firstItem.querySelectorAll("*").forEach(el => {itemClasses.push(el.className) });
       if (columnCnt === 1) listContain.style.display = "";
       else {
-        const isPackaged = typeof scaffolding !== "undefined";
         listContain.style.display = "none";
         container = document.createElement("div");
         container.className = "SPstyLists-columnRender";

From 353dc79660bb002e90bd243944d1c58a0e042d53 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Fri, 6 Sep 2024 18:55:50 -0700
Subject: [PATCH 11/13] bug fix Sty-Lists.js

---
 extensions/SharkPool/Sty-Lists.js | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index a239701ccb..7e050028f6 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,14 +3,14 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 2.0.0
+// Version 2.0.1
 
 (function (Scratch) {
   "use strict";
   if (!Scratch.extensions.unsandboxed) throw new Error("Sty-Lists must run unsandboxed!");
 
   const menuIconURI =
-"data:image/svg+xml;base64,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";
+"data:image/svg+xml;base64,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";
 
   const vm = Scratch.vm;
   const runtime = vm.runtime;
@@ -336,16 +336,16 @@
       if (list.listenerApplied === undefined) {
         list.listenerApplied = true;
         const container = listMon.querySelector(listDocs.grid);
-        container.addEventListener("scroll", () => { this.applyChanges(listMon, id) });
+        container.addEventListener("scroll", () => this.applyChanges(listMon, id));
       }
-      const allItems = listMon.querySelectorAll(`div[class^="${listDocs.body}"] [class^="${listDocs.value}"]`);
-      const changedLabels = list.labels, changedColors = list.colors;
       const isPackaged = typeof scaffolding !== "undefined";
-      allItems.forEach((item, i) => {
-        if (isPackaged ? item.parentNode.getAttribute("data-index") == i : item.getAttribute("dataindex") == i) {
-          if (changedLabels && changedLabels[i]) item.previousSibling.textContent = changedLabels[i];
-          if (changedColors && changedColors[i]) item.style.background = changedColors[i];
-        }
+      const allItems = listMon.querySelectorAll(`div[class^="${listDocs.body}"] [class^="${listDocs.value}"]`);
+      const newLabels = list.labels || {}, newColors = list.colors || {};
+      allItems.forEach((item) => {
+        const i = isPackaged ? item.parentNode.getAttribute("data-index") : item.getAttribute("dataindex");
+        if (newLabels[i]) item.previousSibling.textContent = newLabels[i];
+        if (isPackaged) item.style.background = newColors[i] || ""; // Labels auto reset, colors do not
+        else if (newColors[i]) item.style.background = newColors[i];
       });
     }
 
@@ -367,7 +367,7 @@
         workspace.toolboxRefreshEnabled_ = true;
         workspace.refreshToolboxSelection_();
         workspace.toolboxRefreshEnabled_ = false;
-        setTimeout(function() { runtime.requestBlocksUpdate() }, 10);
+        setTimeout(() => { runtime.requestBlocksUpdate() }, 10);
       }
     }
 
@@ -421,7 +421,7 @@
         container.style.overflowX = "hidden";
         container.style.height = "100%";
         container.style.position = "relative";
-        container.addEventListener("scroll", () => { this.applyChanges(listMon, id) });
+        container.addEventListener("scroll", () => this.applyChanges(listMon, id));
         for (let i = 0; i < Math.ceil(items.length / columnCnt); i++) {
           const row = document.createElement("div");
           row.className = itemClasses[0];
@@ -619,8 +619,9 @@
       const { id, listMon } = this.getMonitor(args.LIST, util, true);
       if (!listMon) return;
       const index = Math.max(0, Scratch.Cast.toNumber(args.NUM) - 1);
+      const val = args.VALUE.replaceAll(" ", " ");
       const currentList = visualLists[id] || {};
-      visualLists[id] = { ...currentList, util, labels: { ...currentList.labels, [index]: args.VALUE } };
+      visualLists[id] = { ...currentList, util, labels: { ...currentList.labels, [index]: val } };
       this.applyChanges(listMon, id);
     }
 

From 8f373a4554627933316af078cba20c502940fd50 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sat, 19 Oct 2024 14:00:02 -0700
Subject: [PATCH 12/13] Sty-Lists -- Bug Fix

---
 extensions/SharkPool/Sty-Lists.js | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index 7e050028f6..630c121b3a 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,7 +3,7 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 2.0.1
+// Version 2.0.11
 
 (function (Scratch) {
   "use strict";
@@ -353,9 +353,7 @@
       // Used for creating IDs for variables
       const soup = "!#%()*+,-./:;=?@[]^_`{|}~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
       const id = [];
-      for (let i = 0; i < 20; i++) {
-        id[i] = soup.charAt(Math.random() * soup.length);
-      }
+      for (let i = 0; i < 20; i++) id[i] = soup.charAt(Math.random() * soup.length);
       return id.join("");
     }
 
@@ -451,7 +449,7 @@
             valueInner.textContent = listItem || "";
             value.appendChild(valueInner);
             item.appendChild(value);
-            if (!listItem) item.style.opacity = "0"; // Use Ghost Items to keep items separated
+            if (listItem === undefined) item.style.opacity = "0"; // Use Ghost Items to keep items separated
             row.appendChild(item);
           }
           itemDiv.push(row)

From dee84815fe654b88ef82b1fefea5733d5588f228 Mon Sep 17 00:00:00 2001
From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com>
Date: Sat, 16 Nov 2024 00:53:52 -0800
Subject: [PATCH 13/13] Sty-Lists -- Add Show/Hide List Block

---
 extensions/SharkPool/Sty-Lists.js | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/extensions/SharkPool/Sty-Lists.js b/extensions/SharkPool/Sty-Lists.js
index 630c121b3a..b238117ed4 100644
--- a/extensions/SharkPool/Sty-Lists.js
+++ b/extensions/SharkPool/Sty-Lists.js
@@ -3,7 +3,7 @@
 // Description: Customize and Organize Lists Monitors.
 // By: SharkPool
 
-// Version 2.0.11
+// Version 2.1.0
 
 (function (Scratch) {
   "use strict";
@@ -102,6 +102,15 @@
               LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" }
             },
           },
+          {
+            opcode: "setVis",
+            blockType: Scratch.BlockType.COMMAND,
+            text: "[VIS] list [LIST]",
+            arguments: {
+              LIST: { type: Scratch.ArgumentType.STRING, menu: "lists" },
+              VIS: { type: Scratch.ArgumentType.STRING, menu: "VISIBLE" }
+            },
+          },
           "---",
           {
             opcode: "renderList",
@@ -287,6 +296,7 @@
           listTypes: ["globally", "for this sprite only"],
           listUtils: ["click events", "text highlighting", "numbered items", "+ and = buttons"],
           ON_OFF: ["on", "off"],
+          VISIBLE: { acceptReporters: true, items: ["show", "hide"] },
           ATTS: { acceptReporters: true, items: ["width", "height"] },
           ALIGN: { acceptReporters: true, items: ["left", "right", "center"] }
         }
@@ -394,6 +404,14 @@
       return this.refresh();
     }
 
+    setVis(args, util) {
+      const id = this.getListID(args.LIST, util);
+      if (!id) return;
+      runtime.monitorBlocks.changeBlock({
+        id, element: "checkbox", value: args.VIS === "show"
+      }, runtime);
+    }
+
     renderList(args, util) {
       const { id, listMon } = this.getMonitor(args.LIST, util, true);
       if (!listMon) return;