@triflare/fx 1.0.1 → 1.0.3

package/bin/fx.js

@@ -217,6 +217,8 @@ async function cmdBuild(args) {
     extensionUrls,
     useConfigFile: !args.flags["no-config"],
   });
+  for (const warning of result.warnings)
+    process.stderr.write(`warning: ${warning}\n`);
 
   const explicit = args.flags.o || args.flags.output;
   const output =

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflare/fx",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Code PenguinMod projects with text.",
   "type": "module",
   "license": "Apache-2.0",
@@ -8,6 +8,10 @@
   "bin": {
     "fx": "bin/fx.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/triflare/fx.git"
+  },
   "exports": {
     ".": "./src/index.js",
     "./catalog": "./src/catalog.js",

package/product.yml

@@ -1,7 +1,7 @@
 # Identity
 name: "Triflare Fx"
 command: "fx"
-version: "1.0.1"
+version: "1.0.3"
 tagline: "Code PenguinMod projects with text."
 author: "Triflare"
 homepage: "https://github.com/triflare/fx"

package/src/build.js

@@ -98,7 +98,7 @@ function resolveSources(options) {
 
 /**
  * @param {BuildOptions} [options]
- * @returns {{project: object, assets: Map<string, Buffer>, sb3: Buffer, config: object, fx: object, ast: object, files: string[]}}
+ * @returns {{project: object, assets: Map<string, Buffer>, sb3: Buffer, config: object, fx: object, ast: object, files: string[], warnings: string[]}}
  */
 export function build(options = {}) {
   const { dir, entries } = resolveSources(options);
@@ -155,6 +155,7 @@ export function build(options = {}) {
     fx: fxConfig,
     ast,
     files: entries.map((e) => e.file),
+    warnings: compiler.warnings,
   };
 }
 

package/src/catalog.js

@@ -1,21 +1,39 @@
 /**
  * Triflare Fx block catalog.
  *
- * This module is the single source of truth for how a Triflare Fx
- * `category.function(...)` call maps onto a Scratch/PenguinMod opcode: its shape
- * (command/reporter/boolean/hat), its inputs, its dropdown fields and any
- * mutation it requires. The compiler, the decompiler and the editor tooling all
- * read from here instead of hard-coding opcode tables.
+ * The single source of truth for how a `category.function(...)` call maps onto
+ * a Scratch/PenguinMod opcode: shape, inputs, dropdown fields and mutations.
+ * The compiler, the decompiler and the editor tooling all read from here.
  *
- * Input descriptors:
- *   {type: 'number'|'positive'|'whole'|'integer'|'angle'|'string'|'color'
- *          |'boolean'|'substack'|'broadcast'|'variable'|'list'}
- *   {type: 'menu', menu: <shadow opcode>, field: <field name>, default: <value>}
+ * Entry conventions:
+ *   - `kind` is a command unless the entry says otherwise, so only reporters,
+ *     booleans and hats spell it out (see the default applied below).
+ *   - `inputs` maps an input name to one of the shared descriptors below.
+ *   - `fields` maps a dropdown field name to its default value.
+ *   - `args` describes a hat's parameters (`field` or `input`).
+ *   - `extension` names the providing extension for non-core opcodes.
+ *   - `dynamicNext` / `stopBlock` flag blocks with special stack behaviour.
  *
- * Field descriptors are plain objects providing the default dropdown value.
+ * Input descriptors:
+ *   NUMBER, STRING, BOOLEAN, ANGLE, COLOR, INTEGER, POSITIVE, WHOLE, SUBSTACK
+ *   and BROADCAST are shared `{type}` descriptors;
+ *   `{type: 'menu', menu, field, default}` wraps a dropdown shadow block;
+ *   `{type: 'variable'|'list'}` takes a variable/list reference.
  */
 
-// Common reusable menu descriptors -----------------------------------------
+// Reusable input descriptors -----------------------------------------------
+const NUMBER = { type: "number" };
+const STRING = { type: "string" };
+const BOOLEAN = { type: "boolean" };
+const ANGLE = { type: "angle" };
+const COLOR = { type: "color" };
+const INTEGER = { type: "integer" };
+const POSITIVE = { type: "positive" };
+const WHOLE = { type: "whole" };
+const SUBSTACK = { type: "substack" };
+const BROADCAST = { type: "broadcast" };
+
+// Reusable dropdown (shadow menu) descriptors -------------------------------
 const GOTO_MENU = {
   type: "menu",
   menu: "motion_goto_menu",
@@ -85,82 +103,67 @@ const OF_MENU = {
   default: "_stage_",
 };
 
-/** @type {Record<string, object>} */
-export const CATALOG = {
+const CORE_CATALOG = {
   // ---------------------------------------------------------------- motion
   "motion.moveSteps": {
     opcode: "motion_movesteps",
-    kind: "command",
-    inputs: { STEPS: { type: "number" } },
+    inputs: { STEPS: NUMBER },
   },
   "motion.turnRight": {
     opcode: "motion_turnright",
-    kind: "command",
-    inputs: { DEGREES: { type: "number" } },
+    inputs: { DEGREES: NUMBER },
   },
   "motion.turnLeft": {
     opcode: "motion_turnleft",
-    kind: "command",
-    inputs: { DEGREES: { type: "number" } },
+    inputs: { DEGREES: NUMBER },
   },
   "motion.goToXY": {
     opcode: "motion_gotoxy",
-    kind: "command",
-    inputs: { X: { type: "number" }, Y: { type: "number" } },
+    inputs: { X: NUMBER, Y: NUMBER },
   },
   "motion.goTo": {
     opcode: "motion_goto",
-    kind: "command",
     inputs: { TO: GOTO_MENU },
   },
   "motion.glideToXY": {
     opcode: "motion_glidesecstoxy",
-    kind: "command",
     inputs: {
-      SECS: { type: "number" },
-      X: { type: "number" },
-      Y: { type: "number" },
+      SECS: NUMBER,
+      X: NUMBER,
+      Y: NUMBER,
     },
   },
   "motion.glideTo": {
     opcode: "motion_glideto",
-    kind: "command",
-    inputs: { SECS: { type: "number" }, TO: GLIDE_MENU },
+    inputs: { SECS: NUMBER, TO: GLIDE_MENU },
   },
   "motion.pointInDirection": {
     opcode: "motion_pointindirection",
-    kind: "command",
-    inputs: { DIRECTION: { type: "angle" } },
+    inputs: { DIRECTION: ANGLE },
   },
   "motion.pointTowards": {
     opcode: "motion_pointtowards",
-    kind: "command",
     inputs: { TOWARDS: POINT_MENU },
   },
   "motion.changeX": {
     opcode: "motion_changexby",
-    kind: "command",
-    inputs: { DX: { type: "number" } },
+    inputs: { DX: NUMBER },
   },
   "motion.setX": {
     opcode: "motion_setx",
-    kind: "command",
-    inputs: { X: { type: "number" } },
+    inputs: { X: NUMBER },
   },
   "motion.changeY": {
     opcode: "motion_changeyby",
-    kind: "command",
-    inputs: { DY: { type: "number" } },
+    inputs: { DY: NUMBER },
   },
   "motion.setY": {
     opcode: "motion_sety",
-    kind: "command",
-    inputs: { Y: { type: "number" } },
+    inputs: { Y: NUMBER },
   },
-  "motion.ifOnEdgeBounce": { opcode: "motion_ifonedgebounce", kind: "command" },
+  "motion.ifOnEdgeBounce": { opcode: "motion_ifonedgebounce" },
   "motion.setRotationStyle": {
     opcode: "motion_setrotationstyle",
-    kind: "command",
     fields: { STYLE: "all around" },
   },
   "motion.xPosition": { opcode: "motion_xposition", kind: "reporter" },
@@ -170,79 +173,65 @@ export const CATALOG = {
   // ----------------------------------------------------------------- looks
   "looks.say": {
     opcode: "looks_say",
-    kind: "command",
-    inputs: { MESSAGE: { type: "string" } },
+    inputs: { MESSAGE: STRING },
   },
   "looks.sayForSecs": {
     opcode: "looks_sayforsecs",
-    kind: "command",
-    inputs: { MESSAGE: { type: "string" }, SECS: { type: "number" } },
+    inputs: { MESSAGE: STRING, SECS: NUMBER },
   },
   "looks.think": {
     opcode: "looks_think",
-    kind: "command",
-    inputs: { MESSAGE: { type: "string" } },
+    inputs: { MESSAGE: STRING },
   },
   "looks.thinkForSecs": {
     opcode: "looks_thinkforsecs",
-    kind: "command",
-    inputs: { MESSAGE: { type: "string" }, SECS: { type: "number" } },
+    inputs: { MESSAGE: STRING, SECS: NUMBER },
   },
   "looks.switchCostume": {
     opcode: "looks_switchcostumeto",
-    kind: "command",
     inputs: { COSTUME: COSTUME_MENU },
   },
-  "looks.nextCostume": { opcode: "looks_nextcostume", kind: "command" },
+  "looks.nextCostume": { opcode: "looks_nextcostume" },
   "looks.switchBackdrop": {
     opcode: "looks_switchbackdropto",
-    kind: "command",
     inputs: { BACKDROP: BACKDROP_MENU },
   },
   "looks.switchBackdropAndWait": {
     opcode: "looks_switchbackdroptoandwait",
-    kind: "command",
     inputs: { BACKDROP: BACKDROP_MENU },
   },
-  "looks.nextBackdrop": { opcode: "looks_nextbackdrop", kind: "command" },
+  "looks.nextBackdrop": { opcode: "looks_nextbackdrop" },
   "looks.changeSize": {
     opcode: "looks_changesizeby",
-    kind: "command",
-    inputs: { CHANGE: { type: "number" } },
+    inputs: { CHANGE: NUMBER },
   },
   "looks.setSize": {
     opcode: "looks_setsizeto",
-    kind: "command",
-    inputs: { SIZE: { type: "number" } },
+    inputs: { SIZE: NUMBER },
   },
   "looks.changeEffect": {
     opcode: "looks_changeeffectby",
-    kind: "command",
     fields: { EFFECT: "color" },
-    inputs: { CHANGE: { type: "number" } },
+    inputs: { CHANGE: NUMBER },
   },
   "looks.setEffect": {
     opcode: "looks_seteffectto",
-    kind: "command",
     fields: { EFFECT: "color" },
-    inputs: { VALUE: { type: "number" } },
+    inputs: { VALUE: NUMBER },
   },
   "looks.clearEffects": {
     opcode: "looks_cleargraphiceffects",
-    kind: "command",
   },
-  "looks.show": { opcode: "looks_show", kind: "command" },
-  "looks.hide": { opcode: "looks_hide", kind: "command" },
+  "looks.show": { opcode: "looks_show" },
+  "looks.hide": { opcode: "looks_hide" },
   "looks.goToFrontLayer": {
     opcode: "looks_gotofrontback",
-    kind: "command",
     fields: { FRONT_BACK: "front" },
   },
   "looks.goLayers": {
     opcode: "looks_goforwardbackwardlayers",
-    kind: "command",
     fields: { FORWARD_BACKWARD: "forward" },
-    inputs: { NUM: { type: "integer" } },
+    inputs: { NUM: INTEGER },
   },
   "looks.costumeNumber": {
     opcode: "looks_costumenumbername",
@@ -259,37 +248,31 @@ export const CATALOG = {
   // ----------------------------------------------------------------- sound
   "sound.play": {
     opcode: "sound_play",
-    kind: "command",
     inputs: { SOUND_MENU: SOUND_MENU },
   },
   "sound.playUntilDone": {
     opcode: "sound_playuntildone",
-    kind: "command",
     inputs: { SOUND_MENU: SOUND_MENU },
   },
-  "sound.stopAllSounds": { opcode: "sound_stopallsounds", kind: "command" },
+  "sound.stopAllSounds": { opcode: "sound_stopallsounds" },
   "sound.changeEffect": {
     opcode: "sound_changeeffectby",
-    kind: "command",
     fields: { EFFECT: "pitch" },
-    inputs: { VALUE: { type: "number" } },
+    inputs: { VALUE: NUMBER },
   },
   "sound.setEffect": {
     opcode: "sound_seteffectto",
-    kind: "command",
     fields: { EFFECT: "pitch" },
-    inputs: { VALUE: { type: "number" } },
+    inputs: { VALUE: NUMBER },
   },
-  "sound.clearEffects": { opcode: "sound_cleareffects", kind: "command" },
+  "sound.clearEffects": { opcode: "sound_cleareffects" },
   "sound.changeVolume": {
     opcode: "sound_changevolumeby",
-    kind: "command",
-    inputs: { VOLUME: { type: "number" } },
+    inputs: { VOLUME: NUMBER },
   },
   "sound.setVolume": {
     opcode: "sound_setvolumeto",
-    kind: "command",
-    inputs: { VOLUME: { type: "number" } },
+    inputs: { VOLUME: NUMBER },
   },
   "sound.volume": { opcode: "sound_volume", kind: "reporter" },
 
@@ -302,12 +285,12 @@ export const CATALOG = {
   "sensing.touchingColor": {
     opcode: "sensing_touchingcolor",
     kind: "boolean",
-    inputs: { COLOR: { type: "color" } },
+    inputs: { COLOR: COLOR },
   },
   "sensing.colorIsTouchingColor": {
     opcode: "sensing_coloristouchingcolor",
     kind: "boolean",
-    inputs: { COLOR: { type: "color" }, COLOR2: { type: "color" } },
+    inputs: { COLOR: COLOR, COLOR2: COLOR },
   },
   "sensing.distanceTo": {
     opcode: "sensing_distanceto",
@@ -316,8 +299,7 @@ export const CATALOG = {
   },
   "sensing.askAndWait": {
     opcode: "sensing_askandwait",
-    kind: "command",
-    inputs: { QUESTION: { type: "string" } },
+    inputs: { QUESTION: STRING },
   },
   "sensing.answer": { opcode: "sensing_answer", kind: "reporter" },
   "sensing.keyPressed": {
@@ -330,7 +312,7 @@ export const CATALOG = {
   "sensing.mouseY": { opcode: "sensing_mousey", kind: "reporter" },
   "sensing.loudness": { opcode: "sensing_loudness", kind: "reporter" },
   "sensing.timer": { opcode: "sensing_timer", kind: "reporter" },
-  "sensing.resetTimer": { opcode: "sensing_resettimer", kind: "command" },
+  "sensing.resetTimer": { opcode: "sensing_resettimer" },
   "sensing.propertyOf": {
     opcode: "sensing_of",
     kind: "reporter",
@@ -352,110 +334,107 @@ export const CATALOG = {
   "operators.add": {
     opcode: "operator_add",
     kind: "reporter",
-    inputs: { NUM1: { type: "number" }, NUM2: { type: "number" } },
+    inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.subtract": {
     opcode: "operator_subtract",
     kind: "reporter",
-    inputs: { NUM1: { type: "number" }, NUM2: { type: "number" } },
+    inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.multiply": {
     opcode: "operator_multiply",
     kind: "reporter",
-    inputs: { NUM1: { type: "number" }, NUM2: { type: "number" } },
+    inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.divide": {
     opcode: "operator_divide",
     kind: "reporter",
-    inputs: { NUM1: { type: "number" }, NUM2: { type: "number" } },
+    inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.random": {
     opcode: "operator_random",
     kind: "reporter",
-    inputs: { FROM: { type: "number" }, TO: { type: "number" } },
+    inputs: { FROM: NUMBER, TO: NUMBER },
   },
   "operators.gt": {
     opcode: "operator_gt",
     kind: "boolean",
-    inputs: { OPERAND1: { type: "string" }, OPERAND2: { type: "string" } },
+    inputs: { OPERAND1: STRING, OPERAND2: STRING },
   },
   "operators.lt": {
     opcode: "operator_lt",
     kind: "boolean",
-    inputs: { OPERAND1: { type: "string" }, OPERAND2: { type: "string" } },
+    inputs: { OPERAND1: STRING, OPERAND2: STRING },
   },
   "operators.equals": {
     opcode: "operator_equals",
     kind: "boolean",
-    inputs: { OPERAND1: { type: "string" }, OPERAND2: { type: "string" } },
+    inputs: { OPERAND1: STRING, OPERAND2: STRING },
   },
   "operators.and": {
     opcode: "operator_and",
     kind: "boolean",
-    inputs: { OPERAND1: { type: "boolean" }, OPERAND2: { type: "boolean" } },
+    inputs: { OPERAND1: BOOLEAN, OPERAND2: BOOLEAN },
   },
   "operators.or": {
     opcode: "operator_or",
     kind: "boolean",
-    inputs: { OPERAND1: { type: "boolean" }, OPERAND2: { type: "boolean" } },
+    inputs: { OPERAND1: BOOLEAN, OPERAND2: BOOLEAN },
   },
   "operators.not": {
     opcode: "operator_not",
     kind: "boolean",
-    inputs: { OPERAND: { type: "boolean" } },
+    inputs: { OPERAND: BOOLEAN },
   },
   "operators.join": {
     opcode: "operator_join",
     kind: "reporter",
-    inputs: { STRING1: { type: "string" }, STRING2: { type: "string" } },
+    inputs: { STRING1: STRING, STRING2: STRING },
   },
   "operators.letterOf": {
     opcode: "operator_letter_of",
     kind: "reporter",
-    inputs: { LETTER: { type: "number" }, STRING: { type: "string" } },
+    inputs: { LETTER: NUMBER, STRING: STRING },
   },
   "operators.length": {
     opcode: "operator_length",
     kind: "reporter",
-    inputs: { STRING: { type: "string" } },
+    inputs: { STRING: STRING },
   },
   "operators.contains": {
     opcode: "operator_contains",
     kind: "boolean",
-    inputs: { STRING1: { type: "string" }, STRING2: { type: "string" } },
+    inputs: { STRING1: STRING, STRING2: STRING },
   },
   "operators.mod": {
     opcode: "operator_mod",
     kind: "reporter",
-    inputs: { NUM1: { type: "number" }, NUM2: { type: "number" } },
+    inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.round": {
     opcode: "operator_round",
     kind: "reporter",
-    inputs: { NUM: { type: "number" } },
+    inputs: { NUM: NUMBER },
   },
   "operators.math": {
     opcode: "operator_mathop",
     kind: "reporter",
     fields: { OPERATOR: "abs" },
-    inputs: { NUM: { type: "number" } },
+    inputs: { NUM: NUMBER },
   },
 
   // --------------------------------------------------------------- control
   "control.wait": {
     opcode: "control_wait",
-    kind: "command",
-    inputs: { DURATION: { type: "positive" } },
+    inputs: { DURATION: POSITIVE },
   },
   "control.repeat": {
     opcode: "control_repeat",
-    kind: "command",
-    inputs: { TIMES: { type: "whole" }, SUBSTACK: { type: "substack" } },
+    inputs: { TIMES: WHOLE, SUBSTACK: SUBSTACK },
   },
   "control.forever": {
     opcode: "control_forever",
-    kind: "command",
-    inputs: { SUBSTACK: { type: "substack" } },
+    inputs: { SUBSTACK: SUBSTACK },
     // PenguinMod builds this loop without a next-statement connection and only
     // creates one from the block's mutation (`hasbreak` — the nub the editor
     // adds by itself once a block sits below the loop). Blocks stacked under a
@@ -466,54 +445,45 @@ export const CATALOG = {
   },
   "control.if": {
     opcode: "control_if",
-    kind: "command",
-    inputs: { CONDITION: { type: "boolean" }, SUBSTACK: { type: "substack" } },
+    inputs: { CONDITION: BOOLEAN, SUBSTACK: SUBSTACK },
   },
   "control.ifElse": {
     opcode: "control_if_else",
-    kind: "command",
     inputs: {
-      CONDITION: { type: "boolean" },
-      SUBSTACK: { type: "substack" },
-      SUBSTACK2: { type: "substack" },
+      CONDITION: BOOLEAN,
+      SUBSTACK: SUBSTACK,
+      SUBSTACK2: SUBSTACK,
     },
   },
   "control.waitUntil": {
     opcode: "control_wait_until",
-    kind: "command",
-    inputs: { CONDITION: { type: "boolean" } },
+    inputs: { CONDITION: BOOLEAN },
   },
   "control.repeatUntil": {
     opcode: "control_repeat_until",
-    kind: "command",
-    inputs: { CONDITION: { type: "boolean" }, SUBSTACK: { type: "substack" } },
+    inputs: { CONDITION: BOOLEAN, SUBSTACK: SUBSTACK },
   },
   "control.stop": {
     opcode: "control_stop",
-    kind: "command",
     fields: { STOP_OPTION: "all" },
     stopBlock: true,
   },
   "control.clone": {
     opcode: "control_create_clone_of",
-    kind: "command",
     inputs: { CLONE_OPTION: CLONE_MENU },
   },
   "control.deleteThisClone": {
     opcode: "control_delete_this_clone",
-    kind: "command",
   },
 
   // ---------------------------------------------------------------- events
   "events.broadcast": {
     opcode: "event_broadcast",
-    kind: "command",
-    inputs: { BROADCAST_INPUT: { type: "broadcast" } },
+    inputs: { BROADCAST_INPUT: BROADCAST },
   },
   "events.broadcastAndWait": {
     opcode: "event_broadcastandwait",
-    kind: "command",
-    inputs: { BROADCAST_INPUT: { type: "broadcast" } },
+    inputs: { BROADCAST_INPUT: BROADCAST },
   },
 
   // --------------------------------------------------------------- hats
@@ -574,26 +544,23 @@ export const CATALOG = {
   },
 
   // ------------------------------------------------------------------ pen
-  "pen.clear": { opcode: "pen_clear", kind: "command", extension: "pen" },
-  "pen.stamp": { opcode: "pen_stamp", kind: "command", extension: "pen" },
-  "pen.penDown": { opcode: "pen_penDown", kind: "command", extension: "pen" },
-  "pen.penUp": { opcode: "pen_penUp", kind: "command", extension: "pen" },
+  "pen.clear": { opcode: "pen_clear", extension: "pen" },
+  "pen.stamp": { opcode: "pen_stamp", extension: "pen" },
+  "pen.penDown": { opcode: "pen_penDown", extension: "pen" },
+  "pen.penUp": { opcode: "pen_penUp", extension: "pen" },
   "pen.setColor": {
     opcode: "pen_setPenColorToColor",
-    kind: "command",
-    inputs: { COLOR: { type: "color" } },
+    inputs: { COLOR: COLOR },
     extension: "pen",
   },
   "pen.changeSize": {
     opcode: "pen_changePenSizeBy",
-    kind: "command",
-    inputs: { SIZE: { type: "number" } },
+    inputs: { SIZE: NUMBER },
     extension: "pen",
   },
   "pen.setSize": {
     opcode: "pen_setPenSizeTo",
-    kind: "command",
-    inputs: { SIZE: { type: "number" } },
+    inputs: { SIZE: NUMBER },
     extension: "pen",
   },
   // COLOR_PARAM is an input whose shadow is `pen_menu_colorParam`, not a
@@ -602,7 +569,6 @@ export const CATALOG = {
   // wrapping a shadow menu block (field name `colorParam`).
   "pen.changeColorParam": {
     opcode: "pen_changePenColorParamBy",
-    kind: "command",
     inputs: {
       COLOR_PARAM: {
         type: "menu",
@@ -610,13 +576,12 @@ export const CATALOG = {
         field: "colorParam",
         default: "color",
       },
-      VALUE: { type: "number" },
+      VALUE: NUMBER,
     },
     extension: "pen",
   },
   "pen.setColorParam": {
     opcode: "pen_setPenColorParamTo",
-    kind: "command",
     inputs: {
       COLOR_PARAM: {
         type: "menu",
@@ -624,7 +589,7 @@ export const CATALOG = {
         field: "colorParam",
         default: "color",
       },
-      VALUE: { type: "number" },
+      VALUE: NUMBER,
     },
     extension: "pen",
   },
@@ -647,6 +612,18 @@ export const CATALOG = {
   },
 };
 
+/**
+ * Catalog entries with the default `kind` filled in: everything is a command
+ * unless the table above said otherwise.
+ * @type {Record<string, object>}
+ */
+export const CATALOG = Object.fromEntries(
+  Object.entries(CORE_CATALOG).map(([name, entry]) => [
+    name,
+    { kind: "command", ...entry },
+  ]),
+);
+
 /**
  * Native Scratch variable/list mutation opcodes used when a list method is
  * called (`items.push(x)` etc.).

package/src/compiler.js

@@ -25,6 +25,11 @@ const HAT_ALIASES = {
   timerGreaterThan: "events.timerGreaterThan",
 };
 
+// `dataFormat` values Scratch 3 can load (see the `VM.Costume` / `VM.Sound`
+// types). Anything else is still written through, but may not load.
+const COSTUME_FORMATS = new Set(["svg", "png", "jpg"]);
+const SOUND_FORMATS = new Set(["wav", "mp3"]);
+
 const NUMBER_TYPES = {
   number: 4,
   positive: 5,
@@ -133,6 +138,8 @@ export class Compiler {
     this.catalog = catalog ? { ...CATALOG, ...catalog } : CATALOG;
     this.extensionUrls = extensionUrls;
     this.file = file;
+    /** @type {string[]} Non-fatal problems worth surfacing to the user. */
+    this.warnings = [];
 
     // opcode -> extension id, derived from the (merged) catalog. This lets
     // synthesized extension blocks declare an id that isn't inferable from
@@ -463,12 +470,20 @@ export class Compiler {
   applyCostumes(ctx, property) {
     for (const entry of property.value) {
       const format = detectFormat(entry.value);
+      if (!COSTUME_FORMATS.has(format))
+        this.warnings.push(
+          `costume ${JSON.stringify(entry.key)} uses dataFormat ` +
+            `"${format}"; Scratch 3 costumes are svg, png or jpg`,
+        );
       const buffer = this.readAsset(entry.value, entry.loc);
       const { width, height } = imageSize(buffer, format);
       const asset = this.registerAsset(buffer, format);
       ctx.target.costumes.push({
         name: entry.key,
-        bitmapResolution: 1,
+        // Scratch 3 saves bitmap costumes at 2x; the VM converts a 1 to 2 on
+        // load anyway (`import/load-costume.js`), and the renderer's
+        // BitmapSkin defaults to 2. SVGs are always 1.
+        bitmapResolution: format === "svg" ? 1 : 2,
         dataFormat: format,
         assetId: asset.assetId,
         md5ext: asset.md5ext,
@@ -481,6 +496,11 @@ export class Compiler {
   applySounds(ctx, property) {
     for (const entry of property.value) {
       const format = detectFormat(entry.value);
+      if (!SOUND_FORMATS.has(format))
+        this.warnings.push(
+          `sound ${JSON.stringify(entry.key)} uses dataFormat ` +
+            `"${format}"; Scratch 3 sounds are wav or mp3`,
+        );
       const buffer = this.readAsset(entry.value, entry.loc);
       const info =
         format === "wav" ? wavInfo(buffer) : { rate: 48000, sampleCount: 0 };
@@ -577,7 +597,7 @@ export class Compiler {
         }
       } else if (spec.input) {
         inputs[spec.input] = this.buildInputForSpec(
-          { type: spec.type || "any" },
+          { type: spec.type || "any", default: spec.default },
           argExpr,
           null,
         );
@@ -1110,7 +1130,16 @@ export class Compiler {
   }
 
   defaultPrim(spec) {
-    switch (spec.type) {
+    const prim = this.defaultPrimForType(spec.type);
+    // Extensions declare the value a call falls back to when it omits an
+    // argument; built-in catalog entries never set `default`.
+    if (spec.default !== undefined && spec.default !== null)
+      prim[1] = String(spec.default);
+    return prim;
+  }
+
+  defaultPrimForType(type) {
+    switch (type) {
       case "number":
         return [4, "0"];
       case "positive":

package/src/decompiler.js

@@ -376,13 +376,23 @@ class Decompiler {
     const proto = this.target.blocks[protoId];
     const mutation = (proto && proto.mutation) || {};
     const proccode = mutation.proccode || "procedure";
+    const ids = mutation.argumentids ? JSON.parse(mutation.argumentids) : [];
     const names = mutation.argumentnames
       ? JSON.parse(mutation.argumentnames)
       : [];
+    // Parameter types live on the prototype's argument reporter shadows, not
+    // in the mutation, so read them back or `loud: boolean` decompiles to a
+    // string parameter.
+    const params = names.map((name, index) => {
+      const reporter =
+        proto && this.target.blocks[firstOf(proto.inputs[ids[index]])];
+      return reporter && reporter.opcode === "argument_reporter_boolean"
+        ? `${name}: boolean`
+        : name;
+    });
     const baseName = proccode.split(" ")[0];
     const returning = this.returningProccodes.has(proccode) ? "returning " : "";
-    const params = names.join(", ");
-    return `${returning}function ${baseName}(${params}) {\n${this.renderStack(defBlock.next, 1)}\n}`;
+    return `${returning}function ${baseName}(${params.join(", ")}) {\n${this.renderStack(defBlock.next, 1)}\n}`;
   }
 
   decompileTarget(target, indent = 0) {

package/src/dev.js

@@ -55,6 +55,239 @@ function escapeHtml(text) {
     .replaceAll('"', """);
 }
 
+/**
+ * Elements whose content the HTML tokenizer treats as text rather than markup.
+ * `noscript` is included because this page always runs scripts, which is
+ * exactly when the parser stops tokenizing its content.
+ */
+const RAW_TEXT_TAGS = new Set([
+  "script",
+  "style",
+  "title",
+  "textarea",
+  "iframe",
+  "noembed",
+  "noframes",
+  "xmp",
+  "noscript",
+]);
+
+/**
+ * Elements whose contents are parsed into a separate fragment: a `</body>`
+ * inside one is ignored by the document tokenizer, so it cannot be the
+ * document's body end either.
+ */
+const FRAGMENT_TAGS = new Set(["template"]);
+
+const TAG_NAME_AT = /<([a-zA-Z][^\s/>]*)/y;
+
+/**
+ * Index just past the start tag beginning at `start`, skipping quoted attribute
+ * values so a `>` inside `srcdoc="…"` cannot end the tag early. Returns -1 when
+ * the tag never closes.
+ * @param {string} html
+ * @param {number} start
+ * @returns {number}
+ */
+function startTagEnd(html, start) {
+  let quote = "";
+  for (let i = start + 1; i < html.length; i += 1) {
+    const char = html[i];
+    if (quote) {
+      if (char === quote) quote = "";
+    } else if (char === '"' || char === "'") {
+      quote = char;
+    } else if (char === ">") {
+      return i + 1;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Index just past the first `</name>` at or after `from`, or -1.
+ * @param {string} html
+ * @param {string} name
+ * @param {number} from
+ * @returns {number}
+ */
+function endTagEnd(html, name, from) {
+  const pattern = new RegExp(`</${name}\\s*>`, "gi");
+  pattern.lastIndex = from;
+  const match = pattern.exec(html);
+  return match ? match.index + match[0].length : -1;
+}
+
+/**
+ * Index just past the `</name>` that closes the element whose start tag ends at
+ * `from`, honouring nested `name` elements and skipping comments and raw-text
+ * content. Returns -1 when the element never closes.
+ * @param {string} html
+ * @param {string} name
+ * @param {number} from
+ * @returns {number}
+ */
+function matchingClose(html, name, from) {
+  let depth = 1;
+  let i = from;
+
+  while (i < html.length) {
+    const tag = html.indexOf("<", i);
+    if (tag === -1) return -1;
+
+    if (html.startsWith("<!--", tag)) {
+      const commentEnd = html.indexOf("-->", tag + 4);
+      if (commentEnd === -1) return -1;
+      i = commentEnd + 3;
+      continue;
+    }
+
+    const end = startTagEnd(html, tag);
+    if (end === -1) return -1;
+
+    if (html[tag + 1] === "/") {
+      const nameAt = tag + 2;
+      if (
+        html.slice(nameAt, nameAt + name.length).toLowerCase() === name &&
+        " \t\n\f\r/>".includes(html[nameAt + name.length] ?? ">")
+      ) {
+        depth -= 1;
+        if (depth === 0) return end;
+      }
+      i = end;
+      continue;
+    }
+
+    TAG_NAME_AT.lastIndex = tag;
+    const match = TAG_NAME_AT.exec(html);
+    const inner = match ? match[1].toLowerCase() : "";
+
+    if (inner === name) {
+      depth += 1;
+      i = end;
+      continue;
+    }
+
+    // `<plaintext>` never closes, so nothing after it can close the fragment.
+    if (inner === "plaintext") return -1;
+
+    // Raw-text content is text, so a `</template>`-looking string in a script
+    // inside the fragment cannot close it early.
+    if (RAW_TEXT_TAGS.has(inner)) {
+      const raw = endTagEnd(html, inner, end);
+      if (raw === -1) return -1;
+      i = raw;
+      continue;
+    }
+
+    i = end;
+  }
+
+  return -1;
+}
+
+/**
+ * Find the ranges the HTML tokenizer treats as text rather than markup, so tag
+ * searches cannot match text that merely looks like markup (a `</body>` inside
+ * a script string, a commented-out tag, an attribute value, ...).
+ * @param {string} html
+ * @returns {{ranges: Array<[number, number]>, textFrom: number}} `ranges` are
+ *   sorted, non-overlapping `[start, end)` spans; `textFrom` is the offset
+ *   where a `<plaintext>` or unterminated tag/text element starts, so nothing
+ *   from there to end of input is markup. -1 when the whole input is markup.
+ */
+function nonMarkupRanges(html) {
+  /** @type {Array<[number, number]>} */
+  const ranges = [];
+  let textFrom = -1;
+  let i = 0;
+
+  while (i < html.length) {
+    const tag = html.indexOf("<", i);
+    if (tag === -1) break;
+
+    if (html.startsWith("<!--", tag)) {
+      const close = html.indexOf("-->", tag + 4);
+      const end = close === -1 ? html.length : close + 3;
+      ranges.push([tag, end]);
+      i = end;
+      continue;
+    }
+
+    TAG_NAME_AT.lastIndex = tag;
+    const match = TAG_NAME_AT.exec(html);
+    const name = match ? match[1].toLowerCase() : "";
+    const next = html[tag + 1] ?? "";
+
+    // A bare `<` (`1 < 2`) opens no tag, so carry on just after it: scanning
+    // from here could otherwise let a stray quote in text open an attribute
+    // quote and swallow real markup that follows.
+    if (!match && next !== "/" && next !== "!" && next !== "?") {
+      i = tag + 1;
+      continue;
+    }
+
+    const end = startTagEnd(html, tag);
+
+    // An unterminated tag, and `<plaintext>`, make the rest of the input text.
+    if (end === -1 || name === "plaintext") {
+      ranges.push([tag, html.length]);
+      textFrom = tag;
+      break;
+    }
+
+    // End tags and declarations have no attributes that could hide a tag.
+    if (name === "") {
+      i = end;
+      continue;
+    }
+
+    if (!RAW_TEXT_TAGS.has(name) && !FRAGMENT_TAGS.has(name)) {
+      // A start tag's quoted attributes are text too, so a `</body>` inside
+      // `title="…"` cannot capture the injection.
+      ranges.push([tag, end]);
+      i = end;
+      continue;
+    }
+
+    // Fragment contents (templates) are opaque to the document tokenizer, so a
+    // `</body>` inside them — nested templates included — is not the body end.
+    const close = FRAGMENT_TAGS.has(name)
+      ? matchingClose(html, name, end)
+      : endTagEnd(html, name, end);
+
+    // An element without its end tag also runs to end of input.
+    if (close === -1) {
+      ranges.push([tag, html.length]);
+      textFrom = tag;
+      break;
+    }
+
+    ranges.push([tag, close]);
+    i = close;
+  }
+
+  return { ranges, textFrom };
+}
+
+/**
+ * Offset of the last `</body>` outside the given text ranges, or -1.
+ * @param {string} html
+ * @param {Array<[number, number]>} ranges
+ * @returns {number}
+ */
+function lastBodyEnd(html, ranges) {
+  let bodyEnd = -1;
+  let next = 0;
+  for (const match of html.matchAll(/<\/body\s*>/gi)) {
+    while (next < ranges.length && ranges[next][1] <= match.index) next += 1;
+    const range = ranges[next];
+    if (range && range[0] <= match.index) continue; // text, not a tag
+    bodyEnd = match.index;
+  }
+  return bodyEnd;
+}
+
 /**
  * @param {string} html
  * @returns {string}
@@ -84,9 +317,22 @@ export function injectDevClient(html) {
   });
 })();
 </script>`;
-  if (/<\/body\s*>/i.test(html))
-    return html.replace(/<\/body\s*>/i, `${script}\n</body>`);
-  return `${html}${html.endsWith("\n") ? "" : "\n"}${script}`;
+  // Insert before the *last* real closing body tag: packaged pages inline a
+  // bundle that can itself contain the literal text `</body>` inside a string,
+  // and injecting there would corrupt the script instead of ending the
+  // document. Comments, text-element content and attribute values are masked
+  // first so a quoted or commented-out `</body>` cannot capture the injection.
+  const { ranges, textFrom } = nonMarkupRanges(html);
+  const bodyEnd = lastBodyEnd(html, ranges);
+
+  // Without a usable body end tag, go before the point where the document
+  // turns into text (keeping the client a script rather than literal text),
+  // or append when the whole input was markup.
+  const at =
+    bodyEnd === -1 ? (textFrom === -1 ? html.length : textFrom) : bodyEnd;
+  const before = html.slice(0, at);
+  const separator = before === "" || before.endsWith("\n") ? "" : "\n";
+  return `${before}${separator}${script}${html.slice(at)}`;
 }
 
 /**

package/src/extensions.js

@@ -165,18 +165,191 @@ export const Color = {
   hexToDecimal(hex) {
     return Color.rgbToDecimal(Color.hexToRgb(hex));
   },
+  hsvToRgb(hsv) {
+    let h = hsv.h % 360;
+    if (h < 0) h += 360;
+    const s = Math.max(0, Math.min(hsv.s, 1));
+    const v = Math.max(0, Math.min(hsv.v, 1));
+
+    const i = Math.floor(h / 60);
+    const f = h / 60 - i;
+    const p = v * (1 - s);
+    const q = v * (1 - s * f);
+    const t = v * (1 - s * (1 - f));
+
+    let r;
+    let g;
+    let b;
+    switch (i) {
+      default:
+      case 0:
+        r = v;
+        g = t;
+        b = p;
+        break;
+      case 1:
+        r = q;
+        g = v;
+        b = p;
+        break;
+      case 2:
+        r = p;
+        g = v;
+        b = t;
+        break;
+      case 3:
+        r = p;
+        g = q;
+        b = v;
+        break;
+      case 4:
+        r = t;
+        g = p;
+        b = v;
+        break;
+      case 5:
+        r = v;
+        g = p;
+        b = q;
+        break;
+    }
+
+    return {
+      r: Math.floor(r * 255),
+      g: Math.floor(g * 255),
+      b: Math.floor(b * 255),
+    };
+  },
+  rgbToHsv(rgb) {
+    const r = rgb.r / 255;
+    const g = rgb.g / 255;
+    const b = rgb.b / 255;
+    const x = Math.min(Math.min(r, g), b);
+    const v = Math.max(Math.max(r, g), b);
+
+    // For greys hue is arbitrarily reported as zero.
+    let h = 0;
+    let s = 0;
+    if (x !== v) {
+      const f = r === x ? g - b : g === x ? b - r : r - g;
+      const i = r === x ? 3 : g === x ? 5 : 1;
+      h = ((i - f / (v - x)) * 60) % 360;
+      s = (v - x) / v;
+    }
+
+    return { h: h, s: s, v: v };
+  },
+  mixRgb(rgb0, rgb1, fraction1) {
+    if (fraction1 <= 0) return rgb0;
+    if (fraction1 >= 1) return rgb1;
+    const fraction0 = 1 - fraction1;
+    return {
+      r: fraction0 * rgb0.r + fraction1 * rgb1.r,
+      g: fraction0 * rgb0.g + fraction1 * rgb1.g,
+      b: fraction0 * rgb0.b + fraction1 * rgb1.b,
+    };
+  },
 };
 
-/** `Scratch.Cast`. */
+/**
+ * `Scratch.Cast` (scratch-vm's `util/cast`, as exposed to extensions).
+ *
+ * Each member mirrors the VM's implementation, including Scratch's own
+ * coercion rules — `Cast.toBoolean("0")` is false, `Cast.compare` is
+ * case-insensitive for text and numeric otherwise.
+ */
 export const Cast = {
   toString: (value) => String(value),
   toNumber: (value) => {
+    if (typeof value === "number") return Number.isNaN(value) ? 0 : value;
     const n = Number(value);
     return Number.isNaN(n) ? 0 : n;
   },
-  toBoolean: (value) =>
-    typeof value === "boolean" ? value : String(value) === "true",
-  toList: (value) => (Array.isArray(value) ? value : [value]),
+  toBoolean: (value) => {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      // These exact strings are false in Scratch; everything else is true.
+      if (value === "" || value === "0" || value.toLowerCase() === "false")
+        return false;
+      return true;
+    }
+    return Boolean(value);
+  },
+  /** 0 when equal, negative when `a` sorts first, positive otherwise. */
+  compare: (a, b) => {
+    // Scratch does not treat "0", "\t" or strings containing them as zero.
+    const isNotActuallyZero = (value) => {
+      if (typeof value !== "string") return false;
+      for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code === 48 || code === 9) return false;
+      }
+      return true;
+    };
+    let n1 = Number(a);
+    let n2 = Number(b);
+    if (n1 === 0 && isNotActuallyZero(a)) n1 = NaN;
+    else if (n2 === 0 && isNotActuallyZero(b)) n2 = NaN;
+    if (Number.isNaN(n1) || Number.isNaN(n2)) {
+      const s1 = String(a).toLowerCase();
+      const s2 = String(b).toLowerCase();
+      if (s1 < s2) return -1;
+      if (s1 > s2) return 1;
+      return 0;
+    }
+    if (
+      (n1 === Infinity && n2 === Infinity) ||
+      (n1 === -Infinity && n2 === -Infinity)
+    )
+      return 0;
+    return n1 - n2;
+  },
+  toRgbColorList: (value) => {
+    const color = Cast.toRgbColorObject(value);
+    return [color.r, color.g, color.b];
+  },
+  toRgbColorObject: (value) => {
+    let color;
+    if (typeof value === "object") value += "";
+    if (typeof value === "string" && value.substring(0, 1) === "#") {
+      color = Color.hexToRgb(value);
+      // A string that only looks like a hex colour casts to black.
+      if (!color) color = { r: 0, g: 0, b: 0, a: 255 };
+    } else {
+      color = Color.decimalToRgb(Cast.toNumber(value));
+    }
+    return color;
+  },
+  isWhiteSpace: (value) =>
+    value === null || (typeof value === "string" && value.trim().length === 0),
+  isInt: (value) => {
+    if (typeof value === "number") {
+      if (Number.isNaN(value)) return true;
+      return value === Math.floor(value);
+    }
+    if (typeof value === "boolean") return true;
+    if (typeof value === "string") return value.indexOf(".") < 0;
+    return false;
+  },
+  get LIST_INVALID() {
+    return "INVALID";
+  },
+  get LIST_ALL() {
+    return "ALL";
+  },
+  toListIndex: (index, length, acceptAll) => {
+    if (typeof index !== "number") {
+      if (index === "all") return acceptAll ? Cast.LIST_ALL : Cast.LIST_INVALID;
+      if (index === "last") return length > 0 ? length : Cast.LIST_INVALID;
+      if (index === "random" || index === "any")
+        return length > 0
+          ? 1 + Math.floor(Math.random() * length)
+          : Cast.LIST_INVALID;
+    }
+    index = Math.floor(Cast.toNumber(index));
+    if (index < 1 || index > length) return Cast.LIST_INVALID;
+    return index;
+  },
 };
 
 // -------------------------------------------------------------- translation
@@ -184,23 +357,35 @@ export const Cast = {
 /**
  * Map a `Scratch.ArgumentType` onto a Triflare Fx input descriptor.
  * @param {object} arg
- * @returns {{type: string}}
+ * @returns {{type: string, default?: string|number}}
  */
 function argumentSpec(arg) {
   const type = arg && arg.type;
+  let spec;
   switch (type) {
     case ArgumentType.BOOLEAN:
-      return { type: "boolean" };
-    case ArgumentType.NUMBER:
-      return { type: "number" };
+      spec = { type: "boolean" };
+      break;
     case ArgumentType.ANGLE:
-      return { type: "angle" };
+      spec = { type: "angle" };
+      break;
     case ArgumentType.COLOR:
-      return { type: "color" };
-    // Matrix, note, costume, backdrop, sound and string all travel as text.
+      spec = { type: "color" };
+      break;
+    // A note is a MIDI number, so it takes numeric input like `NUMBER`.
+    case ArgumentType.NOTE:
+    case ArgumentType.NUMBER:
+      spec = { type: "number" };
+      break;
+    // Matrix, costume, sound, PM menus and plain strings all travel as text.
     default:
-      return { type: "string" };
+      spec = { type: "string" };
   }
+  // Extensions declare the value a call falls back to when it omits the arg.
+  if (arg && arg.defaultValue !== undefined && arg.defaultValue !== null) {
+    spec.default = arg.defaultValue;
+  }
+  return spec;
 }
 
 /**
@@ -270,10 +455,14 @@ function registerInfo(catalog, info, sourceName) {
       extension: id,
     };
     if (kind === "hat") {
-      entry.args = Object.entries(block.arguments || {}).map(([name, arg]) => ({
-        input: name,
-        type: argumentSpec(arg).type,
-      }));
+      entry.args = Object.entries(block.arguments || {}).map(([name, arg]) => {
+        const spec = argumentSpec(arg);
+        return {
+          input: name,
+          type: spec.type,
+          ...(spec.default !== undefined ? { default: spec.default } : {}),
+        };
+      });
     } else if (
       block.blockType === BlockType.CONDITIONAL ||
       block.blockType === BlockType.LOOP
@@ -331,15 +520,20 @@ function permissive(label) {
   return proxy;
 }
 
-function makeSandbox(registered, { unsandboxed = false } = {}) {
+export function makeSandbox(registered, { unsandboxed = false } = {}) {
+  /** A function that rejects: the sandbox has no browser or network. */
+  const unavailable = (name) => () =>
+    Promise.reject(new Error(`${name} is not available while compiling`));
   const Scratch = {
     extensions: {
       register(extension) {
         registered.push(extension);
       },
-      // PenguinMod sets `unsandboxed: true` for unsandboxed loads and exposes
-      // `isPenguinMod`, so extensions can adapt to whichever loader runs them.
-      unsandboxed: Boolean(unsandboxed),
+      // TurboWarp documents `unsandboxed` as true when unsandboxed and
+      // undefined otherwise — never false.
+      unsandboxed: unsandboxed || undefined,
+      // PenguinMod's unsandboxed loader sets this; exposing it in both modes
+      // keeps PenguinMod-only extensions loadable here.
       isPenguinMod: true,
     },
     BlockType,
@@ -351,15 +545,31 @@ function makeSandbox(registered, { unsandboxed = false } = {}) {
     Clone,
     Color,
     Cast,
-    translate: (value) => {
-      if (typeof value === "string") return value;
-      if (
-        value &&
-        typeof value === "object" &&
-        typeof value.default === "string"
-      )
-        return value.default;
-      return value == null ? "" : String(value);
+    // tw-l10n exposes `translate(message, args)`, `translate.setup({…})` and a
+    // read-only `translate.language` on the same function. Generated l10n
+    // bundles call `setup({…})` at module scope before registering.
+    translate: Object.defineProperty(
+      Object.assign(
+        (message) => {
+          if (typeof message === "string") return message;
+          if (message && typeof message === "object") {
+            return typeof message.default === "string" ? message.default : "";
+          }
+          throw new Error("unsupported data type in translate()");
+        },
+        { setup() {} },
+      ),
+      "language",
+      { get: () => "en", enumerable: true },
+    ),
+    // `Scratch.external` loads sibling resources; the sandbox has no browser,
+    // so its entries reject instead of resolving like a module.
+    external: {
+      importModule: unavailable("Scratch.external"),
+      fetch: unavailable("Scratch.external"),
+      dataURL: unavailable("Scratch.external"),
+      blob: unavailable("Scratch.external"),
+      evalAndReturn: unavailable("Scratch.external"),
     },
     canFetch: () => Promise.resolve(false),
     fetch: () =>

package/vendor/pm-packager-dist/.fx-build.json

@@ -2,5 +2,5 @@
   "name": "@penguinmod/packager",
   "version": "1.9.2",
   "commit": "53f868b85ec21d2edab9ce00fd2d709da93da6d6",
-  "builtAt": "2026-11-03T06:22:44.624Z"
+  "builtAt": "2026-11-04T05:52:07.415Z"
 }