unplugin-typegpu 0.9.0 → 0.10.1

package/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,29 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/babel.cjs

@@ -1,2 +1,163 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkDEVVEJF4cjs = require('./chunk-DEVVEJF4.cjs');exports.default = _chunkDEVVEJF4cjs.i;
-//# sourceMappingURL=babel.cjs.map
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_common = require('./common.cjs');
+const require_filter = require('./filter.cjs');
+let defu = require("defu");
+defu = require_runtime.__toESM(defu);
+let tinyest_for_wgsl = require("tinyest-for-wgsl");
+let tinyest = require("tinyest");
+let _babel_standalone = require("@babel/standalone");
+_babel_standalone = require_runtime.__toESM(_babel_standalone);
+
+//#region src/babel.ts
+const template = _babel_standalone.packages.template;
+const types = _babel_standalone.packages.types;
+function containsUseGpuDirective(node) {
+	var _node$body$directives, _node$body;
+	return ("directives" in node.body ? (_node$body$directives = (_node$body = node.body) === null || _node$body === void 0 ? void 0 : _node$body.directives) !== null && _node$body$directives !== void 0 ? _node$body$directives : [] : []).map((directive) => directive.value.value).includes(require_common.useGpuDirective);
+}
+function i(identifier) {
+	return types.identifier(identifier);
+}
+const fnNodeToOriginalMap = /* @__PURE__ */ new WeakMap();
+function functionToTranspiled(node, parent) {
+	var _fnNodeToOriginalMap$;
+	const { params, body, externalNames } = (0, tinyest_for_wgsl.transpileFn)((_fnNodeToOriginalMap$ = fnNodeToOriginalMap.get(node)) !== null && _fnNodeToOriginalMap$ !== void 0 ? _fnNodeToOriginalMap$ : node);
+	const maybeName = require_common.getFunctionName(node, parent);
+	const metadata = types.objectExpression([
+		types.objectProperty(i("v"), types.numericLiteral(tinyest.FORMAT_VERSION)),
+		types.objectProperty(i("name"), maybeName ? types.stringLiteral(maybeName) : types.buildUndefinedNode()),
+		types.objectProperty(i("ast"), template.expression`${require_common.embedJSON({
+			params,
+			body,
+			externalNames
+		})}`()),
+		types.objectProperty(i("externals"), types.arrowFunctionExpression([], types.blockStatement([types.returnStatement(types.objectExpression(externalNames.map((name) => types.objectProperty(i(name), i(name), false, name !== "this"))))])))
+	]);
+	return types.callExpression(types.arrowFunctionExpression([i("$")], types.logicalExpression("&&", types.callExpression(types.memberExpression(types.assignmentExpression("??=", types.memberExpression(i("globalThis"), i("__TYPEGPU_META__")), types.newExpression(i("WeakMap"), [])), i("set")), [types.assignmentExpression("=", types.memberExpression(i("$"), i("f")), node), metadata]), types.memberExpression(i("$"), i("f")))), [types.objectExpression([])]);
+}
+function wrapInAutoName(node, name) {
+	return types.callExpression(template.expression("globalThis.__TYPEGPU_AUTONAME__ ?? (a => a)", { placeholderPattern: false })(), [node, types.stringLiteral(name)]);
+}
+function functionVisitor(ctx) {
+	let inUseGpuScope = false;
+	return {
+		VariableDeclarator(path) {
+			require_common.performExpressionNaming(ctx, path.node, (node, name) => {
+				path.get("init").replaceWith(wrapInAutoName(node, name));
+			});
+		},
+		AssignmentExpression(path) {
+			if (inUseGpuScope) {
+				const runtimeFn = require_common.operators[path.node.operator];
+				if (runtimeFn) path.replaceWith(types.assignmentExpression("=", path.node.left, types.callExpression(types.identifier(runtimeFn), [path.node.left, path.node.right])));
+			}
+			require_common.performExpressionNaming(ctx, path.node, (node, name) => {
+				path.get("right").replaceWith(wrapInAutoName(node, name));
+			});
+		},
+		ObjectProperty(path) {
+			require_common.performExpressionNaming(ctx, path.node, (node, name) => {
+				path.get("value").replaceWith(wrapInAutoName(node, name));
+			});
+		},
+		ClassProperty(path) {
+			require_common.performExpressionNaming(ctx, path.node, (node, name) => {
+				path.get("value").replaceWith(wrapInAutoName(node, name));
+			});
+		},
+		ImportDeclaration(path) {
+			require_common.gatherTgpuAliases(path.node, ctx);
+		},
+		BinaryExpression: { exit(path) {
+			if (!inUseGpuScope) return;
+			const runtimeFn = require_common.operators[path.node.operator];
+			if (runtimeFn) path.replaceWith(types.callExpression(types.identifier(runtimeFn), [path.node.left, path.node.right]));
+		} },
+		ArrowFunctionExpression: {
+			enter(path) {
+				if (containsUseGpuDirective(path.node)) {
+					fnNodeToOriginalMap.set(path.node, types.cloneNode(path.node, true));
+					if (inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+					inUseGpuScope = true;
+				}
+			},
+			exit(path) {
+				const node = path.node;
+				if (containsUseGpuDirective(node)) {
+					inUseGpuScope = false;
+					const parent = path.parentPath.node;
+					path.replaceWith(functionToTranspiled(node, parent));
+					path.skip();
+				}
+			}
+		},
+		FunctionExpression: {
+			enter(path) {
+				if (containsUseGpuDirective(path.node)) {
+					fnNodeToOriginalMap.set(path.node, types.cloneNode(path.node, true));
+					if (inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+					inUseGpuScope = true;
+				}
+			},
+			exit(path) {
+				const node = path.node;
+				if (containsUseGpuDirective(node)) {
+					inUseGpuScope = false;
+					const parent = path.parentPath.node;
+					path.replaceWith(functionToTranspiled(node, parent));
+					path.skip();
+				}
+			}
+		},
+		FunctionDeclaration: {
+			enter(path) {
+				if (containsUseGpuDirective(path.node)) {
+					fnNodeToOriginalMap.set(path.node, types.cloneNode(path.node, true));
+					if (inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+					inUseGpuScope = true;
+				}
+			},
+			exit(path) {
+				var _fnNodeToOriginalMap$2;
+				const node = (_fnNodeToOriginalMap$2 = fnNodeToOriginalMap.get(path.node)) !== null && _fnNodeToOriginalMap$2 !== void 0 ? _fnNodeToOriginalMap$2 : path.node;
+				if (containsUseGpuDirective(node)) {
+					inUseGpuScope = false;
+					if (!node.id) return;
+					const parent = path.parentPath.node;
+					const expression = types.functionExpression(node.id, node.params, node.body);
+					path.replaceWith(types.variableDeclaration("const", [types.variableDeclarator(node.id, functionToTranspiled(expression, parent))]));
+					path.skip();
+				}
+			}
+		},
+		CallExpression: { exit(path) {
+			const node = path.node;
+			if (require_common.isShellImplementationCall(node, ctx)) {
+				const implementation = node.arguments[0];
+				if (implementation && (implementation.type === "FunctionExpression" || implementation.type === "ArrowFunctionExpression")) {
+					const transpiled = functionToTranspiled(implementation, null);
+					path.replaceWith(types.callExpression(node.callee, [transpiled]));
+					path.skip();
+				}
+			}
+		} }
+	};
+}
+function babel_default() {
+	return { visitor: { Program(path, state) {
+		const options = (0, defu.default)(state.opts, require_common.defaultOptions);
+		const id = state.filename;
+		const filter = require_filter.createFilterForId(options);
+		if (id && filter && !(filter === null || filter === void 0 ? void 0 : filter(id))) return;
+		const ctx = {
+			tgpuAliases: new Set(options.forceTgpuAlias ? [options.forceTgpuAlias] : []),
+			fileId: id,
+			autoNamingEnabled: options.autoNamingEnabled
+		};
+		path.traverse(functionVisitor(ctx));
+	} } };
+}
+
+//#endregion
+exports.default = babel_default;

package/babel.d.cts

@@ -1,10 +1,10 @@
-import * as _babel_traverse from '@babel/traverse';
-import * as babel from '@babel/types';
+import { Node, Program } from "./node_modules/.pnpm/@babel_types@7.26.5/node_modules/@babel/types/lib/index-legacy.cjs";
+import * as _babel_traverse0 from "@babel/traverse";
 
+//#region src/babel.d.ts
 declare function export_default(): {
-    visitor: {
-        Program(this: babel.Node, path: _babel_traverse.NodePath<babel.Program>, state: babel.Node): void;
-    };
+  visitor: {
+    Program(this: Node, path: _babel_traverse0.NodePath<Program>, state: Node): void;
+  };
 };
-
-export { export_default as default };
+export = export_default;

package/babel.d.mts

@@ -0,0 +1,11 @@
+import { Node, Program } from "./node_modules/.pnpm/@babel_types@7.26.5/node_modules/@babel/types/lib/index-legacy.mjs";
+import * as _babel_traverse0 from "@babel/traverse";
+
+//#region src/babel.d.ts
+declare function export_default(): {
+  visitor: {
+    Program(this: Node, path: _babel_traverse0.NodePath<Program>, state: Node): void;
+  };
+};
+//#endregion
+export { export_default as default };

package/babel.mjs

@@ -0,0 +1,159 @@
+import { defaultOptions, embedJSON, gatherTgpuAliases, getFunctionName, isShellImplementationCall, operators, performExpressionNaming, useGpuDirective } from "./common.mjs";
+import { createFilterForId } from "./filter.mjs";
+import defu from "defu";
+import { transpileFn } from "tinyest-for-wgsl";
+import { FORMAT_VERSION } from "tinyest";
+import * as Babel from "@babel/standalone";
+
+//#region src/babel.ts
+const template = Babel.packages.template;
+const types = Babel.packages.types;
+function containsUseGpuDirective(node) {
+	var _node$body$directives, _node$body;
+	return ("directives" in node.body ? (_node$body$directives = (_node$body = node.body) === null || _node$body === void 0 ? void 0 : _node$body.directives) !== null && _node$body$directives !== void 0 ? _node$body$directives : [] : []).map((directive) => directive.value.value).includes(useGpuDirective);
+}
+function i(identifier) {
+	return types.identifier(identifier);
+}
+const fnNodeToOriginalMap = /* @__PURE__ */ new WeakMap();
+function functionToTranspiled(node, parent) {
+	var _fnNodeToOriginalMap$;
+	const { params, body, externalNames } = transpileFn((_fnNodeToOriginalMap$ = fnNodeToOriginalMap.get(node)) !== null && _fnNodeToOriginalMap$ !== void 0 ? _fnNodeToOriginalMap$ : node);
+	const maybeName = getFunctionName(node, parent);
+	const metadata = types.objectExpression([
+		types.objectProperty(i("v"), types.numericLiteral(FORMAT_VERSION)),
+		types.objectProperty(i("name"), maybeName ? types.stringLiteral(maybeName) : types.buildUndefinedNode()),
+		types.objectProperty(i("ast"), template.expression`${embedJSON({
+			params,
+			body,
+			externalNames
+		})}`()),
+		types.objectProperty(i("externals"), types.arrowFunctionExpression([], types.blockStatement([types.returnStatement(types.objectExpression(externalNames.map((name) => types.objectProperty(i(name), i(name), false, name !== "this"))))])))
+	]);
+	return types.callExpression(types.arrowFunctionExpression([i("$")], types.logicalExpression("&&", types.callExpression(types.memberExpression(types.assignmentExpression("??=", types.memberExpression(i("globalThis"), i("__TYPEGPU_META__")), types.newExpression(i("WeakMap"), [])), i("set")), [types.assignmentExpression("=", types.memberExpression(i("$"), i("f")), node), metadata]), types.memberExpression(i("$"), i("f")))), [types.objectExpression([])]);
+}
+function wrapInAutoName(node, name) {
+	return types.callExpression(template.expression("globalThis.__TYPEGPU_AUTONAME__ ?? (a => a)", { placeholderPattern: false })(), [node, types.stringLiteral(name)]);
+}
+function functionVisitor(ctx) {
+	let inUseGpuScope = false;
+	return {
+		VariableDeclarator(path) {
+			performExpressionNaming(ctx, path.node, (node, name) => {
+				path.get("init").replaceWith(wrapInAutoName(node, name));
+			});
+		},
+		AssignmentExpression(path) {
+			if (inUseGpuScope) {
+				const runtimeFn = operators[path.node.operator];
+				if (runtimeFn) path.replaceWith(types.assignmentExpression("=", path.node.left, types.callExpression(types.identifier(runtimeFn), [path.node.left, path.node.right])));
+			}
+			performExpressionNaming(ctx, path.node, (node, name) => {
+				path.get("right").replaceWith(wrapInAutoName(node, name));
+			});
+		},
+		ObjectProperty(path) {
+			performExpressionNaming(ctx, path.node, (node, name) => {
+				path.get("value").replaceWith(wrapInAutoName(node, name));
+			});
+		},
+		ClassProperty(path) {
+			performExpressionNaming(ctx, path.node, (node, name) => {
+				path.get("value").replaceWith(wrapInAutoName(node, name));
+			});
+		},
+		ImportDeclaration(path) {
+			gatherTgpuAliases(path.node, ctx);
+		},
+		BinaryExpression: { exit(path) {
+			if (!inUseGpuScope) return;
+			const runtimeFn = operators[path.node.operator];
+			if (runtimeFn) path.replaceWith(types.callExpression(types.identifier(runtimeFn), [path.node.left, path.node.right]));
+		} },
+		ArrowFunctionExpression: {
+			enter(path) {
+				if (containsUseGpuDirective(path.node)) {
+					fnNodeToOriginalMap.set(path.node, types.cloneNode(path.node, true));
+					if (inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+					inUseGpuScope = true;
+				}
+			},
+			exit(path) {
+				const node = path.node;
+				if (containsUseGpuDirective(node)) {
+					inUseGpuScope = false;
+					const parent = path.parentPath.node;
+					path.replaceWith(functionToTranspiled(node, parent));
+					path.skip();
+				}
+			}
+		},
+		FunctionExpression: {
+			enter(path) {
+				if (containsUseGpuDirective(path.node)) {
+					fnNodeToOriginalMap.set(path.node, types.cloneNode(path.node, true));
+					if (inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+					inUseGpuScope = true;
+				}
+			},
+			exit(path) {
+				const node = path.node;
+				if (containsUseGpuDirective(node)) {
+					inUseGpuScope = false;
+					const parent = path.parentPath.node;
+					path.replaceWith(functionToTranspiled(node, parent));
+					path.skip();
+				}
+			}
+		},
+		FunctionDeclaration: {
+			enter(path) {
+				if (containsUseGpuDirective(path.node)) {
+					fnNodeToOriginalMap.set(path.node, types.cloneNode(path.node, true));
+					if (inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+					inUseGpuScope = true;
+				}
+			},
+			exit(path) {
+				var _fnNodeToOriginalMap$2;
+				const node = (_fnNodeToOriginalMap$2 = fnNodeToOriginalMap.get(path.node)) !== null && _fnNodeToOriginalMap$2 !== void 0 ? _fnNodeToOriginalMap$2 : path.node;
+				if (containsUseGpuDirective(node)) {
+					inUseGpuScope = false;
+					if (!node.id) return;
+					const parent = path.parentPath.node;
+					const expression = types.functionExpression(node.id, node.params, node.body);
+					path.replaceWith(types.variableDeclaration("const", [types.variableDeclarator(node.id, functionToTranspiled(expression, parent))]));
+					path.skip();
+				}
+			}
+		},
+		CallExpression: { exit(path) {
+			const node = path.node;
+			if (isShellImplementationCall(node, ctx)) {
+				const implementation = node.arguments[0];
+				if (implementation && (implementation.type === "FunctionExpression" || implementation.type === "ArrowFunctionExpression")) {
+					const transpiled = functionToTranspiled(implementation, null);
+					path.replaceWith(types.callExpression(node.callee, [transpiled]));
+					path.skip();
+				}
+			}
+		} }
+	};
+}
+function babel_default() {
+	return { visitor: { Program(path, state) {
+		const options = defu(state.opts, defaultOptions);
+		const id = state.filename;
+		const filter = createFilterForId(options);
+		if (id && filter && !(filter === null || filter === void 0 ? void 0 : filter(id))) return;
+		const ctx = {
+			tgpuAliases: new Set(options.forceTgpuAlias ? [options.forceTgpuAlias] : []),
+			fileId: id,
+			autoNamingEnabled: options.autoNamingEnabled
+		};
+		path.traverse(functionVisitor(ctx));
+	} } };
+}
+
+//#endregion
+export { babel_default as default };

package/bun.cjs

@@ -1,2 +1,40 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkNQODVO3Lcjs = require('./chunk-NQODVO3L.cjs');require('./chunk-DEVVEJF4.cjs');exports.default = _chunkNQODVO3Lcjs.a;
-//# sourceMappingURL=bun.cjs.map
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_common = require('./common.cjs');
+const require_babel = require('./babel.cjs');
+let defu = require("defu");
+defu = require_runtime.__toESM(defu);
+let _babel_standalone = require("@babel/standalone");
+_babel_standalone = require_runtime.__toESM(_babel_standalone);
+
+//#region src/bun.ts
+var bun_default = (rawOptions) => {
+	const options = (0, defu.default)(rawOptions, require_common.defaultOptions);
+	const include = options.include;
+	if (!(include instanceof RegExp)) throw new Error(`Unsupported 'include' options in Bun plugin. Please provide a single regular expression`);
+	if (options.exclude) throw new Error(`Unsupported 'exclude' option in Bun plugin`);
+	return {
+		name: "unplugin-typegpu",
+		setup(build) {
+			build.onLoad({ filter: include }, async (args) => {
+				const text = await Bun.file(args.path).text();
+				if (require_common.earlyPruneRegex.every((pattern) => !pattern.test(text))) return {
+					contents: text,
+					loader: args.loader
+				};
+				const result = _babel_standalone.transform(text, {
+					presets: [["typescript", { allowDeclareFields: true }]],
+					filename: args.path,
+					plugins: [require_babel.default]
+				}).code;
+				return {
+					contents: result !== null && result !== void 0 ? result : text,
+					loader: args.loader
+				};
+			});
+		}
+	};
+};
+
+//#endregion
+exports.default = bun_default;

package/bun.d.cts

@@ -1,3 +1,5 @@
-import 'bun';
-export { _ as default } from './bun-Dq3TUCfa.cjs';
-import 'unplugin';
+import { Options } from "./common.cjs";
+
+//#region src/bun.d.ts
+declare const _default: (rawOptions: Options) => BunPlugin;
+export = _default;

package/bun.d.mts

@@ -0,0 +1,6 @@
+import { Options } from "./common.mjs";
+
+//#region src/bun.d.ts
+declare const _default: (rawOptions: Options) => BunPlugin;
+//#endregion
+export { _default as default };

package/bun.mjs

@@ -0,0 +1,36 @@
+import { defaultOptions, earlyPruneRegex } from "./common.mjs";
+import babel_default from "./babel.mjs";
+import defu from "defu";
+import * as Babel from "@babel/standalone";
+
+//#region src/bun.ts
+var bun_default = (rawOptions) => {
+	const options = defu(rawOptions, defaultOptions);
+	const include = options.include;
+	if (!(include instanceof RegExp)) throw new Error(`Unsupported 'include' options in Bun plugin. Please provide a single regular expression`);
+	if (options.exclude) throw new Error(`Unsupported 'exclude' option in Bun plugin`);
+	return {
+		name: "unplugin-typegpu",
+		setup(build) {
+			build.onLoad({ filter: include }, async (args) => {
+				const text = await Bun.file(args.path).text();
+				if (earlyPruneRegex.every((pattern) => !pattern.test(text))) return {
+					contents: text,
+					loader: args.loader
+				};
+				const result = Babel.transform(text, {
+					presets: [["typescript", { allowDeclareFields: true }]],
+					filename: args.path,
+					plugins: [babel_default]
+				}).code;
+				return {
+					contents: result !== null && result !== void 0 ? result : text,
+					loader: args.loader
+				};
+			});
+		}
+	};
+};
+
+//#endregion
+export { bun_default as default };

package/common.cjs

@@ -0,0 +1,183 @@
+
+//#region src/common.ts
+const defaultOptions = {
+	include: /\.m?[jt]sx?(?:\?.*)?$/,
+	autoNamingEnabled: true,
+	earlyPruning: true
+};
+function embedJSON(jsValue) {
+	return JSON.stringify(jsValue).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+/**
+* Checks if `node` is an alias for the 'tgpu' object, traditionally
+* available via `import tgpu from 'typegpu'`.
+*/
+function isTgpu(ctx, node) {
+	let path = "";
+	let tail = node;
+	while (true) if (tail.type === "MemberExpression") {
+		if ((tail.property.type === "Literal" || tail.property.type === "StringLiteral") && tail.property.value === "~unstable") {
+			tail = tail.object;
+			continue;
+		}
+		if (tail.property.type !== "Identifier") break;
+		path = path ? `${tail.property.name}.${path}` : tail.property.name;
+		tail = tail.object;
+	} else if (tail.type === "Identifier") {
+		path = path ? `${tail.name}.${path}` : tail.name;
+		break;
+	} else break;
+	return ctx.tgpuAliases.has(path);
+}
+function gatherTgpuAliases(node, ctx) {
+	if (node.source.value === "typegpu") {
+		for (const spec of node.specifiers) if (spec.type === "ImportDefaultSpecifier" || spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && spec.imported.name === "tgpu") ctx.tgpuAliases.add(spec.local.name);
+		else if (spec.type === "ImportNamespaceSpecifier") ctx.tgpuAliases.add(`${spec.local.name}.tgpu`);
+	}
+}
+const fnShellFunctionNames = [
+	"fn",
+	"vertexFn",
+	"fragmentFn",
+	"computeFn"
+];
+function isShellImplementationCall(node, ctx) {
+	return node.callee.type === "CallExpression" && node.callee.callee.type === "MemberExpression" && node.callee.callee.property.type === "Identifier" && fnShellFunctionNames.includes(node.callee.callee.property.name) && node.arguments.length === 1 && isTgpu(ctx, node.callee.callee.object);
+}
+/**
+* Extracts a name and expression from nodes that contain a label and an expression,
+* such as VariableDeclarator or PropertyDefinition.
+* Returns a tuple of [name, expression] if found, otherwise undefined.
+*
+* @example
+* extractLabelledExpression(node`let name = tgpu.bindGroupLayout({});`)
+* // ["name", node`tgpu.bindGroupLayout({})`]
+*/
+function extractLabelledExpression(node) {
+	if (node.type === "VariableDeclarator" && node.id.type === "Identifier" && node.init) return [node.id.name, node.init];
+	else if (node.type === "AssignmentExpression") {
+		const maybeName = tryFindIdentifier(node.left);
+		if (maybeName) return [maybeName, node.right];
+	} else if ((node.type === "Property" || node.type === "ObjectProperty") && node.key.type === "Identifier") return [node.key.name, node.value];
+	else if ((node.type === "ClassProperty" || node.type === "PropertyDefinition") && node.value && node.key.type === "Identifier") return [node.key.name, node.value];
+}
+function getFunctionName(node, parent) {
+	var _extractLabelledExpre, _node$id;
+	const maybeName = parent ? (_extractLabelledExpre = extractLabelledExpression(parent)) === null || _extractLabelledExpre === void 0 ? void 0 : _extractLabelledExpre[0] : void 0;
+	return maybeName !== null && maybeName !== void 0 ? maybeName : node.type === "FunctionDeclaration" || node.type === "FunctionExpression" ? (_node$id = node.id) === null || _node$id === void 0 ? void 0 : _node$id.name : void 0;
+}
+const resourceConstructors = [
+	"bindGroupLayout",
+	"vertexLayout",
+	"privateVar",
+	"workgroupVar",
+	"const",
+	"slot",
+	"accessor",
+	"comptime",
+	...fnShellFunctionNames,
+	"createBuffer",
+	"createMutable",
+	"createReadonly",
+	"createUniform",
+	"createQuerySet",
+	"createPipeline",
+	"createComputePipeline",
+	"createGuardedComputePipeline",
+	"createRenderPipeline",
+	"createTexture",
+	"createSampler",
+	"createComparisonSampler",
+	"struct",
+	"unstruct",
+	"createView"
+];
+/**
+* Checks if `node` should be wrapped in an autoname function.
+* Since it is mostly for debugging and clean WGSL generation,
+* some false positives and false negatives are admissible.
+*/
+function containsResourceConstructorCall(node, ctx) {
+	if (node.type === "CallExpression") {
+		if (isShellImplementationCall(node, ctx)) return true;
+		if (node.callee.type === "Identifier" && resourceConstructors.includes(node.callee.name)) return true;
+		if (node.callee.type === "MemberExpression") {
+			if (node.callee.property.type === "Identifier") {
+				if (resourceConstructors.includes(node.callee.property.name)) return true;
+				if (node.callee.property.name === "$name") return false;
+			}
+			return containsResourceConstructorCall(node.callee.object, ctx);
+		}
+	}
+	if (node.type === "TaggedTemplateExpression") return containsResourceConstructorCall(node.tag, ctx);
+	return false;
+}
+/**
+* Tries to find an identifier in a node.
+*
+* @example
+* // syntax is simplified, imagine the arguments are appropriate nodes instead
+* tryFindIdentifier('myBuffer'); // 'myBuffer'
+* tryFindIdentifier('buffers.myBuffer'); // 'myBuffer'
+* tryFindIdentifier('this.myBuffer'); // 'myBuffer'
+* tryFindIdentifier('[a, b]'); // undefined
+*/
+function tryFindIdentifier(node) {
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "PrivateName") return tryFindIdentifier(node.id);
+	if (node.type === "PrivateIdentifier") return node.name;
+	if (node.type === "MemberExpression") return tryFindIdentifier(node.property);
+}
+/**
+* Checks if `node` contains a label and a tgpu expression that could be named.
+* If so, it calls the provided callback. Nodes selected for naming include:
+*
+* `let name = tgpu.bindGroupLayout({});` (VariableDeclarator)
+*
+* `name = tgpu.bindGroupLayout({});` (AssignmentExpression)
+*
+* `property: tgpu.bindGroupLayout({})` (Property/ObjectProperty)
+*
+* Since it is mostly for debugging and clean WGSL generation,
+* some false positives and false negatives are admissible.
+*
+* This function is NOT used for auto-naming shell-less functions.
+* Those are handled separately.
+*
+* @privateRemarks
+* When adding new checks, you need to call this method in the corresponding node in Babel.
+*/
+function performExpressionNaming(ctx, node, namingCallback) {
+	if (!ctx.autoNamingEnabled) return;
+	const labelledExpression = extractLabelledExpression(node);
+	if (labelledExpression) {
+		const [label, expression] = labelledExpression;
+		if (containsResourceConstructorCall(expression, ctx)) namingCallback(expression, label);
+	}
+}
+const useGpuDirective = "use gpu";
+/** Regular expressions used for early pruning (to avoid unnecessary parsing, which is expensive) */
+const earlyPruneRegex = [/["']use gpu["']/, /t(ype)?gpu/];
+const operators = {
+	"+": "__tsover_add",
+	"-": "__tsover_sub",
+	"*": "__tsover_mul",
+	"/": "__tsover_div",
+	"%": "__tsover_mod",
+	"+=": "__tsover_add",
+	"-=": "__tsover_sub",
+	"*=": "__tsover_mul",
+	"/=": "__tsover_div",
+	"%=": "__tsover_mod"
+};
+
+//#endregion
+exports.defaultOptions = defaultOptions;
+exports.earlyPruneRegex = earlyPruneRegex;
+exports.embedJSON = embedJSON;
+exports.gatherTgpuAliases = gatherTgpuAliases;
+exports.getFunctionName = getFunctionName;
+exports.isShellImplementationCall = isShellImplementationCall;
+exports.operators = operators;
+exports.performExpressionNaming = performExpressionNaming;
+exports.useGpuDirective = useGpuDirective;