hikkaku 0.1.14 → 0.2.0

package/blocks/index.mjs

@@ -1,134 +1,595 @@
-import { a as fromCostumeSource, i as valueBlock, o as fromPrimitiveSource, r as substack, s as fromSoundSource, t as block } from "../composer-JWWbnKkh.mjs";
+import { a as valueBlock, c as fromSoundSource, i as substack, l as InputType, n as block, o as fromCostumeSource, s as fromPrimitiveSource, t as attachStack, u as Shadow } from "../composer-BudVTTBs.mjs";
 
 //#region src/blocks/control.ts
+/**
+* Repeats enclosed blocks a fixed number of times.
+*
+* Input: `times`, `handler`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param times PrimitiveSource<number>. number of iterations
+* @param handler () => void. body of the loop
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { repeat } from 'hikkaku/blocks'
+*
+* repeat(10, () => {})
+* ```
+*/
 const repeat = (times, handler) => {
 	const substackId = substack(handler);
 	return block("control_repeat", { inputs: {
 		TIMES: fromPrimitiveSource(times),
-		...substackId ? { SUBSTACK: [2, substackId] } : {}
+		...substackId ? { SUBSTACK: [Shadow.NoShadow, substackId] } : {}
 	} });
 };
+/**
+* Repeats until the condition becomes true.
+*
+* Input: `condition`, `handler`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param condition PrimitiveSource<boolean>
+* @param handler () => void
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { repeatUntil } from 'hikkaku/blocks'
+*
+* repeatUntil(true, () => {})
+* ```
+*/
 const repeatUntil = (condition, handler) => {
 	const substackId = substack(handler);
 	return block("control_repeat_until", { inputs: {
 		CONDITION: fromPrimitiveSource(condition),
-		...substackId ? { SUBSTACK: [2, substackId] } : {}
+		...substackId ? { SUBSTACK: [Shadow.NoShadow, substackId] } : {}
 	} });
 };
+/**
+* Repeats while the condition remains true.
+*
+* Input: `condition`, `handler`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param condition PrimitiveSource<boolean>
+* @param handler () => void
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { repeatWhile } from 'hikkaku/blocks'
+*
+* repeatWhile(true, () => {})
+* ```
+*/
 const repeatWhile = (condition, handler) => {
 	const substackId = substack(handler);
 	return block("control_while", { inputs: {
 		CONDITION: fromPrimitiveSource(condition),
-		...substackId ? { SUBSTACK: [2, substackId] } : {}
+		...substackId ? { SUBSTACK: [Shadow.NoShadow, substackId] } : {}
 	} });
 };
+/**
+* Loops with a loop variable.
+*
+* Input: `variable`, `value`, `handler`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param variable VariableReference
+* @param value PrimitiveSource<number>. upper bound
+* @param handler () => void
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { forEach } from 'hikkaku/blocks'
+*
+* forEach(variable as any, 10, () => {})
+* ```
+*/
 const forEach = (variable, value, handler) => {
 	const substackId = substack(handler);
 	return block("control_for_each", {
 		inputs: {
 			VALUE: fromPrimitiveSource(value),
-			...substackId ? { SUBSTACK: [2, substackId] } : {}
+			...substackId ? { SUBSTACK: [Shadow.NoShadow, substackId] } : {}
 		},
 		fields: { VARIABLE: [variable.name, variable.id] }
 	});
 };
+/**
+* Infinite loop.
+*
+* Input: `handler`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param handler () => void
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { forever } from 'hikkaku/blocks'
+*
+* forever(() => {})
+* ```
+*/
 const forever = (handler) => {
 	const substackId = substack(handler);
-	return block("control_forever", { inputs: substackId ? { SUBSTACK: [2, substackId] } : {} });
-};
+	return block("control_forever", { inputs: substackId ? { SUBSTACK: [Shadow.NoShadow, substackId] } : {} });
+};
+/**
+* Pauses execution.
+*
+* Input: `seconds`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param seconds PrimitiveSource<number>
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { wait } from 'hikkaku/blocks'
+*
+* wait(10)
+* ```
+*/
 const wait = (seconds) => {
 	return block("control_wait", { inputs: { DURATION: fromPrimitiveSource(seconds) } });
 };
+/**
+* Waits until condition becomes true.
+*
+* Input: `condition`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param condition PrimitiveSource<boolean>
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { waitUntil } from 'hikkaku/blocks'
+*
+* waitUntil(true)
+* ```
+*/
 const waitUntil = (condition) => {
 	return block("control_wait_until", { inputs: { CONDITION: fromPrimitiveSource(condition) } });
 };
+/**
+* Conditional execution.
+*
+* Input: `condition`, `handler`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param condition PrimitiveSource<boolean>
+* @param handler () => void
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { ifThen } from 'hikkaku/blocks'
+*
+* ifThen(true, () => {})
+* ```
+*/
 const ifThen = (condition, handler) => {
 	const substackId = substack(handler);
 	return block("control_if", { inputs: {
 		CONDITION: fromPrimitiveSource(condition),
-		...substackId ? { SUBSTACK: [2, substackId] } : {}
+		...substackId ? { SUBSTACK: [Shadow.NoShadow, substackId] } : {}
 	} });
 };
+/**
+* If / else branching.
+*
+* Input: `condition`, `thenHandler`, `elseHandler`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param condition PrimitiveSource<boolean>
+* @param thenHandler () => void
+* @param elseHandler () => void
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { ifElse } from 'hikkaku/blocks'
+*
+* ifElse(true, () => {}, () => {})
+* ```
+*/
 const ifElse = (condition, thenHandler, elseHandler) => {
 	const thenSubstackId = substack(thenHandler);
 	const elseSubstackId = substack(elseHandler);
 	return block("control_if_else", { inputs: {
 		CONDITION: fromPrimitiveSource(condition),
-		...thenSubstackId ? { SUBSTACK: [2, thenSubstackId] } : {},
-		...elseSubstackId ? { SUBSTACK2: [2, elseSubstackId] } : {}
+		...thenSubstackId ? { SUBSTACK: [Shadow.NoShadow, thenSubstackId] } : {},
+		...elseSubstackId ? { SUBSTACK2: [Shadow.NoShadow, elseSubstackId] } : {}
 	} });
 };
+/**
+* Builds chained if / else-if / else branching from condition-handler pairs.
+*
+* Input: `branches`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param branches Input value used by this block.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { match } from 'hikkaku/blocks'
+*
+* match(...[[true, () => {}]] as any)
+* ```
+*/
+const match = (...branches) => {
+	if (branches.length === 0) return;
+	const tail = branches[branches.length - 1];
+	const defaultHandler = typeof tail === "function" ? tail : null;
+	const branchList = defaultHandler ? branches.slice(0, -1) : branches;
+	if (branchList.length === 0) return defaultHandler?.();
+	let elseHandler = defaultHandler ?? (() => {});
+	for (let i = branchList.length - 1; i >= 0; i--) {
+		const branch = branchList[i];
+		if (!branch) continue;
+		const [condition, handler] = branch;
+		const next = elseHandler;
+		elseHandler = () => {
+			ifElse(condition, handler, next);
+		};
+	}
+	return elseHandler();
+};
+/**
+* Stops scripts.
+*
+* Input: `option`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param option 'all' | 'this script' | 'other scripts in sprite' | 'other scripts in stage'
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { stop } from 'hikkaku/blocks'
+*
+* stop('all')
+* ```
+*/
 const stop = (option) => {
 	return block("control_stop", { fields: { STOP_OPTION: [option, null] } });
 };
+/**
+* Special menu value for cloning the current sprite.
+*
+* Input: none.
+* Output: String constant used as the `target` argument of {@link createClone}.
+*
+* @example
+* ```ts
+* import { CREATE_CLONE_MYSELF, createClone } from 'hikkaku/blocks'
+*
+* createClone(CREATE_CLONE_MYSELF)
+* ```
+*/
 const CREATE_CLONE_MYSELF = "_myself_";
+/**
+* Creates a clone of a target.
+*
+* Input: `target`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param target string
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { createClone } from 'hikkaku/blocks'
+*
+* createClone('mouse-pointer')
+* ```
+*/
 const createClone = (target) => {
 	return block("control_create_clone_of", { inputs: { CLONE_OPTION: fromPrimitiveSource(target) } });
 };
+/**
+* Deletes the current clone.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { deleteThisClone } from 'hikkaku/blocks'
+*
+* deleteThisClone()
+* ```
+*/
 const deleteThisClone = () => {
 	return block("control_delete_this_clone", {});
 };
+/**
+* Returns the global counter value.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getCounter } from 'hikkaku/blocks'
+*
+* getCounter()
+* ```
+*/
 const getCounter = () => {
 	return valueBlock("control_get_counter", {});
 };
+/**
+* Increments the counter.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { incrCounter } from 'hikkaku/blocks'
+*
+* incrCounter()
+* ```
+*/
 const incrCounter = () => {
 	return block("control_incr_counter", {});
 };
+/**
+* Resets the counter.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { clearCounter } from 'hikkaku/blocks'
+*
+* clearCounter()
+* ```
+*/
 const clearCounter = () => {
 	return block("control_clear_counter", {});
 };
+/**
+* Starts the script when the clone is created. You should use this to control clone behavior.
+*
+* Input: `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param stack Input value used by this block. Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { controlStartAsClone } from 'hikkaku/blocks'
+*
+* controlStartAsClone(() => {})
+* ```
+*/
 const controlStartAsClone = (stack) => {
 	const res = block("control_start_as_clone", { topLevel: true });
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Executes enclosed blocks without screen refresh.
+*
+* Input: `handler`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param handler () => void
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { allAtOnce } from 'hikkaku/blocks'
+*
+* allAtOnce(() => {})
+* ```
+*/
 const allAtOnce = (handler) => {
 	const substackId = substack(handler);
-	return block("control_all_at_once", { inputs: substackId ? { SUBSTACK: [2, substackId] } : {} });
+	return block("control_all_at_once", { inputs: substackId ? { SUBSTACK: [Shadow.NoShadow, substackId] } : {} });
 };
 
 //#endregion
 //#region src/blocks/data.ts
 const toField = (field) => [field.name, field.id];
+/**
+* Returns the value of a variable.
+*
+* Input: `variable`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param variable VariableReference
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getVariable } from 'hikkaku/blocks'
+*
+* getVariable(variable as any)
+* ```
+*/
 const getVariable = (variable) => {
 	return valueBlock("data_variable", { fields: { VARIABLE: toField(variable) } });
 };
+/**
+* Sets a variable.
+*
+* Input: `variable`, `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param variable VariableReference
+* @param value PrimitiveSource<number | string>
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setVariableTo } from 'hikkaku/blocks'
+*
+* setVariableTo(variable as any, 10)
+* ```
+*/
 const setVariableTo = (variable, value) => {
 	return block("data_setvariableto", {
 		inputs: { VALUE: fromPrimitiveSource(value) },
 		fields: { VARIABLE: toField(variable) }
 	});
 };
+/**
+* Changes a variable by an amount.
+*
+* Input: `variable`, `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param variable VariableReference
+* @param value PrimitiveSource<number>
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changeVariableBy } from 'hikkaku/blocks'
+*
+* changeVariableBy(variable as any, 10)
+* ```
+*/
 const changeVariableBy = (variable, value) => {
 	return block("data_changevariableby", {
 		inputs: { VALUE: fromPrimitiveSource(value) },
 		fields: { VARIABLE: toField(variable) }
 	});
 };
+/**
+* Shows variable monitor.
+*
+* Input: `variable`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param variable See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { showVariable } from 'hikkaku/blocks'
+*
+* showVariable(variable as any)
+* ```
+*/
 const showVariable = (variable) => {
 	return block("data_showvariable", { fields: { VARIABLE: toField(variable) } });
 };
+/**
+* Hides variable monitor.
+*
+* Input: `variable`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param variable See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { hideVariable } from 'hikkaku/blocks'
+*
+* hideVariable(variable as any)
+* ```
+*/
 const hideVariable = (variable) => {
 	return block("data_hidevariable", { fields: { VARIABLE: toField(variable) } });
 };
+/**
+* Returns list contents as text.
+*
+* Input: `list`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param list ListReference
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getListContents } from 'hikkaku/blocks'
+*
+* getListContents(list as any)
+* ```
+*/
 const getListContents = (list) => {
 	return valueBlock("data_listcontents", { fields: { LIST: toField(list) } });
 };
+/**
+* Appends an item.
+*
+* Input: `list`, `item`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param list ListReference
+* @param item PrimitiveSource<string | number>
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { addToList } from 'hikkaku/blocks'
+*
+* addToList(list as any, undefined as any)
+* ```
+*/
 const addToList = (list, item) => {
 	return block("data_addtolist", {
 		inputs: { ITEM: fromPrimitiveSource(item) },
 		fields: { LIST: toField(list) }
 	});
 };
+/**
+* Deletes an item.
+*
+* Input: `list`, `index`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param list Input value used by this block.
+* @param index PrimitiveSource<number | string>
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { deleteOfList } from 'hikkaku/blocks'
+*
+* deleteOfList(list as any, undefined as any)
+* ```
+*/
 const deleteOfList = (list, index) => {
 	return block("data_deleteoflist", {
 		inputs: { INDEX: fromPrimitiveSource(index) },
 		fields: { LIST: toField(list) }
 	});
 };
+/**
+* Clears list.
+*
+* Input: `list`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param list See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { deleteAllOfList } from 'hikkaku/blocks'
+*
+* deleteAllOfList(list as any)
+* ```
+*/
 const deleteAllOfList = (list) => {
 	return block("data_deletealloflist", { fields: { LIST: toField(list) } });
 };
+/**
+* Inserts item at index.
+*
+* Input: `list`, `index`, `item`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param list See function signature for accepted input values.
+* @param index See function signature for accepted input values.
+* @param item See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { insertAtList } from 'hikkaku/blocks'
+*
+* insertAtList(list as any, undefined as any, undefined as any)
+* ```
+*/
 const insertAtList = (list, index, item) => {
 	return block("data_insertatlist", {
 		inputs: {
@@ -138,6 +599,23 @@ const insertAtList = (list, index, item) => {
 		fields: { LIST: toField(list) }
 	});
 };
+/**
+* Replaces item at index.
+*
+* Input: `list`, `index`, `item`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param list See function signature for accepted input values.
+* @param index See function signature for accepted input values.
+* @param item See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { replaceItemOfList } from 'hikkaku/blocks'
+*
+* replaceItemOfList(list as any, undefined as any, undefined as any)
+* ```
+*/
 const replaceItemOfList = (list, index, item) => {
 	return block("data_replaceitemoflist", {
 		inputs: {
@@ -147,218 +625,968 @@ const replaceItemOfList = (list, index, item) => {
 		fields: { LIST: toField(list) }
 	});
 };
+/**
+* Returns list item.
+*
+* Input: `list`, `index`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param list See function signature for accepted input values.
+* @param index See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getItemOfList } from 'hikkaku/blocks'
+*
+* getItemOfList(list as any, undefined as any)
+* ```
+*/
 const getItemOfList = (list, index) => {
 	return valueBlock("data_itemoflist", {
 		inputs: { INDEX: fromPrimitiveSource(index) },
 		fields: { LIST: toField(list) }
 	});
 };
+/**
+* Returns index of item.
+*
+* Input: `list`, `item`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param list See function signature for accepted input values.
+* @param item See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getItemNumOfList } from 'hikkaku/blocks'
+*
+* getItemNumOfList(list as any, undefined as any)
+* ```
+*/
 const getItemNumOfList = (list, item) => {
 	return valueBlock("data_itemnumoflist", {
 		inputs: { ITEM: fromPrimitiveSource(item) },
 		fields: { LIST: toField(list) }
 	});
 };
+/**
+* Returns list length.
+*
+* Input: `list`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param list See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { lengthOfList } from 'hikkaku/blocks'
+*
+* lengthOfList(list as any)
+* ```
+*/
 const lengthOfList = (list) => {
 	return valueBlock("data_lengthoflist", { fields: { LIST: toField(list) } });
 };
+/**
+* Checks membership.
+*
+* Input: `list`, `item`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param list See function signature for accepted input values.
+* @param item See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { listContainsItem } from 'hikkaku/blocks'
+*
+* listContainsItem(list as any, undefined as any)
+* ```
+*/
 const listContainsItem = (list, item) => {
 	return valueBlock("data_listcontainsitem", {
 		inputs: { ITEM: fromPrimitiveSource(item) },
 		fields: { LIST: toField(list) }
 	});
 };
+/**
+* Shows list monitor.
+*
+* Input: `list`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param list See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { showList } from 'hikkaku/blocks'
+*
+* showList(list as any)
+* ```
+*/
 const showList = (list) => {
 	return block("data_showlist", { fields: { LIST: toField(list) } });
 };
+/**
+* Hides list monitor.
+*
+* Input: `list`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param list See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { hideList } from 'hikkaku/blocks'
+*
+* hideList(list as any)
+* ```
+*/
 const hideList = (list) => {
 	return block("data_hidelist", { fields: { LIST: toField(list) } });
 };
 
 //#endregion
 //#region src/blocks/events.ts
+/**
+* Runs when green flag is clicked.
+*
+* Input: `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param stack () => void Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { whenFlagClicked } from 'hikkaku/blocks'
+*
+* whenFlagClicked(() => {})
+* ```
+*/
 const whenFlagClicked = (stack) => {
 	const res = block("event_whenflagclicked", { topLevel: true });
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Runs when key is pressed.
+*
+* Input: `key`, `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param key string
+* @param stack Input value used by this block. Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { whenKeyPressed } from 'hikkaku/blocks'
+*
+* whenKeyPressed('space', () => {})
+* ```
+*/
 const whenKeyPressed = (key, stack) => {
 	const res = block("event_whenkeypressed", {
 		topLevel: true,
 		fields: { KEY_OPTION: [key, null] }
 	});
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Runs when sprite is clicked.
+*
+* Input: `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param stack See function signature for accepted input values. Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { whenThisSpriteClicked } from 'hikkaku/blocks'
+*
+* whenThisSpriteClicked(() => {})
+* ```
+*/
 const whenThisSpriteClicked = (stack) => {
 	const res = block("event_whenthisspriteclicked", { topLevel: true });
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Runs when stage is clicked.
+*
+* Input: `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param stack See function signature for accepted input values. Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { whenStageClicked } from 'hikkaku/blocks'
+*
+* whenStageClicked(() => {})
+* ```
+*/
 const whenStageClicked = (stack) => {
 	const res = block("event_whenstageclicked", { topLevel: true });
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Runs when backdrop changes.
+*
+* Input: `backdrop`, `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param backdrop See function signature for accepted input values.
+* @param stack See function signature for accepted input values. Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { whenBackdropSwitchesTo } from 'hikkaku/blocks'
+*
+* whenBackdropSwitchesTo('backdrop1', () => {})
+* ```
+*/
 const whenBackdropSwitchesTo = (backdrop, stack) => {
 	const res = block("event_whenbackdropswitchesto", {
 		topLevel: true,
 		fields: { BACKDROP: [backdrop, null] }
 	});
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Runs when a broadcast is received.
+*
+* Input: `broadcast`, `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param broadcast See function signature for accepted input values.
+* @param stack See function signature for accepted input values. Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { whenBroadcastReceived } from 'hikkaku/blocks'
+*
+* whenBroadcastReceived('message1', () => {})
+* ```
+*/
 const whenBroadcastReceived = (broadcast, stack) => {
 	const res = block("event_whenbroadcastreceived", {
 		topLevel: true,
 		fields: { BROADCAST_OPTION: [broadcast, null] }
 	});
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Runs when touching object.
+*
+* Input: `target`, `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param target See function signature for accepted input values.
+* @param stack See function signature for accepted input values. Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { whenTouchingObject } from 'hikkaku/blocks'
+*
+* whenTouchingObject('mouse-pointer', () => {})
+* ```
+*/
 const whenTouchingObject = (target, stack) => {
 	const res = block("event_whentouchingobject", {
 		topLevel: true,
 		fields: { TOUCHINGOBJECTMENU: [target, null] }
 	});
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Triggered by sensor threshold.
+*
+* Input: `menu`, `value`, `stack`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param menu See function signature for accepted input values.
+* @param value See function signature for accepted input values.
+* @param stack See function signature for accepted input values. Optional.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { whenGreaterThan } from 'hikkaku/blocks'
+*
+* whenGreaterThan('loudness', 10, () => {})
+* ```
+*/
 const whenGreaterThan = (menu, value, stack) => {
 	const res = block("event_whengreaterthan", {
 		topLevel: true,
 		inputs: { VALUE: fromPrimitiveSource(value) },
 		fields: { WHENGREATERTHANMENU: [menu, null] }
 	});
-	stack?.();
+	attachStack(res.id, stack);
 	return res;
 };
+/**
+* Sends a broadcast.
+*
+* Input: `message`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param message See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { broadcast } from 'hikkaku/blocks'
+*
+* broadcast('Hello')
+* ```
+*/
 const broadcast = (message) => {
-	return block("event_broadcast", { inputs: { BROADCAST_INPUT: typeof message === "string" ? [1, [11, message]] : fromPrimitiveSource(message) } });
-};
+	return block("event_broadcast", { inputs: { BROADCAST_INPUT: typeof message === "string" ? [Shadow.SameBlockShadow, [
+		InputType.Broadcast,
+		message,
+		message
+	]] : fromPrimitiveSource(message) } });
+};
+/**
+* Broadcasts and waits.
+*
+* Input: `message`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param message See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { broadcastAndWait } from 'hikkaku/blocks'
+*
+* broadcastAndWait('Hello')
+* ```
+*/
 const broadcastAndWait = (message) => {
 	return block("event_broadcastandwait", { inputs: { BROADCAST_INPUT: fromPrimitiveSource(message) } });
 };
 
 //#endregion
 //#region src/blocks/looks.ts
+/**
+* Displays a speech bubble.
+*
+* Input: `message`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param message See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { say } from 'hikkaku/blocks'
+*
+* say('Hello')
+* ```
+*/
 const say = (message) => {
 	return block("looks_say", { inputs: { MESSAGE: fromPrimitiveSource(message) } });
 };
+/**
+* Speaks for duration.
+*
+* Input: `message`, `seconds`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param message See function signature for accepted input values.
+* @param seconds See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { sayForSecs } from 'hikkaku/blocks'
+*
+* sayForSecs('Hello', 10)
+* ```
+*/
 const sayForSecs = (message, seconds) => {
 	return block("looks_sayforsecs", { inputs: {
 		MESSAGE: fromPrimitiveSource(message),
 		SECS: fromPrimitiveSource(seconds)
 	} });
 };
+/**
+* Displays thought bubble.
+*
+* Input: `message`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param message See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { think } from 'hikkaku/blocks'
+*
+* think('Hello')
+* ```
+*/
 const think = (message) => {
 	return block("looks_think", { inputs: { MESSAGE: fromPrimitiveSource(message) } });
 };
+/**
+* Thinks for duration.
+*
+* Input: `message`, `seconds`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param message See function signature for accepted input values.
+* @param seconds See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { thinkForSecs } from 'hikkaku/blocks'
+*
+* thinkForSecs('Hello', 10)
+* ```
+*/
 const thinkForSecs = (message, seconds) => {
 	return block("looks_thinkforsecs", { inputs: {
 		MESSAGE: fromPrimitiveSource(message),
 		SECS: fromPrimitiveSource(seconds)
 	} });
 };
+/**
+* Shows sprite.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { show } from 'hikkaku/blocks'
+*
+* show()
+* ```
+*/
 const show = () => {
 	return block("looks_show", {});
 };
+/**
+* Hides sprite.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { hide } from 'hikkaku/blocks'
+*
+* hide()
+* ```
+*/
 const hide = () => {
 	return block("looks_hide", {});
 };
+/**
+* Switches costume.
+*
+* Input: `costume`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param costume See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { switchCostumeTo } from 'hikkaku/blocks'
+*
+* switchCostumeTo('costume1')
+* ```
+*/
 const switchCostumeTo = (costume) => {
 	return block("looks_switchcostumeto", { inputs: { COSTUME: fromCostumeSource(costume) } });
 };
+/**
+* Next costume.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { nextCostume } from 'hikkaku/blocks'
+*
+* nextCostume()
+* ```
+*/
 const nextCostume = () => {
 	return block("looks_nextcostume", {});
 };
+/**
+* Switch backdrop.
+*
+* Input: `backdrop`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param backdrop See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { switchBackdropTo } from 'hikkaku/blocks'
+*
+* switchBackdropTo('backdrop1')
+* ```
+*/
 const switchBackdropTo = (backdrop) => {
 	return block("looks_switchbackdropto", { inputs: { BACKDROP: fromPrimitiveSource(backdrop) } });
 };
+/**
+* Switch backdrop and wait.
+*
+* Input: `backdrop`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param backdrop See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { switchBackdropToAndWait } from 'hikkaku/blocks'
+*
+* switchBackdropToAndWait('backdrop1')
+* ```
+*/
 const switchBackdropToAndWait = (backdrop) => {
 	return block("looks_switchbackdroptoandwait", { inputs: { BACKDROP: fromPrimitiveSource(backdrop) } });
 };
+/**
+* Next backdrop.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { nextBackdrop } from 'hikkaku/blocks'
+*
+* nextBackdrop()
+* ```
+*/
 const nextBackdrop = () => {
 	return block("looks_nextbackdrop", {});
 };
+/**
+* Changes graphic effect.
+*
+* Input: `effect`, `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param effect See function signature for accepted input values.
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changeLooksEffectBy } from 'hikkaku/blocks'
+*
+* changeLooksEffectBy('color', 10)
+* ```
+*/
 const changeLooksEffectBy = (effect, value) => {
 	return block("looks_changeeffectby", {
 		inputs: { CHANGE: fromPrimitiveSource(value) },
 		fields: { EFFECT: [effect, null] }
 	});
 };
+/**
+* Sets graphic effect.
+*
+* Input: `effect`, `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param effect See function signature for accepted input values.
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setLooksEffectTo } from 'hikkaku/blocks'
+*
+* setLooksEffectTo('color', 10)
+* ```
+*/
 const setLooksEffectTo = (effect, value) => {
 	return block("looks_seteffectto", {
 		inputs: { VALUE: fromPrimitiveSource(value) },
 		fields: { EFFECT: [effect, null] }
 	});
 };
+/**
+* Clears effects.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { clearGraphicEffects } from 'hikkaku/blocks'
+*
+* clearGraphicEffects()
+* ```
+*/
 const clearGraphicEffects = () => {
 	return block("looks_cleargraphiceffects", {});
 };
+/**
+* Changes size.
+*
+* Input: `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changeSizeBy } from 'hikkaku/blocks'
+*
+* changeSizeBy(10)
+* ```
+*/
 const changeSizeBy = (value) => {
 	return block("looks_changesizeby", { inputs: { CHANGE: fromPrimitiveSource(value) } });
 };
+/**
+* Sets size.
+*
+* Input: `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setSizeTo } from 'hikkaku/blocks'
+*
+* setSizeTo(10)
+* ```
+*/
 const setSizeTo = (value) => {
 	return block("looks_setsizeto", { inputs: { SIZE: fromPrimitiveSource(value) } });
 };
+/**
+* Moves sprite layer.
+*
+* Input: `position`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param position See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { goToFrontBack } from 'hikkaku/blocks'
+*
+* goToFrontBack('front')
+* ```
+*/
 const goToFrontBack = (position) => {
 	return block("looks_gotofrontback", { fields: { FRONT_BACK: [position, null] } });
 };
+/**
+* Moves layers.
+*
+* Input: `direction`, `layers`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param direction See function signature for accepted input values.
+* @param layers See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { goForwardBackwardLayers } from 'hikkaku/blocks'
+*
+* goForwardBackwardLayers('forward', 10)
+* ```
+*/
 const goForwardBackwardLayers = (direction, layers) => {
 	return block("looks_goforwardbackwardlayers", {
 		inputs: { NUM: fromPrimitiveSource(layers) },
 		fields: { FORWARD_BACKWARD: [direction, null] }
 	});
 };
+/**
+* Returns size.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getSize } from 'hikkaku/blocks'
+*
+* getSize()
+* ```
+*/
 const getSize = () => {
 	return valueBlock("looks_size", {});
 };
+/**
+* Returns costume number or name.
+*
+* Input: `value`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param value See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getCostumeNumberName } from 'hikkaku/blocks'
+*
+* getCostumeNumberName(10)
+* ```
+*/
 const getCostumeNumberName = (value) => {
 	return valueBlock("looks_costumenumbername", { fields: { NUMBER_NAME: [value, null] } });
 };
+/**
+* Returns backdrop number or name.
+*
+* Input: `value`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param value See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getBackdropNumberName } from 'hikkaku/blocks'
+*
+* getBackdropNumberName(10)
+* ```
+*/
 const getBackdropNumberName = (value) => {
 	return valueBlock("looks_backdropnumbername", { fields: { NUMBER_NAME: [value, null] } });
 };
 
 //#endregion
 //#region src/blocks/motion.ts
+/**
+* Moves sprite.
+*
+* Input: `steps`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param steps See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { moveSteps } from 'hikkaku/blocks'
+*
+* moveSteps(undefined as any)
+* ```
+*/
 const moveSteps = (steps) => {
 	return block("motion_movesteps", { inputs: { STEPS: fromPrimitiveSource(steps) } });
 };
+/**
+* Moves to coordinates.
+*
+* Input: `x`, `y`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param x See function signature for accepted input values.
+* @param y See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { gotoXY } from 'hikkaku/blocks'
+*
+* gotoXY(10, 10)
+* ```
+*/
 const gotoXY = (x, y) => {
 	return block("motion_gotoxy", { inputs: {
 		X: fromPrimitiveSource(x),
 		Y: fromPrimitiveSource(y)
 	} });
 };
+/**
+* Changes X.
+*
+* Input: `dx`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param dx See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changeXBy } from 'hikkaku/blocks'
+*
+* changeXBy(10)
+* ```
+*/
 const changeXBy = (dx) => {
 	return block("motion_changexby", { inputs: { DX: fromPrimitiveSource(dx) } });
 };
+/**
+* Changes Y.
+*
+* Input: `dy`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param dy See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changeYBy } from 'hikkaku/blocks'
+*
+* changeYBy(10)
+* ```
+*/
 const changeYBy = (dy) => {
 	return block("motion_changeyby", { inputs: { DY: fromPrimitiveSource(dy) } });
 };
+/**
+* Sets X.
+*
+* Input: `x`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param x See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setX } from 'hikkaku/blocks'
+*
+* setX(10)
+* ```
+*/
 const setX = (x) => {
 	return block("motion_setx", { inputs: { X: fromPrimitiveSource(x) } });
 };
+/**
+* Sets Y.
+*
+* Input: `y`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param y See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setY } from 'hikkaku/blocks'
+*
+* setY(10)
+* ```
+*/
 const setY = (y) => {
 	return block("motion_sety", { inputs: { Y: fromPrimitiveSource(y) } });
 };
+/**
+* Moves to target.
+*
+* Input: `target`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param target See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { goTo } from 'hikkaku/blocks'
+*
+* goTo('mouse-pointer')
+* ```
+*/
 const goTo = (target) => {
 	return block("motion_goto", { fields: { TO: [target, null] } });
 };
+/**
+* Turns right.
+*
+* Input: `degrees`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param degrees See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { turnRight } from 'hikkaku/blocks'
+*
+* turnRight(10)
+* ```
+*/
 const turnRight = (degrees) => {
 	return block("motion_turnright", { inputs: { DEGREES: fromPrimitiveSource(degrees) } });
 };
+/**
+* Turns left.
+*
+* Input: `degrees`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param degrees See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { turnLeft } from 'hikkaku/blocks'
+*
+* turnLeft(10)
+* ```
+*/
 const turnLeft = (degrees) => {
 	return block("motion_turnleft", { inputs: { DEGREES: fromPrimitiveSource(degrees) } });
 };
+/**
+* Points direction.
+*
+* Input: `direction`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param direction See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { pointInDirection } from 'hikkaku/blocks'
+*
+* pointInDirection('forward')
+* ```
+*/
 const pointInDirection = (direction) => {
 	return block("motion_pointindirection", { inputs: { DIRECTION: fromPrimitiveSource(direction) } });
 };
+/**
+* Points toward target.
+*
+* Input: `target`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param target See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { pointTowards } from 'hikkaku/blocks'
+*
+* pointTowards('mouse-pointer')
+* ```
+*/
 const pointTowards = (target) => {
 	return block("motion_pointtowards", { fields: { TOWARDS: [target, null] } });
 };
+/**
+* Glides to position.
+*
+* Input: `seconds`, `x`, `y`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param seconds See function signature for accepted input values.
+* @param x See function signature for accepted input values.
+* @param y See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { glide } from 'hikkaku/blocks'
+*
+* glide(10, 10, 10)
+* ```
+*/
 const glide = (seconds, x, y) => {
 	return block("motion_glidesecstoxy", { inputs: {
 		SECS: fromPrimitiveSource(seconds),
@@ -366,123 +1594,495 @@ const glide = (seconds, x, y) => {
 		Y: fromPrimitiveSource(y)
 	} });
 };
+/**
+* Glides to target.
+*
+* Input: `seconds`, `target`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param seconds See function signature for accepted input values.
+* @param target See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { glideTo } from 'hikkaku/blocks'
+*
+* glideTo(10, 'mouse-pointer')
+* ```
+*/
 const glideTo = (seconds, target) => {
 	return block("motion_glideto", {
 		inputs: { SECS: fromPrimitiveSource(seconds) },
 		fields: { TO: [target, null] }
 	});
 };
+/**
+* Bounces on edge.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { ifOnEdgeBounce } from 'hikkaku/blocks'
+*
+* ifOnEdgeBounce()
+* ```
+*/
 const ifOnEdgeBounce = () => {
 	return block("motion_ifonedgebounce", {});
 };
+/**
+* Sets rotation style.
+*
+* Input: `style`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param style See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setRotationStyle } from 'hikkaku/blocks'
+*
+* setRotationStyle('all around')
+* ```
+*/
 const setRotationStyle = (style) => {
 	return block("motion_setrotationstyle", { fields: { STYLE: [style, null] } });
 };
+/**
+* Returns X position.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getX } from 'hikkaku/blocks'
+*
+* getX()
+* ```
+*/
 const getX = () => {
 	return valueBlock("motion_xposition", {});
 };
+/**
+* Returns Y position.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getY } from 'hikkaku/blocks'
+*
+* getY()
+* ```
+*/
 const getY = () => {
 	return valueBlock("motion_yposition", {});
 };
+/**
+* Returns direction.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getDirection } from 'hikkaku/blocks'
+*
+* getDirection()
+* ```
+*/
 const getDirection = () => {
 	return valueBlock("motion_direction", {});
 };
 
 //#endregion
 //#region src/blocks/operator.ts
+/**
+* Addition.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { add } from 'hikkaku/blocks'
+*
+* add(1, 2)
+* ```
+*/
 const add = (a, b) => {
 	return valueBlock("operator_add", { inputs: {
 		NUM1: fromPrimitiveSource(a),
 		NUM2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Subtraction.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { subtract } from 'hikkaku/blocks'
+*
+* subtract(5, 3)
+* ```
+*/
 const subtract = (a, b) => {
 	return valueBlock("operator_subtract", { inputs: {
 		NUM1: fromPrimitiveSource(a),
 		NUM2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Multiplication.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { multiply } from 'hikkaku/blocks'
+*
+* multiply(3, 4)
+* ```
+*/
 const multiply = (a, b) => {
 	return valueBlock("operator_multiply", { inputs: {
 		NUM1: fromPrimitiveSource(a),
 		NUM2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Division.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { divide } from 'hikkaku/blocks'
+*
+* divide(10, 2)
+* ```
+*/
 const divide = (a, b) => {
 	return valueBlock("operator_divide", { inputs: {
 		NUM1: fromPrimitiveSource(a),
 		NUM2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Less-than comparison.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { lt } from 'hikkaku/blocks'
+*
+* lt(1, 2)
+* ```
+*/
 const lt = (a, b) => {
 	return valueBlock("operator_lt", { inputs: {
 		OPERAND1: fromPrimitiveSource(a),
 		OPERAND2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Equality comparison.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { equals } from 'hikkaku/blocks'
+*
+* equals(5, 5)
+* ```
+*/
 const equals = (a, b) => {
 	return valueBlock("operator_equals", { inputs: {
 		OPERAND1: fromPrimitiveSource(a),
 		OPERAND2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Greater-than comparison.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { gt } from 'hikkaku/blocks'
+*
+* gt(10, 5)
+* ```
+*/
 const gt = (a, b) => {
 	return valueBlock("operator_gt", { inputs: {
 		OPERAND1: fromPrimitiveSource(a),
 		OPERAND2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Logical AND.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { and } from 'hikkaku/blocks'
+*
+* and(true, false)
+* ```
+*/
 const and = (a, b) => {
 	return valueBlock("operator_and", { inputs: {
 		OPERAND1: fromPrimitiveSource(a),
 		OPERAND2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Logical OR.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { or } from 'hikkaku/blocks'
+*
+* or(true, false)
+* ```
+*/
 const or = (a, b) => {
 	return valueBlock("operator_or", { inputs: {
 		OPERAND1: fromPrimitiveSource(a),
 		OPERAND2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Logical NOT.
+*
+* Input: `operand`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param operand See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { not } from 'hikkaku/blocks'
+*
+* not(false)
+* ```
+*/
 const not = (operand) => {
 	return valueBlock("operator_not", { inputs: { OPERAND: fromPrimitiveSource(operand) } });
 };
+/**
+* Random number.
+*
+* Input: `from`, `to`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param from See function signature for accepted input values.
+* @param to See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { random } from 'hikkaku/blocks'
+*
+* random(10, 10)
+* ```
+*/
 const random = (from, to) => {
 	return valueBlock("operator_random", { inputs: {
 		FROM: fromPrimitiveSource(from),
 		TO: fromPrimitiveSource(to)
 	} });
 };
+/**
+* String concatenation.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { join } from 'hikkaku/blocks'
+*
+* join('Hello', 'World')
+* ```
+*/
 const join = (a, b) => {
 	return valueBlock("operator_join", { inputs: {
 		STRING1: fromPrimitiveSource(a),
 		STRING2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Character extraction.
+*
+* Input: `letter`, `text`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param letter See function signature for accepted input values.
+* @param text See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { letterOf } from 'hikkaku/blocks'
+*
+* letterOf(10, 'Hello')
+* ```
+*/
 const letterOf = (letter, text) => {
 	return valueBlock("operator_letter_of", { inputs: {
 		LETTER: fromPrimitiveSource(letter),
 		STRING: fromPrimitiveSource(text)
 	} });
 };
+/**
+* String length.
+*
+* Input: `text`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param text See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { length } from 'hikkaku/blocks'
+*
+* length('Hello')
+* ```
+*/
 const length = (text) => {
 	return valueBlock("operator_length", { inputs: { STRING: fromPrimitiveSource(text) } });
 };
+/**
+* Substring check.
+*
+* Input: `text`, `substring`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param text See function signature for accepted input values.
+* @param substring See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { contains } from 'hikkaku/blocks'
+*
+* contains('Hello', 'Hello')
+* ```
+*/
 const contains = (text, substring) => {
 	return valueBlock("operator_contains", { inputs: {
 		STRING1: fromPrimitiveSource(text),
 		STRING2: fromPrimitiveSource(substring)
 	} });
 };
+/**
+* Modulo.
+*
+* Input: `a`, `b`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param a See function signature for accepted input values.
+* @param b See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { mod } from 'hikkaku/blocks'
+*
+* mod(10, 3)
+* ```
+*/
 const mod = (a, b) => {
 	return valueBlock("operator_mod", { inputs: {
 		NUM1: fromPrimitiveSource(a),
 		NUM2: fromPrimitiveSource(b)
 	} });
 };
+/**
+* Rounds number.
+*
+* Input: `value`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param value See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { round } from 'hikkaku/blocks'
+*
+* round(10)
+* ```
+*/
 const round = (value) => {
 	return valueBlock("operator_round", { inputs: { NUM: fromPrimitiveSource(value) } });
 };
+/**
+* Math operation (sin, cos, log, etc.).
+*
+* Input: `operator`, `value`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param operator See function signature for accepted input values.
+* @param value See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { mathop } from 'hikkaku/blocks'
+*
+* mathop('abs', 10)
+* ```
+*/
 const mathop = (operator, value) => {
 	return valueBlock("operator_mathop", {
 		inputs: { NUM: fromPrimitiveSource(value) },
@@ -492,74 +2092,350 @@ const mathop = (operator, value) => {
 
 //#endregion
 //#region src/blocks/pen.ts
+/**
+* Clears all pen marks.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { eraseAll } from 'hikkaku/blocks'
+*
+* eraseAll()
+* ```
+*/
 const eraseAll = () => {
 	return block("pen_clear", {});
 };
+/**
+* Alias for {@link eraseAll}.
+*
+* Input: none.
+* Output: Same Scratch statement block definition as {@link eraseAll}.
+*
+* @example
+* ```ts
+* import { clear } from 'hikkaku/blocks'
+*
+* clear()
+* ```
+*/
 const clear = eraseAll;
+/**
+* Stamps sprite costume.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { stamp } from 'hikkaku/blocks'
+*
+* stamp()
+* ```
+*/
 const stamp = () => {
 	return block("pen_stamp", {});
 };
+/**
+* Starts drawing.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { penDown } from 'hikkaku/blocks'
+*
+* penDown()
+* ```
+*/
 const penDown = () => {
 	return block("pen_penDown", {});
 };
+/**
+* Stops drawing.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { penUp } from 'hikkaku/blocks'
+*
+* penUp()
+* ```
+*/
 const penUp = () => {
 	return block("pen_penUp", {});
 };
+/**
+* Sets pen color.
+*
+* Input: `color`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param color See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setPenColorTo } from 'hikkaku/blocks'
+*
+* setPenColorTo(undefined as any)
+* ```
+*/
 const setPenColorTo = (color) => {
 	return block("pen_setPenColorToColor", { inputs: { COLOR: fromPrimitiveSource(color) } });
 };
+/**
+* Alias for {@link setPenColorTo}.
+*
+* Input: `color`.
+* Output: Same Scratch statement block definition as {@link setPenColorTo}.
+*
+* @param color See function signature for accepted input values.
+* @example
+* ```ts
+* import { setPenColorToColor } from 'hikkaku/blocks'
+*
+* setPenColorToColor('#ff0000')
+* ```
+*/
 const setPenColorToColor = setPenColorTo;
+/**
+* Changes pen color parameter by amount.
+*
+* Input: `param`, `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param param See function signature for accepted input values.
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changePenColorParamBy } from 'hikkaku/blocks'
+*
+* changePenColorParamBy(undefined as any, 10)
+* ```
+*/
 const changePenColorParamBy = (param, value) => {
 	return block("pen_changePenColorParamBy", { inputs: {
 		COLOR_PARAM: fromPrimitiveSource(param),
 		VALUE: fromPrimitiveSource(value)
 	} });
 };
+/**
+* Sets pen color parameter to value.
+*
+* Input: `param`, `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param param See function signature for accepted input values.
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setPenColorParamTo } from 'hikkaku/blocks'
+*
+* setPenColorParamTo(undefined as any, 10)
+* ```
+*/
 const setPenColorParamTo = (param, value) => {
 	return block("pen_setPenColorParamTo", { inputs: {
 		COLOR_PARAM: fromPrimitiveSource(param),
 		VALUE: fromPrimitiveSource(value)
 	} });
 };
+/**
+* Changes pen size by amount.
+*
+* Input: `size`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param size See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changePenSizeBy } from 'hikkaku/blocks'
+*
+* changePenSizeBy(10)
+* ```
+*/
 const changePenSizeBy = (size) => {
 	return block("pen_changePenSizeBy", { inputs: { SIZE: fromPrimitiveSource(size) } });
 };
+/**
+* Sets pen size to value.
+*
+* Input: `size`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param size See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setPenSizeTo } from 'hikkaku/blocks'
+*
+* setPenSizeTo(10)
+* ```
+*/
 const setPenSizeTo = (size) => {
 	return block("pen_setPenSizeTo", { inputs: { SIZE: fromPrimitiveSource(size) } });
 };
+/**
+* Sets pen shade to value.
+*
+* Input: `shade`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param shade See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setPenShadeToNumber } from 'hikkaku/blocks'
+*
+* setPenShadeToNumber(10)
+* ```
+*/
 const setPenShadeToNumber = (shade) => {
 	return block("pen_setPenShadeToNumber", { inputs: { SHADE: fromPrimitiveSource(shade) } });
 };
+/**
+* Changes pen shade by amount.
+*
+* Input: `shade`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param shade See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changePenShadeBy } from 'hikkaku/blocks'
+*
+* changePenShadeBy(10)
+* ```
+*/
 const changePenShadeBy = (shade) => {
 	return block("pen_changePenShadeBy", { inputs: { SHADE: fromPrimitiveSource(shade) } });
 };
+/**
+* Sets pen hue to value.
+*
+* Input: `hue`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param hue See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setPenHueToNumber } from 'hikkaku/blocks'
+*
+* setPenHueToNumber(10)
+* ```
+*/
 const setPenHueToNumber = (hue) => {
 	return block("pen_setPenHueToNumber", { inputs: { HUE: fromPrimitiveSource(hue) } });
 };
+/**
+* Changes pen hue by amount.
+*
+* Input: `hue`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param hue See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changePenHueBy } from 'hikkaku/blocks'
+*
+* changePenHueBy(10)
+* ```
+*/
 const changePenHueBy = (hue) => {
 	return block("pen_changePenHueBy", { inputs: { HUE: fromPrimitiveSource(hue) } });
 };
 
 //#endregion
 //#region src/blocks/procedures.ts
+/**
+* Creates a label fragment used in `defineProcedure`.
+*
+* @param text Static text shown in the custom block signature.
+* @returns A procedure fragment describing a label segment.
+* @example
+* ```ts
+* import { procedureLabel } from 'hikkaku/blocks'
+*
+* procedureLabel('Hello')
+* ```
+*/
 const procedureLabel = (text) => {
 	return {
 		type: "label",
 		text
 	};
 };
+/**
+* Creates a boolean argument fragment used in `defineProcedure`.
+*
+* @param name Argument name shown in the custom block signature.
+* @returns A procedure fragment describing a boolean input.
+* @example
+* ```ts
+* import { procedureBoolean } from 'hikkaku/blocks'
+*
+* procedureBoolean(undefined as any)
+* ```
+*/
 const procedureBoolean = (name) => {
 	return {
 		type: "boolean",
 		name
 	};
 };
+/**
+* Creates a string/number argument fragment used in `defineProcedure`.
+*
+* @param name Argument name shown in the custom block signature.
+* @returns A procedure fragment describing a string/number input.
+* @example
+* ```ts
+* import { procedureStringOrNumber } from 'hikkaku/blocks'
+*
+* procedureStringOrNumber(undefined as any)
+* ```
+*/
 const procedureStringOrNumber = (name) => {
 	return {
 		type: "stringOrNumber",
 		name
 	};
 };
+/**
+* Defines a custom procedure and returns its definition block.
+*
+* @param proclist List of procedure parts (labels and arguments) that define the procedure's signature.
+* @param stack Optional callback that composes the procedure body. Return `undefined` from this callback (implicit return is fine).
+* Argument references include `getter()` to create reporter blocks.
+* @param warp If `true`, run the procedure without screen refresh until completion.
+* @returns A procedure definition block with `reference` metadata for safe calls.
+* @example
+* ```ts
+* import { defineProcedure, procedureLabel, procedureStringOrNumber, say } from 'hikkaku/blocks'
+*
+* const greet = defineProcedure(
+*   [procedureLabel('greet'), procedureStringOrNumber('name')],
+*   ({ name }) => {
+*     say(name.getter())
+*   },
+* )
+* ```
+*/
 const defineProcedure = (proclist, stack, warp = false) => {
 	const proccode = proclist.map((proc) => {
 		switch (proc.type) {
@@ -583,33 +2459,105 @@ const defineProcedure = (proclist, stack, warp = false) => {
 			default: throw new Error("Unknown procedure proc type");
 		}
 	});
+	const prototype = block("procedures_prototype", {
+		mutation: {
+			tagName: "mutation",
+			children: [],
+			proccode,
+			argumentids: JSON.stringify(argumentids),
+			argumentnames: JSON.stringify(argumentnames),
+			argumentdefaults: JSON.stringify(argumentdefaults),
+			warp: warp.toString()
+		},
+		isShadow: true
+	});
 	const definition = block("procedures_definition", {
-		inputs: { custom_block: [1, block("procedures_prototype", {
-			mutation: {
-				tagName: "mutation",
-				children: [],
-				proccode,
-				argumentids: JSON.stringify(argumentids),
-				argumentnames: JSON.stringify(argumentnames),
-				argumentdefaults: JSON.stringify(argumentdefaults),
-				warp: warp.toString()
-			},
-			isShadow: true
-		}).id] },
+		inputs: { custom_block: [Shadow.SameBlockShadow, prototype.id] },
 		topLevel: true
 	});
 	const references = Object.fromEntries(argumentProcs.map((proc, index) => {
-		return [proc.name, {
-			isProcedureArgument: true,
-			name: proc.name,
-			type: proc.type,
-			id: argumentids[index]
-		}];
+		const argumentid = argumentids[index];
+		if (!argumentid) throw new Error("Argument ID not found");
+		let reference;
+		if (proc.type === "boolean") {
+			const boolReference = {
+				isProcedureArgument: true,
+				name: proc.name,
+				type: proc.type,
+				id: argumentid,
+				getter: () => argumentReporterBoolean(boolReference)
+			};
+			reference = boolReference;
+		} else if (proc.type === "stringOrNumber") {
+			const strNumReference = {
+				isProcedureArgument: true,
+				name: proc.name,
+				type: proc.type,
+				id: argumentid,
+				getter: () => argumentReporterStringNumber(strNumReference)
+			};
+			reference = strNumReference;
+		} else throw new Error("Unknown procedure proc type");
+		return [proc.name, reference];
 	}));
-	stack?.(references);
-	return definition;
+	const reference = {
+		type: "procedure",
+		proccode,
+		argumentids,
+		warp,
+		arguments: references
+	};
+	if (stack) attachStack(definition.id, () => {
+		stack(references);
+	});
+	return {
+		...definition,
+		reference
+	};
 };
-const callProcedure = (proccode, argumentIds, inputs, warp = false) => {
+/**
+* Calls a custom procedure.
+* Supports three call styles:
+* 1) Low-level: `callProcedure(proccode, argumentIds, inputs?, warp?)`
+* 2) Reference + array: `callProcedure(definitionOrReference, [{ reference, value }], warp?)`
+* 3) Reference + object: `callProcedure(definitionOrReference, { [argumentId]: value }, warp?)`
+*
+* @param proccodeOrReference Procedure code or the definition/reference returned by `defineProcedure`.
+* @param argumentIdsOrInputs Argument IDs for low-level calls, or argument inputs for reference-based calls.
+* @param inputsOrWarp Optional low-level inputs object or a warp override for reference-based calls.
+* @param warp Warp flag used by low-level calls.
+* @returns A `procedures_call` block.
+* @example
+* ```ts
+* import { callProcedure, defineProcedure, procedureLabel, procedureStringOrNumber } from 'hikkaku/blocks'
+*
+* const greet = defineProcedure([
+*   procedureLabel('greet'),
+*   procedureStringOrNumber('name'),
+* ])
+*
+* callProcedure(greet, [
+*   { reference: greet.reference.arguments.name, value: 'Ada' },
+* ])
+* ```
+*/
+const callProcedure = (proccodeOrReference, argumentIdsOrInputs, inputsOrWarp, warp = false) => {
+	let proccode = "";
+	let argumentIds = [];
+	let inputs = {};
+	if (typeof proccodeOrReference === "string") {
+		proccode = proccodeOrReference;
+		argumentIds = argumentIdsOrInputs;
+		inputs = (typeof inputsOrWarp === "object" ? inputsOrWarp : void 0) ?? {};
+		warp = typeof inputsOrWarp === "boolean" ? inputsOrWarp : warp;
+	} else {
+		const procedureReference = "reference" in proccodeOrReference ? proccodeOrReference.reference : proccodeOrReference;
+		proccode = procedureReference.proccode;
+		argumentIds = procedureReference.argumentids;
+		warp = typeof inputsOrWarp === "boolean" ? inputsOrWarp : procedureReference.warp;
+		if (Array.isArray(argumentIdsOrInputs) && argumentIdsOrInputs.every((input) => typeof input === "object" && input !== null && "reference" in input && "value" in input)) for (const input of argumentIdsOrInputs) inputs[input.reference.id] = input.value;
+		else if (!Array.isArray(argumentIdsOrInputs)) inputs = argumentIdsOrInputs;
+	}
 	const resolvedInputs = {};
 	for (const [key, value] of Object.entries(inputs)) resolvedInputs[key] = fromPrimitiveSource(value);
 	return block("procedures_call", {
@@ -623,9 +2571,33 @@ const callProcedure = (proccode, argumentIds, inputs, warp = false) => {
 		}
 	});
 };
+/**
+* Creates a reporter block for a string/number procedure argument.
+*
+* @param reference String/number argument reference from `defineProcedure`.
+* @returns A reporter block that reads the current argument value.
+* @example
+* ```ts
+* import { argumentReporterStringNumber } from 'hikkaku/blocks'
+*
+* argumentReporterStringNumber(reference as any)
+* ```
+*/
 const argumentReporterStringNumber = (reference) => {
 	return valueBlock("argument_reporter_string_number", { fields: { VALUE: [reference.name, null] } });
 };
+/**
+* Creates a reporter block for a boolean procedure argument.
+*
+* @param reference Boolean argument reference from `defineProcedure`.
+* @returns A reporter block that reads the current argument value.
+* @example
+* ```ts
+* import { argumentReporterBoolean } from 'hikkaku/blocks'
+*
+* argumentReporterBoolean(reference as any)
+* ```
+*/
 const argumentReporterBoolean = (reference) => {
 	return valueBlock("argument_reporter_boolean", {
 		fields: { VALUE: [reference.name, null] },
@@ -635,105 +2607,516 @@ const argumentReporterBoolean = (reference) => {
 
 //#endregion
 //#region src/blocks/sensing.ts
+/**
+* Mouse position.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getMouseX } from 'hikkaku/blocks'
+*
+* getMouseX()
+* ```
+*/
 const getMouseX = () => {
 	return valueBlock("sensing_mousex", {});
 };
+/**
+* getMouseY block helper.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getMouseY } from 'hikkaku/blocks'
+*
+* getMouseY()
+* ```
+*/
 const getMouseY = () => {
 	return valueBlock("sensing_mousey", {});
 };
+/**
+* Touching target check.
+*
+* Input: `target`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param target See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { touchingObject } from 'hikkaku/blocks'
+*
+* touchingObject('mouse-pointer')
+* ```
+*/
 const touchingObject = (target) => {
 	return valueBlock("sensing_touchingobject", { inputs: { TOUCHINGOBJECTMENU: fromPrimitiveSource(target) } });
 };
+/**
+* Touching color check.
+*
+* Input: `color`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param color See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { touchingColor } from 'hikkaku/blocks'
+*
+* touchingColor(undefined as any)
+* ```
+*/
 const touchingColor = (color) => {
 	return valueBlock("sensing_touchingcolor", { inputs: { COLOR: fromPrimitiveSource(color) } });
 };
+/**
+* Color overlap check.
+*
+* Input: `color`, `targetColor`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param color See function signature for accepted input values.
+* @param targetColor See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { colorTouchingColor } from 'hikkaku/blocks'
+*
+* colorTouchingColor(undefined as any, undefined as any)
+* ```
+*/
 const colorTouchingColor = (color, targetColor) => {
 	return valueBlock("sensing_coloristouchingcolor", { inputs: {
 		COLOR: fromPrimitiveSource(color),
 		COLOR2: fromPrimitiveSource(targetColor)
 	} });
 };
+/**
+* Distance to target.
+*
+* Input: `target`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param target See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { distanceTo } from 'hikkaku/blocks'
+*
+* distanceTo('mouse-pointer')
+* ```
+*/
 const distanceTo = (target) => {
 	return valueBlock("sensing_distanceto", { fields: { DISTANCETOMENU: [target, null] } });
 };
+/**
+* Timer value.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getTimer } from 'hikkaku/blocks'
+*
+* getTimer()
+* ```
+*/
 const getTimer = () => {
 	return valueBlock("sensing_timer", {});
 };
+/**
+* Resets timer.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { resetTimer } from 'hikkaku/blocks'
+*
+* resetTimer()
+* ```
+*/
 const resetTimer = () => {
 	return block("sensing_resettimer", {});
 };
+/**
+* Sets drag behavior.
+*
+* Input: `mode`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param mode See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setDragMode } from 'hikkaku/blocks'
+*
+* setDragMode('draggable')
+* ```
+*/
 const setDragMode = (mode) => {
 	return block("sensing_setdragmode", { fields: { DRAG_MODE: [mode, null] } });
 };
+/**
+* Mouse button state.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getMouseDown } from 'hikkaku/blocks'
+*
+* getMouseDown()
+* ```
+*/
 const getMouseDown = () => {
 	return valueBlock("sensing_mousedown", {});
 };
+/**
+* Key state.
+*
+* Input: `key`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param key See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getKeyPressed } from 'hikkaku/blocks'
+*
+* getKeyPressed('space')
+* ```
+*/
 const getKeyPressed = (key) => {
 	return valueBlock("sensing_keypressed", { inputs: { KEY_OPTION: fromPrimitiveSource(key) } });
 };
+/**
+* Current date/time value.
+*
+* Input: `menu`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param menu See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { current } from 'hikkaku/blocks'
+*
+* current('loudness')
+* ```
+*/
 const current = (menu) => {
 	return valueBlock("sensing_current", { fields: { CURRENTMENU: [menu, null] } });
 };
+/**
+* Reads target attribute.
+*
+* Input: `property`, `target`.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @param property See function signature for accepted input values.
+* @param target See function signature for accepted input values.
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getAttributeOf } from 'hikkaku/blocks'
+*
+* getAttributeOf(undefined as any, 'mouse-pointer')
+* ```
+*/
 const getAttributeOf = (property, target) => {
 	return valueBlock("sensing_of", { fields: {
 		PROPERTY: [property, null],
 		OBJECT: [target, null]
 	} });
 };
+/**
+* Days since 2000-01-01.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { daysSince2000 } from 'hikkaku/blocks'
+*
+* daysSince2000()
+* ```
+*/
 const daysSince2000 = () => {
 	return valueBlock("sensing_dayssince2000", {});
 };
+/**
+* Microphone loudness.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getLoudness } from 'hikkaku/blocks'
+*
+* getLoudness()
+* ```
+*/
 const getLoudness = () => {
 	return valueBlock("sensing_loudness", {});
 };
+/**
+* isLoud block helper.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { isLoud } from 'hikkaku/blocks'
+*
+* isLoud()
+* ```
+*/
 const isLoud = () => {
 	return valueBlock("sensing_loud", {});
 };
+/**
+* Asks user input.
+*
+* Input: `question`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param question See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { askAndWait } from 'hikkaku/blocks'
+*
+* askAndWait('Hello')
+* ```
+*/
 const askAndWait = (question) => {
 	return block("sensing_askandwait", { inputs: { QUESTION: fromPrimitiveSource(question) } });
 };
+/**
+* Returns last answer.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getAnswer } from 'hikkaku/blocks'
+*
+* getAnswer()
+* ```
+*/
 const getAnswer = () => {
 	return valueBlock("sensing_answer", {});
 };
+/**
+* Returns username.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getUsername } from 'hikkaku/blocks'
+*
+* getUsername()
+* ```
+*/
 const getUsername = () => {
 	return valueBlock("sensing_username", {});
 };
 
 //#endregion
 //#region src/blocks/sound.ts
+/**
+* Plays sound.
+*
+* Input: `sound`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param sound See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { playSound } from 'hikkaku/blocks'
+*
+* playSound('pop')
+* ```
+*/
 const playSound = (sound) => {
 	return block("sound_play", { inputs: { SOUND_MENU: fromSoundSource(sound) } });
 };
+/**
+* Plays and waits.
+*
+* Input: `sound`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param sound See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { playSoundUntilDone } from 'hikkaku/blocks'
+*
+* playSoundUntilDone('pop')
+* ```
+*/
 const playSoundUntilDone = (sound) => {
 	return block("sound_playuntildone", { inputs: { SOUND_MENU: fromSoundSource(sound) } });
 };
+/**
+* Stops all sounds.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { stopAllSounds } from 'hikkaku/blocks'
+*
+* stopAllSounds()
+* ```
+*/
 const stopAllSounds = () => {
 	return block("sound_stopallsounds", {});
 };
+/**
+* Sets sound effect.
+*
+* Input: `effect`, `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param effect See function signature for accepted input values.
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setSoundEffectTo } from 'hikkaku/blocks'
+*
+* setSoundEffectTo('pitch', 10)
+* ```
+*/
 const setSoundEffectTo = (effect, value) => {
 	return block("sound_seteffectto", {
 		inputs: { VALUE: fromPrimitiveSource(value) },
 		fields: { EFFECT: [effect, null] }
 	});
 };
+/**
+* Changes sound effect.
+*
+* Input: `effect`, `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param effect See function signature for accepted input values.
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changeSoundEffectBy } from 'hikkaku/blocks'
+*
+* changeSoundEffectBy('pitch', 10)
+* ```
+*/
 const changeSoundEffectBy = (effect, value) => {
 	return block("sound_changeeffectby", {
 		inputs: { VALUE: fromPrimitiveSource(value) },
 		fields: { EFFECT: [effect, null] }
 	});
 };
+/**
+* Clears sound effects.
+*
+* Input: none.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { clearEffects } from 'hikkaku/blocks'
+*
+* clearEffects()
+* ```
+*/
 const clearEffects = () => {
 	return block("sound_cleareffects", {});
 };
+/**
+* Sets volume.
+*
+* Input: `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { setVolumeTo } from 'hikkaku/blocks'
+*
+* setVolumeTo(10)
+* ```
+*/
 const setVolumeTo = (value) => {
 	return block("sound_setvolumeto", { inputs: { VOLUME: fromPrimitiveSource(value) } });
 };
+/**
+* Changes volume.
+*
+* Input: `value`.
+* Output: Scratch statement block definition that is appended to the current script stack.
+*
+* @param value See function signature for accepted input values.
+* @returns Scratch statement block definition that is appended to the current script stack.
+* @example
+* ```ts
+* import { changeVolumeBy } from 'hikkaku/blocks'
+*
+* changeVolumeBy(10)
+* ```
+*/
 const changeVolumeBy = (value) => {
 	return block("sound_changevolumeby", { inputs: { VOLUME: fromPrimitiveSource(value) } });
 };
+/**
+* Returns volume.
+*
+* Input: none.
+* Output: Scratch reporter block definition that can be used as an input value in other blocks.
+*
+* @returns Scratch reporter block definition that can be used as an input value in other blocks.
+* @example
+* ```ts
+* import { getVolume } from 'hikkaku/blocks'
+*
+* getVolume()
+* ```
+*/
 const getVolume = () => {
 	return valueBlock("sound_volume", {});
 };
 
 //#endregion
-export { CREATE_CLONE_MYSELF, add, addToList, allAtOnce, and, argumentReporterBoolean, argumentReporterStringNumber, askAndWait, broadcast, broadcastAndWait, callProcedure, changeLooksEffectBy, changePenColorParamBy, changePenHueBy, changePenShadeBy, changePenSizeBy, changeSizeBy, changeSoundEffectBy, changeVariableBy, changeVolumeBy, changeXBy, changeYBy, clear, clearCounter, clearEffects, clearGraphicEffects, colorTouchingColor, contains, controlStartAsClone, createClone, current, daysSince2000, defineProcedure, deleteAllOfList, deleteOfList, deleteThisClone, distanceTo, divide, equals, eraseAll, forEach, forever, getAnswer, getAttributeOf, getBackdropNumberName, getCostumeNumberName, getCounter, getDirection, getItemNumOfList, getItemOfList, getKeyPressed, getListContents, getLoudness, getMouseDown, getMouseX, getMouseY, getSize, getTimer, getUsername, getVariable, getVolume, getX, getY, glide, glideTo, goForwardBackwardLayers, goTo, goToFrontBack, gotoXY, gt, hide, hideList, hideVariable, ifElse, ifOnEdgeBounce, ifThen, incrCounter, insertAtList, isLoud, join, length, lengthOfList, letterOf, listContainsItem, lt, mathop, mod, moveSteps, multiply, nextBackdrop, nextCostume, not, or, penDown, penUp, playSound, playSoundUntilDone, pointInDirection, pointTowards, procedureBoolean, procedureLabel, procedureStringOrNumber, random, repeat, repeatUntil, repeatWhile, replaceItemOfList, resetTimer, round, say, sayForSecs, setDragMode, setLooksEffectTo, setPenColorParamTo, setPenColorTo, setPenColorToColor, setPenHueToNumber, setPenShadeToNumber, setPenSizeTo, setRotationStyle, setSizeTo, setSoundEffectTo, setVariableTo, setVolumeTo, setX, setY, show, showList, showVariable, stamp, stop, stopAllSounds, subtract, switchBackdropTo, switchBackdropToAndWait, switchCostumeTo, think, thinkForSecs, touchingColor, touchingObject, turnLeft, turnRight, wait, waitUntil, whenBackdropSwitchesTo, whenBroadcastReceived, whenFlagClicked, whenGreaterThan, whenKeyPressed, whenStageClicked, whenThisSpriteClicked, whenTouchingObject };
+export { CREATE_CLONE_MYSELF, add, addToList, allAtOnce, and, argumentReporterBoolean, argumentReporterStringNumber, askAndWait, broadcast, broadcastAndWait, callProcedure, changeLooksEffectBy, changePenColorParamBy, changePenHueBy, changePenShadeBy, changePenSizeBy, changeSizeBy, changeSoundEffectBy, changeVariableBy, changeVolumeBy, changeXBy, changeYBy, clear, clearCounter, clearEffects, clearGraphicEffects, colorTouchingColor, contains, controlStartAsClone, createClone, current, daysSince2000, defineProcedure, deleteAllOfList, deleteOfList, deleteThisClone, distanceTo, divide, equals, eraseAll, forEach, forever, getAnswer, getAttributeOf, getBackdropNumberName, getCostumeNumberName, getCounter, getDirection, getItemNumOfList, getItemOfList, getKeyPressed, getListContents, getLoudness, getMouseDown, getMouseX, getMouseY, getSize, getTimer, getUsername, getVariable, getVolume, getX, getY, glide, glideTo, goForwardBackwardLayers, goTo, goToFrontBack, gotoXY, gt, hide, hideList, hideVariable, ifElse, ifOnEdgeBounce, ifThen, incrCounter, insertAtList, isLoud, join, length, lengthOfList, letterOf, listContainsItem, lt, match, mathop, mod, moveSteps, multiply, nextBackdrop, nextCostume, not, or, penDown, penUp, playSound, playSoundUntilDone, pointInDirection, pointTowards, procedureBoolean, procedureLabel, procedureStringOrNumber, random, repeat, repeatUntil, repeatWhile, replaceItemOfList, resetTimer, round, say, sayForSecs, setDragMode, setLooksEffectTo, setPenColorParamTo, setPenColorTo, setPenColorToColor, setPenHueToNumber, setPenShadeToNumber, setPenSizeTo, setRotationStyle, setSizeTo, setSoundEffectTo, setVariableTo, setVolumeTo, setX, setY, show, showList, showVariable, stamp, stop, stopAllSounds, subtract, switchBackdropTo, switchBackdropToAndWait, switchCostumeTo, think, thinkForSecs, touchingColor, touchingObject, turnLeft, turnRight, wait, waitUntil, whenBackdropSwitchesTo, whenBroadcastReceived, whenFlagClicked, whenGreaterThan, whenKeyPressed, whenStageClicked, whenThisSpriteClicked, whenTouchingObject };