hikkaku 0.1.14 → 0.2.0

package/blocks/index.d.mts

@@ -1,56 +1,766 @@
-import { _ as PrimitiveSource, h as ListReference, m as HikkakuBlock, p as CostumeSource, x as VariableReference, y as SoundSource } from "../project-BSiPw18H.mjs";
+import { S as PrimitiveSource, _ as HikkakuBlock, k as VariableReference, m as CostumeSource, w as SoundSource, y as ListReference } from "../project-Ca9rsVT3.mjs";
 
 //#region src/blocks/control.d.ts
 type StopOption = 'all' | 'this script' | 'other scripts in sprite' | 'other scripts in stage';
+/**
+ * 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, () => {})
+ * ```
+ */
 declare const repeat: (times: PrimitiveSource<number>, handler: () => void) => HikkakuBlock;
+/**
+ * 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, () => {})
+ * ```
+ */
 declare const repeatUntil: (condition: PrimitiveSource<boolean>, handler: () => void) => HikkakuBlock;
+/**
+ * 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, () => {})
+ * ```
+ */
 declare const repeatWhile: (condition: PrimitiveSource<boolean>, handler: () => void) => HikkakuBlock;
+/**
+ * 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, () => {})
+ * ```
+ */
 declare const forEach: (variable: VariableReference, value: PrimitiveSource<number>, handler: () => void) => HikkakuBlock;
+/**
+ * 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(() => {})
+ * ```
+ */
 declare const forever: (handler: () => void) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const wait: (seconds: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const waitUntil: (condition: PrimitiveSource<boolean>) => HikkakuBlock;
+/**
+ * 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, () => {})
+ * ```
+ */
 declare const ifThen: (condition: PrimitiveSource<boolean>, handler: () => void) => HikkakuBlock;
+/**
+ * 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, () => {}, () => {})
+ * ```
+ */
 declare const ifElse: (condition: PrimitiveSource<boolean>, thenHandler: () => void, elseHandler: () => void) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
+declare const match: (...branches: [condition: PrimitiveSource<boolean>, handler: () => void][] | [...[condition: PrimitiveSource<boolean>, handler: () => void][], () => void]) => void;
+/**
+ * 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')
+ * ```
+ */
 declare const stop: (option: StopOption) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare 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')
+ * ```
+ */
 declare const createClone: (target: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const deleteThisClone: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getCounter: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const incrCounter: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const clearCounter: () => HikkakuBlock;
+/**
+ * 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(() => {})
+ * ```
+ */
 declare const controlStartAsClone: (stack?: () => void) => HikkakuBlock;
+/**
+ * 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(() => {})
+ * ```
+ */
 declare const allAtOnce: (handler: () => void) => HikkakuBlock;
 //#endregion
 //#region src/blocks/data.d.ts
 type ListIndex = PrimitiveSource<number | string>;
+/**
+ * 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)
+ * ```
+ */
 declare const getVariable: (variable: VariableReference) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setVariableTo: (variable: VariableReference, value: PrimitiveSource<number | string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changeVariableBy: (variable: VariableReference, value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const showVariable: (variable: VariableReference) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const hideVariable: (variable: VariableReference) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const getListContents: (list: ListReference) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const addToList: (list: ListReference, item: PrimitiveSource<string | number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const deleteOfList: (list: ListReference, index: ListIndex) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const deleteAllOfList: (list: ListReference) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const insertAtList: (list: ListReference, index: ListIndex, item: PrimitiveSource<string | number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const replaceItemOfList: (list: ListReference, index: ListIndex, item: PrimitiveSource<string | number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const getItemOfList: (list: ListReference, index: ListIndex) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const getItemNumOfList: (list: ListReference, item: PrimitiveSource<string | number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const lengthOfList: (list: ListReference) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const listContainsItem: (list: ListReference, item: PrimitiveSource<string | number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const showList: (list: ListReference) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const hideList: (list: ListReference) => HikkakuBlock;
 //#endregion
 //#region src/blocks/events.d.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(() => {})
+ * ```
+ */
 declare const whenFlagClicked: (stack?: () => void) => HikkakuBlock;
+/**
+ * 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', () => {})
+ * ```
+ */
 declare const whenKeyPressed: (key: string, stack?: () => void) => HikkakuBlock;
+/**
+ * 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(() => {})
+ * ```
+ */
 declare const whenThisSpriteClicked: (stack?: () => void) => HikkakuBlock;
+/**
+ * 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(() => {})
+ * ```
+ */
 declare const whenStageClicked: (stack?: () => void) => HikkakuBlock;
+/**
+ * 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', () => {})
+ * ```
+ */
 declare const whenBackdropSwitchesTo: (backdrop: string, stack?: () => void) => HikkakuBlock;
+/**
+ * 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', () => {})
+ * ```
+ */
 declare const whenBroadcastReceived: (broadcast: string, stack?: () => void) => HikkakuBlock;
+/**
+ * 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', () => {})
+ * ```
+ */
 declare const whenTouchingObject: (target: string, stack?: () => void) => HikkakuBlock;
+/**
+ * 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, () => {})
+ * ```
+ */
 declare const whenGreaterThan: (menu: string, value: PrimitiveSource<number>, stack?: () => void) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const broadcast: (message: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const broadcastAndWait: (message: PrimitiveSource<string>) => HikkakuBlock;
 //#endregion
 //#region src/blocks/looks.d.ts
@@ -58,85 +768,1174 @@ type LookEffect = 'color' | 'fisheye' | 'whirl' | 'pixelate' | 'mosaic' | 'brigh
 type FrontBack = 'front' | 'back';
 type ForwardBackward = 'forward' | 'backward';
 type NumberName = 'number' | 'name';
+/**
+ * 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')
+ * ```
+ */
 declare const say: (message: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const sayForSecs: (message: PrimitiveSource<string>, seconds: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const think: (message: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const thinkForSecs: (message: PrimitiveSource<string>, seconds: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const show: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const hide: () => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const switchCostumeTo: (costume: CostumeSource) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const nextCostume: () => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const switchBackdropTo: (backdrop: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const switchBackdropToAndWait: (backdrop: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const nextBackdrop: () => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changeLooksEffectBy: (effect: LookEffect, value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setLooksEffectTo: (effect: LookEffect, value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const clearGraphicEffects: () => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changeSizeBy: (value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setSizeTo: (value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const goToFrontBack: (position: FrontBack) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const goForwardBackwardLayers: (direction: ForwardBackward, layers: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getSize: () => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const getCostumeNumberName: (value: NumberName) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const getBackdropNumberName: (value: NumberName) => HikkakuBlock;
 //#endregion
 //#region src/blocks/motion.d.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)
+ * ```
+ */
 declare const moveSteps: (steps: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const gotoXY: (x: PrimitiveSource<number>, y: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changeXBy: (dx: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changeYBy: (dy: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setX: (x: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setY: (y: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const goTo: (target: string) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const turnRight: (degrees: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const turnLeft: (degrees: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const pointInDirection: (direction: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const pointTowards: (target: string) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const glide: (seconds: PrimitiveSource<number>, x: PrimitiveSource<number>, y: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const glideTo: (seconds: PrimitiveSource<number>, target: string) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const ifOnEdgeBounce: () => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const setRotationStyle: (style: "all around" | "left-right" | "don't rotate") => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getX: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getY: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getDirection: () => HikkakuBlock;
 //#endregion
 //#region src/blocks/operator.d.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)
+ * ```
+ */
 declare const add: (a: PrimitiveSource<number>, b: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const subtract: (a: PrimitiveSource<number>, b: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const multiply: (a: PrimitiveSource<number>, b: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const divide: (a: PrimitiveSource<number>, b: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const lt: (a: PrimitiveSource<number | string>, b: PrimitiveSource<number | string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const equals: (a: PrimitiveSource<number | string>, b: PrimitiveSource<number | string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const gt: (a: PrimitiveSource<number | string>, b: PrimitiveSource<number | string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const and: (a: PrimitiveSource<boolean>, b: PrimitiveSource<boolean>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const or: (a: PrimitiveSource<boolean>, b: PrimitiveSource<boolean>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const not: (operand: PrimitiveSource<boolean>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const random: (from: PrimitiveSource<number>, to: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const join: (a: PrimitiveSource<string>, b: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const letterOf: (letter: PrimitiveSource<number>, text: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const length: (text: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const contains: (text: PrimitiveSource<string>, substring: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const mod: (a: PrimitiveSource<number>, b: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const round: (value: PrimitiveSource<number>) => HikkakuBlock;
 type MathOpOperator = 'abs' | 'floor' | 'ceiling' | 'sqrt' | 'sin' | 'cos' | 'tan' | 'asin' | 'acos' | 'atan' | 'ln' | 'log' | 'e ^' | '10 ^';
+/**
+ * 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)
+ * ```
+ */
 declare const mathop: (operator: MathOpOperator, value: PrimitiveSource<number>) => HikkakuBlock;
 //#endregion
 //#region src/blocks/pen.d.ts
 type PenColorParam = 'color' | 'saturation' | 'brightness' | 'transparency';
+/**
+ * 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()
+ * ```
+ */
 declare const eraseAll: () => HikkakuBlock;
+/**
+ * Alias for {@link eraseAll}.
+ *
+ * Input: none.
+ * Output: Same Scratch statement block definition as {@link eraseAll}.
+ *
+ * @example
+ * ```ts
+ * import { clear } from 'hikkaku/blocks'
+ *
+ * clear()
+ * ```
+ */
 declare const clear: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const stamp: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const penDown: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const penUp: () => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setPenColorTo: (color: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const setPenColorToColor: (color: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changePenColorParamBy: (param: PrimitiveSource<PenColorParam>, value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setPenColorParamTo: (param: PrimitiveSource<PenColorParam>, value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changePenSizeBy: (size: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setPenSizeTo: (size: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setPenShadeToNumber: (shade: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changePenShadeBy: (shade: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setPenHueToNumber: (hue: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changePenHueBy: (hue: PrimitiveSource<number>) => HikkakuBlock;
 //#endregion
 //#region src/blocks/procedures.d.ts
@@ -154,8 +1953,44 @@ interface ProcedureProcStringOrNumber<T = string> {
   name: T;
 }
 type ProcedureProc = ProcedureProcLabel | ProcedureProcBoolean | ProcedureProcStringOrNumber;
+/**
+ * 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')
+ * ```
+ */
 declare const procedureLabel: (text: string) => ProcedureProcLabel;
+/**
+ * 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)
+ * ```
+ */
 declare const procedureBoolean: <T extends string>(name: T) => ProcedureProcBoolean<T>;
+/**
+ * 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)
+ * ```
+ */
 declare const procedureStringOrNumber: <T extends string>(name: T) => ProcedureProcStringOrNumber<T>;
 type OnlyArgProc<T> = T extends {
   type: 'label';
@@ -165,6 +2000,10 @@ interface ProcedureReferenceBase {
   name: string;
   type: 'boolean' | 'stringOrNumber';
   id: string;
+  /**
+   * Creates a reporter block for this argument reference.
+   */
+  getter(): HikkakuBlock;
 }
 interface ProcedureBooleanReference extends ProcedureReferenceBase {
   type: 'boolean';
@@ -173,53 +2012,548 @@ interface ProcedureStringOrNumberReference extends ProcedureReferenceBase {
   type: 'stringOrNumber';
 }
 type ProcedureReference = ProcedureBooleanReference | ProcedureStringOrNumberReference;
+interface ProcedureDefinitionReference<T extends ProcedureProc[] = ProcedureProc[]> {
+  type: 'procedure';
+  proccode: string;
+  warp: boolean;
+  argumentids: string[];
+  arguments: ReferencesByProcs<T>;
+}
+type ProcedureCallInput = {
+  reference: ProcedureReference;
+  value: PrimitiveSource<string | number | boolean>;
+};
+interface ProcedureDefinition<T extends ProcedureProc[] = ProcedureProc[]> extends HikkakuBlock {
+  reference: ProcedureDefinitionReference<T>;
+}
 type ReferencesByProcs<T extends ProcedureProc[]> = { [K in OnlyArgProc<T[number]>['name']]: OnlyArgProc<T[number]> extends {
   type: infer U;
 } ? U extends 'boolean' ? ProcedureBooleanReference : U extends 'stringOrNumber' ? ProcedureStringOrNumberReference : never : never };
-declare const defineProcedure: <T extends ProcedureProc[]>(proclist: T, stack?: (references: ReferencesByProcs<T>) => void,
+/**
+ * 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())
+ *   },
+ * )
+ * ```
+ */
+declare const defineProcedure: <T extends ProcedureProc[]>(proclist: T, stack?: (references: ReferencesByProcs<T>) => undefined,
 /**
  * If true, the procedure will run without screen refresh until it completes.
  * This can make the procedure run faster, but the screen will not update until the procedure is done.
  */
 
-warp?: boolean) => HikkakuBlock;
-declare const callProcedure: (proccode: string, argumentIds: string[], inputs: Record<string, PrimitiveSource<string | number | boolean>>, warp?: boolean) => HikkakuBlock;
+warp?: boolean) => ProcedureDefinition<T>;
+/**
+ * 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' },
+ * ])
+ * ```
+ */
+declare const callProcedure: (proccodeOrReference: string | ProcedureDefinitionReference | ProcedureDefinition, argumentIdsOrInputs: string[] | ProcedureCallInput[] | Record<string, PrimitiveSource<string | number | boolean>>, inputsOrWarp?: Record<string, PrimitiveSource<string | number | boolean>> | boolean, warp?: boolean) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const argumentReporterStringNumber: (reference: ProcedureStringOrNumberReference) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const argumentReporterBoolean: (reference: ProcedureBooleanReference) => HikkakuBlock;
 //#endregion
 //#region src/blocks/sensing.d.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()
+ * ```
+ */
 declare const getMouseX: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getMouseY: () => HikkakuBlock;
 type CurrentMenu = 'year' | 'month' | 'date' | 'dayofweek' | 'hour' | 'minute' | 'second';
 type DragMode = 'draggable' | 'not draggable';
+/**
+ * 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')
+ * ```
+ */
 declare const touchingObject: (target: string) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const touchingColor: (color: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const colorTouchingColor: (color: PrimitiveSource<string>, targetColor: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const distanceTo: (target: string) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getTimer: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const resetTimer: () => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const setDragMode: (mode: DragMode) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getMouseDown: () => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const getKeyPressed: (key: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const current: (menu: CurrentMenu) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const getAttributeOf: (property: string, target: string) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const daysSince2000: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getLoudness: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const isLoud: () => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const askAndWait: (question: PrimitiveSource<string>) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getAnswer: () => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getUsername: () => HikkakuBlock;
 //#endregion
 //#region src/blocks/sound.d.ts
 type SoundEffect = 'pitch' | 'pan';
+/**
+ * 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')
+ * ```
+ */
 declare const playSound: (sound: SoundSource) => HikkakuBlock;
+/**
+ * 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')
+ * ```
+ */
 declare const playSoundUntilDone: (sound: SoundSource) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const stopAllSounds: () => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setSoundEffectTo: (effect: SoundEffect, value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changeSoundEffectBy: (effect: SoundEffect, value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const clearEffects: () => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const setVolumeTo: (value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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)
+ * ```
+ */
 declare const changeVolumeBy: (value: PrimitiveSource<number>) => HikkakuBlock;
+/**
+ * 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()
+ * ```
+ */
 declare const getVolume: () => HikkakuBlock;
 //#endregion
-export { CREATE_CLONE_MYSELF, CurrentMenu, DragMode, ForwardBackward, FrontBack, ListIndex, LookEffect, MathOpOperator, NumberName, PenColorParam, ProcedureArgumentDefault, ProcedureBooleanReference, ProcedureProc, ProcedureProcBoolean, ProcedureProcLabel, ProcedureProcStringOrNumber, ProcedureReference, ProcedureReferenceBase, ProcedureStringOrNumberReference, SoundEffect, StopOption, 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, CurrentMenu, DragMode, ForwardBackward, FrontBack, ListIndex, LookEffect, MathOpOperator, NumberName, PenColorParam, ProcedureArgumentDefault, ProcedureBooleanReference, ProcedureCallInput, ProcedureDefinition, ProcedureDefinitionReference, ProcedureProc, ProcedureProcBoolean, ProcedureProcLabel, ProcedureProcStringOrNumber, ProcedureReference, ProcedureReferenceBase, ProcedureStringOrNumberReference, SoundEffect, StopOption, 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 };