hikkaku 0.1.14 → 0.2.0

package/client/index.mjs

@@ -1,3 +1,5 @@
+import { zipSync } from "fflate";
+
 //#region src/client/fiber.ts
 const findDOMAppRoot = () => {
 	const probably = [document.getElementById("app"), document.querySelector("[class^=index_app]")];
@@ -59,7 +61,8 @@ import.meta.hot?.on("hikkaku:project", async (project) => {
 		isFirstLoad = false;
 	}
 	console.log("Received updated project:", project);
-	await state.vm.loadProject(project).catch(console.error);
+	const projectSB3 = zipSync({ "project.json": new TextEncoder().encode(JSON.stringify(project)) });
+	await state.vm.loadProject(projectSB3).catch(console.error);
 	console.log("Project loaded.");
 });
 

package/{composer-JWWbnKkh.mjs → composer-BudVTTBs.mjs}

@@ -1,9 +1,37 @@
+import { InputType, Shadow } from "sb3-types/enum";
+
+//#region src/core/sb3-enum.ts
+const toNumericEnum = (value, fallback) => {
+	if (typeof value === "number" && Number.isInteger(value)) return value;
+	if (typeof value === "string") {
+		const normalized = value.trim();
+		if (normalized.length === 0) return fallback;
+		const parsed = Number(normalized);
+		if (Number.isInteger(parsed)) return parsed;
+	}
+	return fallback;
+};
+const shadow = Shadow;
+const inputType = InputType;
+const Shadow$1 = {
+	SameBlockShadow: toNumericEnum(shadow.SameBlockShadow ?? shadow.UnObscured, 1),
+	NoShadow: toNumericEnum(shadow.NoShadow ?? shadow.No, 2),
+	DiffBlockShadow: toNumericEnum(shadow.DiffBlockShadow ?? shadow.Obscured, 3)
+};
+const InputType$1 = {
+	Number: toNumericEnum(inputType.Number, 4),
+	PositiveInteger: toNumericEnum(inputType.PositiveInteger ?? inputType.PossiveInteger, 6),
+	String: toNumericEnum(inputType.String, 10),
+	Broadcast: toNumericEnum(inputType.Broadcast, 11)
+};
+
+//#endregion
 //#region src/core/block-helper.ts
 const fromPrimitiveSource = (source) => {
-	if (typeof source === "number") return [1, [4, source]];
-	if (typeof source === "boolean") return [1, [6, source ? 1 : 0]];
-	if (typeof source === "string") return [1, [10, source]];
-	return [1, source.id];
+	if (typeof source === "number") return [Shadow$1.SameBlockShadow, [InputType$1.Number, source]];
+	if (typeof source === "boolean") return [Shadow$1.SameBlockShadow, [InputType$1.PositiveInteger, source ? 1 : 0]];
+	if (typeof source === "string") return [Shadow$1.SameBlockShadow, [InputType$1.String, source]];
+	return [Shadow$1.SameBlockShadow, source.id];
 };
 const fromCostumeSource = (source) => {
 	if (typeof source === "object" && source !== null && "type" in source && source.type === "costume") return fromPrimitiveSource(source.name);
@@ -88,8 +116,35 @@ const catchNewBlocks = (handler, catched) => {
 	ctx.adder = (id, block) => {
 		catched(id, block);
 	};
-	handler();
-	ctx.adder = oldAdder;
+	try {
+		handler();
+	} finally {
+		ctx.adder = oldAdder;
+	}
+};
+const firstExecutableBlockId = (blocks) => {
+	const ctx = getRootContext();
+	for (const block of blocks) {
+		if (!block || ctx.usedAsValueSet.has(block)) continue;
+		const blockId = ctx.blockToId.get(block);
+		if (blockId) return blockId;
+	}
+	return null;
+};
+const layoutTopLevelBlocks = (blocks) => {
+	const ctx = getRootContext();
+	const seen = /* @__PURE__ */ new Set();
+	let index = 0;
+	for (const block of blocks) {
+		if (!block || !block.topLevel) continue;
+		const blockId = ctx.blockToId.get(block);
+		if (!blockId || seen.has(blockId)) continue;
+		seen.add(blockId);
+		if (block.x !== 0 || block.y !== 0) continue;
+		block.x = 64;
+		block.y = 72 + index * 260;
+		index++;
+	}
 };
 const substack = (handler) => {
 	const ctx = getRootContext();
@@ -99,12 +154,27 @@ const substack = (handler) => {
 		blocks.push(block);
 	});
 	applyNextAndParent(blocks);
-	for (const block of blocks) {
-		if (!block || ctx.usedAsValueSet.has(block)) continue;
-		const blockId = ctx.blockToId.get(block);
-		if (blockId) return blockId;
+	return firstExecutableBlockId(blocks);
+};
+const attachStack = (parentId, handler) => {
+	if (!handler) return null;
+	const ctx = getRootContext();
+	const blocks = [];
+	catchNewBlocks(handler, (id, block) => {
+		ctx.blocks[id] = block;
+		blocks.push(block);
+	});
+	const stackBlocks = blocks.filter((block) => !block.topLevel);
+	applyNextAndParent(stackBlocks);
+	const firstBlockId = firstExecutableBlockId(stackBlocks);
+	if (!firstBlockId) return null;
+	const parentBlock = ctx.blocks[parentId];
+	const firstBlock = ctx.blocks[firstBlockId];
+	if (parentBlock && firstBlock) {
+		parentBlock.next = firstBlockId;
+		firstBlock.parent = parentId;
 	}
-	return null;
+	return firstBlockId;
 };
 const createBlocks = (handler) => {
 	const blocks = {};
@@ -120,6 +190,7 @@ const createBlocks = (handler) => {
 		blocksForAddingNext.push(block);
 	});
 	applyNextAndParent(blocksForAddingNext);
+	layoutTopLevelBlocks(blocksForAddingNext);
 	const unconnectedValueBlocks = [];
 	for (const [blockId, block] of Object.entries(blocks)) if (rootContext.valueBlockSet.has(block) && !rootContext.usedAsValueSet.has(block)) unconnectedValueBlocks.push({
 		id: blockId,
@@ -135,4 +206,4 @@ const createBlocks = (handler) => {
 };
 
 //#endregion
-export { fromCostumeSource as a, valueBlock as i, createBlocks as n, fromPrimitiveSource as o, substack as r, fromSoundSource as s, block as t };
+export { valueBlock as a, fromSoundSource as c, substack as i, InputType$1 as l, block as n, fromCostumeSource as o, createBlocks as r, fromPrimitiveSource as s, attachStack as t, Shadow$1 as u };

package/index.d.mts

@@ -1,2 +1,2 @@
-import { _ as PrimitiveSource, a as block, b as VariableBase, c as valueBlock, d as fromSoundSource, f as CostumeReference, g as PrimitiveAvailableOnScratch, h as ListReference, i as Handler, l as fromCostumeSource, m as HikkakuBlock, n as Target, o as createBlocks, p as CostumeSource, r as BlockInit, s as substack, t as Project, u as fromPrimitiveSource, v as SoundReference, x as VariableReference, y as SoundSource } from "./project-BSiPw18H.mjs";
-export { BlockInit, CostumeReference, CostumeSource, Handler, HikkakuBlock, ListReference, PrimitiveAvailableOnScratch, PrimitiveSource, Project, SoundReference, SoundSource, Target, VariableBase, VariableReference, block, createBlocks, fromCostumeSource, fromPrimitiveSource, fromSoundSource, substack, valueBlock };
+import { C as SoundReference, D as VariableMonitorMode, E as VariableDefinition, O as VariableMonitorOptions, S as PrimitiveSource, T as VariableBase, _ as HikkakuBlock, a as attachStack, b as MonitorPosition, c as substack, d as fromPrimitiveSource, f as fromSoundSource, g as CreateVariableOptions, h as CreateListOptions, i as Handler, k as VariableReference, l as valueBlock, m as CostumeSource, n as Target, o as block, p as CostumeReference, r as BlockInit, s as createBlocks, t as Project, u as fromCostumeSource, v as ListMonitorOptions, w as SoundSource, x as PrimitiveAvailableOnScratch, y as ListReference } from "./project-Ca9rsVT3.mjs";
+export { BlockInit, CostumeReference, CostumeSource, CreateListOptions, CreateVariableOptions, Handler, HikkakuBlock, ListMonitorOptions, ListReference, MonitorPosition, PrimitiveAvailableOnScratch, PrimitiveSource, Project, SoundReference, SoundSource, Target, VariableBase, VariableDefinition, VariableMonitorMode, VariableMonitorOptions, VariableReference, attachStack, block, createBlocks, fromCostumeSource, fromPrimitiveSource, fromSoundSource, substack, valueBlock };

package/index.mjs

@@ -1,5 +1,54 @@
-import { a as fromCostumeSource, i as valueBlock, n as createBlocks, 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, n as block, o as fromCostumeSource, r as createBlocks, s as fromPrimitiveSource, t as attachStack } from "./composer-BudVTTBs.mjs";
 
+//#region src/core/monitors.ts
+const createVariableMonitor = (id, name, defaultValue, spriteName, options) => {
+	const sliderMin = options.sliderMin ?? 0;
+	const sliderMax = options.sliderMax ?? 100;
+	return {
+		id,
+		mode: options.mode ?? "default",
+		opcode: "data_variable",
+		params: { VARIABLE: name },
+		spriteName,
+		value: defaultValue,
+		sliderMin: Math.min(sliderMin, sliderMax),
+		sliderMax: Math.max(sliderMin, sliderMax),
+		isDiscrete: options.isDiscrete ?? true,
+		x: options.x ?? null,
+		y: options.y ?? null,
+		width: 0,
+		height: 0,
+		visible: options.visible ?? true
+	};
+};
+const createListMonitor = (id, name, defaultValue, spriteName, options) => {
+	return {
+		id,
+		mode: "list",
+		opcode: "data_listcontents",
+		params: { LIST: name },
+		spriteName,
+		value: [...defaultValue],
+		x: options.x ?? null,
+		y: options.y ?? null,
+		width: options.width ?? 0,
+		height: options.height ?? 0,
+		visible: options.visible ?? true
+	};
+};
+const cloneMonitor = (monitor) => {
+	if (monitor.mode === "list") return {
+		...monitor,
+		params: { ...monitor.params },
+		value: [...monitor.value]
+	};
+	return {
+		...monitor,
+		params: { ...monitor.params }
+	};
+};
+
+//#endregion
 //#region src/core/project.ts
 let nextAssetId = 0;
 const createAssetId = () => `asset-${(++nextAssetId).toString(16)}`;
@@ -34,6 +83,7 @@ var Target = class {
 	#blocks = {};
 	#variables = {};
 	#lists = {};
+	#monitors = [];
 	#costumes = [];
 	#sounds = [];
 	constructor(isStage, name) {
@@ -49,22 +99,30 @@ var Target = class {
 			...blocks
 		};
 	}
-	createVariable(name, defaultValue = 0, isCloudVariable) {
+	createVariable(name, defaultValue = 0, isCloudVariableOrOptions) {
+		const options = typeof isCloudVariableOrOptions === "boolean" ? { isCloudVariable: isCloudVariableOrOptions } : isCloudVariableOrOptions;
 		const id = createAssetId();
-		this.#variables[id] = isCloudVariable ? [
+		this.#variables[id] = options?.isCloudVariable ? [
 			name,
 			defaultValue,
 			true
 		] : [name, defaultValue];
+		if (options?.monitor) this.#monitors.push(createVariableMonitor(id, name, defaultValue, this.isStage ? null : this.name, options.monitor));
 		return {
 			id,
 			name,
-			type: "variable"
+			type: "variable",
+			get: () => valueBlock("data_variable", { fields: { VARIABLE: [name, id] } }),
+			set: (value) => block("data_setvariableto", {
+				inputs: { VALUE: fromPrimitiveSource(value) },
+				fields: { VARIABLE: [name, id] }
+			})
 		};
 	}
-	createList(name, defaultValue = []) {
+	createList(name, defaultValue = [], options) {
 		const id = createAssetId();
 		this.#lists[id] = [name, defaultValue];
+		if (options?.monitor) this.#monitors.push(createListMonitor(id, name, defaultValue, this.isStage ? null : this.name, options.monitor));
 		return {
 			id,
 			name,
@@ -85,6 +143,9 @@ var Target = class {
 			type: "sound"
 		};
 	}
+	get monitors() {
+		return this.#monitors;
+	}
 	toScratch() {
 		const costumes = this.#costumes.length > 0 ? this.#costumes : [{
 			name: this.name,
@@ -98,7 +159,8 @@ var Target = class {
 			lists: this.#lists,
 			sounds: this.#sounds,
 			currentCostume: this.currentCostume,
-			costumes
+			costumes,
+			comments: {}
 		};
 		if (this.isStage) return {
 			...target,
@@ -128,18 +190,17 @@ var Project = class {
 	}
 	toScratch() {
 		const targets = this.#targets.map((target) => target.toScratch());
-		const extensions = collectExtensions(targets);
-		const project = {
+		return {
 			targets,
+			monitors: this.#targets.flatMap((target) => target.monitors.map((monitor) => cloneMonitor(monitor))),
+			extensions: collectExtensions(targets),
 			meta: {
 				semver: "3.0.0",
-				agent: `Hikkaku | ${globalThis.navigator ? navigator.userAgent : "unknown"}`
+				agent: `Hikkaku | ${typeof navigator !== "undefined" ? navigator.userAgent : "unknown"}`
 			}
 		};
-		if (extensions.length > 0) project.extensions = extensions;
-		return project;
 	}
 };
 
 //#endregion
-export { Project, Target, block, createBlocks, fromCostumeSource, fromPrimitiveSource, fromSoundSource, substack, valueBlock };
+export { Project, Target, attachStack, block, createBlocks, fromCostumeSource, fromPrimitiveSource, fromSoundSource, substack, valueBlock };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hikkaku",
-  "version": "0.1.14",
+  "version": "0.2.0",
   "type": "module",
   "private": false,
   "exports": {
@@ -30,15 +30,18 @@
     "typecheck": "tsgo"
   },
   "devDependencies": {
+    "@turbowarp/packager": "^3.11.0",
     "@types/bun": "latest",
-    "tsdown": "^0.20.0-beta.4",
-    "@typescript/native-preview": "^7.0.0-dev.20260127.1"
+    "@typescript/native-preview": "^7.0.0-dev.20260127.1",
+    "rolldown": "1.0.0-beta.60",
+    "tsdown": "^0.20.0-beta.4"
   },
   "peerDependencies": {
     "typescript": "^5"
   },
   "dependencies": {
-    "sb3-types": "0.1.10",
+    "fflate": "^0.8.2",
+    "sb3-types": "^0.1.16",
     "vite": "8.0.0-beta.8"
   },
   "repository": {

package/project-Ca9rsVT3.d.mts

@@ -0,0 +1,139 @@
+import * as sb3 from "sb3-types";
+
+//#region src/core/types.d.ts
+type PrimitiveAvailableOnScratch = number | boolean | string;
+type PrimitiveSource<T extends PrimitiveAvailableOnScratch> = T | HikkakuBlock;
+interface VariableBase {
+  id: string;
+  name: string;
+}
+interface MonitorPosition {
+  x?: number | null;
+  y?: number | null;
+}
+type VariableMonitorMode = 'default' | 'large' | 'slider';
+interface VariableMonitorOptions extends MonitorPosition {
+  visible?: boolean;
+  mode?: VariableMonitorMode;
+  sliderMin?: number;
+  sliderMax?: number;
+  isDiscrete?: boolean;
+}
+interface ListMonitorOptions extends MonitorPosition {
+  visible?: boolean;
+  width?: number;
+  height?: number;
+}
+interface CreateVariableOptions {
+  isCloudVariable?: boolean;
+  monitor?: VariableMonitorOptions;
+}
+interface CreateListOptions {
+  monitor?: ListMonitorOptions;
+}
+interface VariableReference extends VariableBase {
+  type: 'variable';
+}
+interface VariableDefinition extends VariableReference {
+  get(): HikkakuBlock;
+  set(value: PrimitiveSource<number | string>): HikkakuBlock;
+}
+interface ListReference extends VariableBase {
+  type: 'list';
+}
+interface CostumeReference {
+  name: string;
+  type: 'costume';
+}
+type CostumeSource = PrimitiveSource<string> | CostumeReference;
+interface SoundReference {
+  name: string;
+  type: 'sound';
+}
+type SoundSource = PrimitiveSource<string> | SoundReference;
+interface HikkakuBlock {
+  isBlock: true;
+  id: string;
+}
+//#endregion
+//#region src/core/block-helper.d.ts
+declare const fromPrimitiveSource: <T extends PrimitiveAvailableOnScratch>(source: PrimitiveSource<T>) => sb3.Input;
+declare const fromCostumeSource: (source: CostumeSource) => sb3.Input;
+declare const fromSoundSource: (source: SoundSource) => sb3.Input;
+//#endregion
+//#region src/core/composer.d.ts
+type Handler = () => void;
+interface BlockInit {
+  inputs?: Record<string, sb3.Input>;
+  fields?: Record<string, sb3.Fields>;
+  topLevel?: boolean;
+  mutation?: sb3.Mutation;
+  isShadow?: boolean;
+  isValue?: boolean;
+}
+declare const block: (opcode: string, init: BlockInit) => HikkakuBlock;
+declare const valueBlock: (opcode: string, init: BlockInit) => HikkakuBlock;
+declare const substack: (handler: Handler) => string | null;
+declare const attachStack: (parentId: string, handler?: Handler) => string | null;
+declare const createBlocks: (handler: Handler) => Record<string, sb3.Block>;
+//#endregion
+//#region src/core/monitors.d.ts
+interface VariableMonitor {
+  id: string;
+  mode: 'default' | 'large' | 'slider';
+  opcode: 'data_variable';
+  params: {
+    VARIABLE: string;
+  };
+  spriteName: string | null;
+  value: sb3.ScalarVal;
+  sliderMin: number;
+  sliderMax: number;
+  isDiscrete: boolean;
+  x: number | null;
+  y: number | null;
+  width: number;
+  height: number;
+  visible: boolean;
+}
+interface ListMonitor {
+  id: string;
+  mode: 'list';
+  opcode: 'data_listcontents';
+  params: {
+    LIST: string;
+  };
+  spriteName: string | null;
+  value: sb3.ScalarVal[];
+  x: number | null;
+  y: number | null;
+  width: number;
+  height: number;
+  visible: boolean;
+}
+type Monitor = VariableMonitor | ListMonitor;
+//#endregion
+//#region src/core/project.d.ts
+declare class Target<IsStage extends boolean = boolean> {
+  #private;
+  readonly isStage: IsStage;
+  readonly name: IsStage extends true ? 'Stage' : string;
+  currentCostume: number;
+  constructor(isStage: IsStage, name: IsStage extends true ? 'Stage' : string);
+  run(handler: (target: Target<IsStage>) => void): void;
+  createVariable(name: string, defaultValue?: sb3.ScalarVal, isCloudVariableOrOptions?: boolean | CreateVariableOptions): VariableDefinition;
+  createList(name: string, defaultValue?: sb3.ScalarVal[], options?: CreateListOptions): ListReference;
+  addCostume(costume: sb3.Costume): CostumeReference;
+  addSound(sound: sb3.Sound): SoundReference;
+  get monitors(): readonly Monitor[];
+  toScratch(): IsStage extends true ? sb3.Stage : sb3.Sprite;
+}
+declare class Project {
+  #private;
+  readonly stage: Target<true>;
+  constructor();
+  createSprite(name: string): Target<false>;
+  toScratch(): sb3.ScratchProject;
+}
+//#endregion
+export { SoundReference as C, VariableMonitorMode as D, VariableDefinition as E, VariableMonitorOptions as O, PrimitiveSource as S, VariableBase as T, HikkakuBlock as _, attachStack as a, MonitorPosition as b, substack as c, fromPrimitiveSource as d, fromSoundSource as f, CreateVariableOptions as g, CreateListOptions as h, Handler as i, VariableReference as k, valueBlock as l, CostumeSource as m, Target as n, block as o, CostumeReference as p, BlockInit as r, createBlocks as s, Project as t, fromCostumeSource as u, ListMonitorOptions as v, SoundSource as w, PrimitiveAvailableOnScratch as x, ListReference as y };

package/vite/index.mjs

@@ -1,29 +1,93 @@
+import { zip } from "fflate";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
 import { createServerModuleRunner } from "vite";
 
 //#region src/vite/index.ts
 const BASE_URL = "https://scratchfoundation.github.io/scratch-gui/";
+const VIRTUAL_MODULE_IDS = { project: "/@virtual/hikkaku-project" };
 function hikkaku(init) {
 	let runner = null;
 	return {
 		name: "vite-plugin-hikkaku",
-		config() {
-			return { environments: {
-				hikkaku: {},
-				client: {}
-			} };
+		config(config, env) {
+			if (env.command === "build") (config.plugins?.find((p) => p && typeof p === "object" && "name" in p && p.name === "vite-plugin-turbowarp-packager"))?.api.setEntry(path.join(process.cwd(), "dist", "project.sb3"));
+			return {
+				environments: { hikkaku: { build: { rolldownOptions: {
+					input: init.entry,
+					output: {
+						entryFileNames: "project.mjs",
+						format: "es"
+					}
+				} } } },
+				builder: {}
+			};
+		},
+		async buildApp(builder) {
+			const env = builder.environments.hikkaku;
+			if (!env) throw new Error("Hikkaku environment is not configured.");
+			await builder.build(env);
+		},
+		async generateBundle(_options, bundle) {
+			const tmpDir = path.join(process.cwd(), "dist", ".tmp");
+			for (const [filePath, file] of Object.entries(bundle)) if (file.type === "chunk") {
+				const fullPath = path.join(tmpDir, filePath);
+				await mkdir(path.dirname(fullPath), { recursive: true });
+				await writeFile(fullPath, file.code);
+			}
+			const { default: project } = await import(pathToFileURL(path.join(process.cwd(), "dist/.tmp", "project.mjs")).href);
+			const projectJSON = project.toScratch();
+			const zipData = await new Promise((resolve, reject) => {
+				zip({ "project.json": new TextEncoder().encode(JSON.stringify(projectJSON)) }, (err, data) => {
+					if (err) reject(err);
+					else resolve(data);
+				});
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: "project.sb3",
+				name: "project.sb3",
+				source: zipData
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: "project.json",
+				name: "project.json",
+				source: JSON.stringify(projectJSON, null, 2)
+			});
+			await rm(tmpDir, {
+				recursive: true,
+				force: true
+			});
 		},
 		resolveId(source) {
 			if (source === "/@virtual/hikkaku-client") return source;
+			if (source === VIRTUAL_MODULE_IDS.project) return source;
 		},
-		load(id) {
+		async load(id) {
 			if (id === "/@virtual/hikkaku-client") return `
           import 'hikkaku/client'
         `;
+			if (id === VIRTUAL_MODULE_IDS.project) {
+				if (this.environment.mode === "dev") {
+					if (!runner) throw new Error("Module runner is not initialized.");
+					const project = (await runner.import(init.entry)).default;
+					return `
+            export default ${JSON.stringify(project.toScratch())}
+          `;
+				} else if (this.environment.mode === "build") {
+					const projectJSON = await import(pathToFileURL(path.join(process.cwd(), "dist", "project.json")).href, { with: { type: "json" } });
+					return `
+            export default ${JSON.stringify(projectJSON)}
+          `;
+				}
+			}
 		},
 		async hotUpdate(options) {
 			if (this.environment.name !== "hikkaku") return;
 			if (!runner) throw new Error("Module runner is not initialized.");
-			const project = (await runner.import(options.file)).default;
+			const project = (await runner.import(init.entry)).default;
 			options.server.environments.client.hot.send("hikkaku:project", project.toScratch());
 		},
 		async configureServer(server) {

package/project-BSiPw18H.d.mts

@@ -1,73 +0,0 @@
-import * as sb3 from "sb3-types";
-
-//#region src/core/types.d.ts
-type PrimitiveAvailableOnScratch = number | boolean | string;
-type PrimitiveSource<T extends PrimitiveAvailableOnScratch> = T | HikkakuBlock;
-interface VariableBase {
-  id: string;
-  name: string;
-}
-interface VariableReference extends VariableBase {
-  type: 'variable';
-}
-interface ListReference extends VariableBase {
-  type: 'list';
-}
-interface CostumeReference {
-  name: string;
-  type: 'costume';
-}
-type CostumeSource = PrimitiveSource<string> | CostumeReference;
-interface SoundReference {
-  name: string;
-  type: 'sound';
-}
-type SoundSource = PrimitiveSource<string> | SoundReference;
-interface HikkakuBlock {
-  isBlock: true;
-  id: string;
-}
-//#endregion
-//#region src/core/block-helper.d.ts
-declare const fromPrimitiveSource: <T extends PrimitiveAvailableOnScratch>(source: PrimitiveSource<T>) => sb3.Input;
-declare const fromCostumeSource: (source: CostumeSource) => sb3.Input;
-declare const fromSoundSource: (source: SoundSource) => sb3.Input;
-//#endregion
-//#region src/core/composer.d.ts
-type Handler = () => void;
-interface BlockInit {
-  inputs?: Record<string, sb3.Input>;
-  fields?: Record<string, sb3.Fields>;
-  topLevel?: boolean;
-  mutation?: sb3.Mutation;
-  isShadow?: boolean;
-  isValue?: boolean;
-}
-declare const block: (opcode: string, init: BlockInit) => HikkakuBlock;
-declare const valueBlock: (opcode: string, init: BlockInit) => HikkakuBlock;
-declare const substack: (handler: Handler) => string | null;
-declare const createBlocks: (handler: Handler) => Record<string, sb3.Block>;
-//#endregion
-//#region src/core/project.d.ts
-declare class Target<IsStage extends boolean = boolean> {
-  #private;
-  readonly isStage: IsStage;
-  readonly name: IsStage extends true ? 'Stage' : string;
-  currentCostume: number;
-  constructor(isStage: IsStage, name: IsStage extends true ? 'Stage' : string);
-  run(handler: (target: Target<IsStage>) => void): void;
-  createVariable(name: string, defaultValue?: sb3.ScalarVal, isCloudVariable?: boolean): VariableReference;
-  createList(name: string, defaultValue?: sb3.ScalarVal[]): ListReference;
-  addCostume(costume: sb3.Costume): CostumeReference;
-  addSound(sound: sb3.Sound): SoundReference;
-  toScratch(): IsStage extends true ? sb3.Stage : sb3.Sprite;
-}
-declare class Project {
-  #private;
-  readonly stage: Target<true>;
-  constructor();
-  createSprite(name: string): Target<false>;
-  toScratch(): sb3.ScratchProject;
-}
-//#endregion
-export { PrimitiveSource as _, block as a, VariableBase as b, valueBlock as c, fromSoundSource as d, CostumeReference as f, PrimitiveAvailableOnScratch as g, ListReference as h, Handler as i, fromCostumeSource as l, HikkakuBlock as m, Target as n, createBlocks as o, CostumeSource as p, BlockInit as r, substack as s, Project as t, fromPrimitiveSource as u, SoundReference as v, VariableReference as x, SoundSource as y };