unplugin-typegpu 0.11.6 → 0.12.0

package/common-hMfUmUk0.cjs

@@ -0,0 +1,790 @@
+//#region rolldown:runtime
+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
+let tinyest_for_wgsl = require("tinyest-for-wgsl");
+tinyest_for_wgsl = __toESM(tinyest_for_wgsl);
+let __babel_types = require("@babel/types");
+__babel_types = __toESM(__babel_types);
+let magic_string = require("magic-string");
+magic_string = __toESM(magic_string);
+let tinyest = require("tinyest");
+tinyest = __toESM(tinyest);
+
+//#region src/core/embeddedMetadata.ts
+const embeddedTypegpuMetadataCache = /* @__PURE__ */ new WeakMap();
+/**
+* Returns the node after unwrapping any parenthesized expressions.
+*/
+function unwrapParentheses(node) {
+	let current = node;
+	while (__babel_types.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+}
+/**
+* Returns the property name of a member expression.
+*/
+function memberPropertyName(node) {
+	if (!node.computed && __babel_types.isIdentifier(node.property)) return node.property.name;
+	if (node.computed && __babel_types.isStringLiteral(node.property)) return node.property.value;
+}
+/**
+* Returns whether the node is a global TypeGPU metadata expression (`globalThis.__TYPEGPU_META__`).
+*/
+function isGlobalTypegpuMetadata(node) {
+	const unwrapped = unwrapParentheses(node);
+	return __babel_types.isMemberExpression(unwrapped) && __babel_types.isIdentifier(unwrapped.object, { name: "globalThis" }) && memberPropertyName(unwrapped) === "__TYPEGPU_META__";
+}
+/**
+* Returns whether the node is a TypeGPU metadata set call (`(globalThis.__TYPEGPU_META__ ??= new WeakMap()).set`)
+*/
+function isTypegpuMetadataSetCall(node) {
+	const callee = unwrapParentheses(node.callee);
+	if (!__babel_types.isMemberExpression(callee) || memberPropertyName(callee) !== "set") return false;
+	const receiver = unwrapParentheses(callee.object);
+	return __babel_types.isAssignmentExpression(receiver, { operator: "??=" }) && isGlobalTypegpuMetadata(receiver.left);
+}
+/**
+* Returns the node of the property with the given name in the object, if it exists.
+*/
+function objectPropertyValue(object, expectedName) {
+	for (const property of object.properties) {
+		if (!__babel_types.isObjectProperty(property) || property.computed) continue;
+		if ((__babel_types.isIdentifier(property.key) ? property.key.name : __babel_types.isStringLiteral(property.key) ? property.key.value : void 0) === expectedName) return property.value;
+	}
+}
+/**
+* Returns metadata embedded by unplugin-typegpu for this exact function.
+* Externals are required as part of the emitted shape, but are intentionally not evaluated.
+*
+* Consider:
+* ```ts
+* const f = ($ => (globalThis.__TYPEGPU_META__ ??= new WeakMap()).set($.f = () => {
+*   'use gpu';
+* }, {
+*   v: 2,
+*   name: "f",
+*   ast: {
+*     params: [],
+*     body: [0, []]
+*   },
+*   externals: {}
+* }) && $.f)({});
+* ```
+*/
+function getEmbeddedTypegpuMetadata(path) {
+	var _expressionPath$paren, _assignedPath$parentP;
+	const cached = embeddedTypegpuMetadataCache.get(path);
+	if (cached !== void 0) return cached;
+	let expressionPath = path;
+	while ((_expressionPath$paren = expressionPath.parentPath) === null || _expressionPath$paren === void 0 ? void 0 : _expressionPath$paren.isParenthesizedExpression()) expressionPath = expressionPath.parentPath;
+	const assignmentPath = expressionPath.parentPath;
+	if (!(assignmentPath === null || assignmentPath === void 0 ? void 0 : assignmentPath.isAssignmentExpression({ operator: "=" }))) return;
+	let assignedPath = assignmentPath;
+	while ((_assignedPath$parentP = assignedPath.parentPath) === null || _assignedPath$parentP === void 0 ? void 0 : _assignedPath$parentP.isParenthesizedExpression()) assignedPath = assignedPath.parentPath;
+	const callPath = assignedPath.parentPath;
+	if (!((callPath === null || callPath === void 0 ? void 0 : callPath.isCallExpression()) && isTypegpuMetadataSetCall(callPath.node))) return;
+	const metadataNode = callPath.node.arguments[1];
+	if (!__babel_types.isObjectExpression(metadataNode)) return;
+	const versionNode = objectPropertyValue(metadataNode, "v");
+	const nameNode = objectPropertyValue(metadataNode, "name");
+	const astNode = objectPropertyValue(metadataNode, "ast");
+	const externalsNode = objectPropertyValue(metadataNode, "externals");
+	if (!__babel_types.isNumericLiteral(versionNode) || nameNode === void 0 || astNode === void 0 || externalsNode === void 0) return;
+	const name = __babel_types.isStringLiteral(nameNode) ? nameNode.value : void 0;
+	const embeddedTypegpuMetadata = {
+		v: versionNode.value,
+		name
+	};
+	embeddedTypegpuMetadataCache.set(path, embeddedTypegpuMetadata);
+	return embeddedTypegpuMetadata;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/core/obfuscate.ts
+const { NodeTypeCatalog: NODE } = tinyest;
+/**
+* Generates all strings consisting of lowercase letters of the given length.
+*/
+function* fixedLengthNameGenerator(length) {
+	if (length === 0) {
+		yield "";
+		return;
+	}
+	for (let i = 97; i <= 122; i++) for (const name of fixedLengthNameGenerator(length - 1)) yield `${String.fromCharCode(i)}${name}`;
+}
+/**
+* Generates all strings consisting of lowercase letters.
+*/
+function* nameGenerator() {
+	for (let i = 1;; i++) for (const name of fixedLengthNameGenerator(i)) yield name;
+}
+var _nameMap = /* @__PURE__ */ new WeakMap();
+var _nameGenerator = /* @__PURE__ */ new WeakMap();
+var _Obfuscator_brand = /* @__PURE__ */ new WeakSet();
+var Obfuscator = class {
+	constructor() {
+		_classPrivateMethodInitSpec(this, _Obfuscator_brand);
+		_classPrivateFieldInitSpec(this, _nameMap, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _nameGenerator, nameGenerator());
+	}
+	/**
+	* If `name` wasn't obfuscated before, give it a new obfuscated name.
+	* Then, returns the obfuscated version of `name`.
+	*/
+	obfuscate(name) {
+		let obfuscatedName = _classPrivateFieldGet2(_nameMap, this).get(name);
+		if (!obfuscatedName) {
+			obfuscatedName = _assertClassBrand(_Obfuscator_brand, this, _generateFreshName).call(this);
+			_classPrivateFieldGet2(_nameMap, this).set(name, obfuscatedName);
+		}
+		return obfuscatedName;
+	}
+};
+function _generateFreshName() {
+	return _classPrivateFieldGet2(_nameGenerator, this).next().value;
+}
+var Context = class {
+	constructor() {
+		_defineProperty(this, "obfuscator", void 0);
+		this.obfuscator = new Obfuscator();
+	}
+};
+function obfuscate(fn) {
+	const ctx = new Context();
+	const params = fn.params.map((param) => {
+		if (param.type === "i") return _objectSpread2(_objectSpread2({}, param), {}, { name: ctx.obfuscator.obfuscate(param.name) });
+		return _objectSpread2(_objectSpread2({}, param), {}, { props: param.props.map((prop) => _objectSpread2(_objectSpread2({}, prop), {}, { alias: ctx.obfuscator.obfuscate(prop.alias) })) });
+	});
+	const body = obf(ctx, fn.body);
+	const externalNames = /* @__PURE__ */ new Map();
+	fn.externalNames.forEach((value, key) => externalNames.set(ctx.obfuscator.obfuscate(key), value));
+	return {
+		params,
+		body,
+		externalNames
+	};
+}
+const visitors = {
+	block(ctx, node) {
+		return [NODE.block, node[1].map((node$1) => obf(ctx, node$1))];
+	},
+	binaryExpr(ctx, node) {
+		return [
+			NODE.binaryExpr,
+			obf(ctx, node[1]),
+			node[2],
+			obf(ctx, node[3])
+		];
+	},
+	assignmentExpr(ctx, node) {
+		return [
+			NODE.assignmentExpr,
+			obf(ctx, node[1]),
+			node[2],
+			obf(ctx, node[3])
+		];
+	},
+	logicalExpr(ctx, node) {
+		return [
+			NODE.logicalExpr,
+			obf(ctx, node[1]),
+			node[2],
+			obf(ctx, node[3])
+		];
+	},
+	unaryExpr(ctx, node) {
+		return [
+			NODE.unaryExpr,
+			node[1],
+			obf(ctx, node[2])
+		];
+	},
+	numericLiteral(_ctx, node) {
+		return [NODE.numericLiteral, node[1]];
+	},
+	call(ctx, node) {
+		return [
+			NODE.call,
+			obf(ctx, node[1]),
+			node[2].map((node$1) => obf(ctx, node$1))
+		];
+	},
+	memberAccess(ctx, node) {
+		return [
+			NODE.memberAccess,
+			obf(ctx, node[1]),
+			node[2]
+		];
+	},
+	indexAccess(ctx, node) {
+		return [
+			NODE.indexAccess,
+			obf(ctx, node[1]),
+			obf(ctx, node[2])
+		];
+	},
+	return(ctx, node) {
+		return node.length === 1 ? [NODE.return] : [NODE.return, obf(ctx, node[1])];
+	},
+	if(ctx, node) {
+		return node.length === 3 ? [
+			NODE.if,
+			obf(ctx, node[1]),
+			obf(ctx, node[2])
+		] : [
+			NODE.if,
+			obf(ctx, node[1]),
+			obf(ctx, node[2]),
+			obf(ctx, node[3])
+		];
+	},
+	let(ctx, node) {
+		return node.length === 2 ? [NODE.let, obf(ctx, node[1])] : [
+			NODE.let,
+			obf(ctx, node[1]),
+			obf(ctx, node[2])
+		];
+	},
+	const(ctx, node) {
+		return node.length === 2 ? [NODE.const, obf(ctx, node[1])] : [
+			NODE.const,
+			obf(ctx, node[1]),
+			obf(ctx, node[2])
+		];
+	},
+	for(ctx, node) {
+		return [
+			NODE.for,
+			obf(ctx, node[1]),
+			obf(ctx, node[2]),
+			obf(ctx, node[3]),
+			obf(ctx, node[4])
+		];
+	},
+	while(ctx, node) {
+		return [
+			NODE.while,
+			obf(ctx, node[1]),
+			obf(ctx, node[2])
+		];
+	},
+	continue(_ctx, _node) {
+		return [NODE.continue];
+	},
+	break(_ctx, _node) {
+		return [NODE.break];
+	},
+	forOf(ctx, node) {
+		return [
+			NODE.forOf,
+			obf(ctx, node[1]),
+			obf(ctx, node[2]),
+			obf(ctx, node[3])
+		];
+	},
+	arrayExpr(ctx, node) {
+		return [NODE.arrayExpr, node[1].map((node$1) => obf(ctx, node$1))];
+	},
+	preUpdate(ctx, node) {
+		return [
+			NODE.preUpdate,
+			node[1],
+			obf(ctx, node[2])
+		];
+	},
+	postUpdate(ctx, node) {
+		return [
+			NODE.postUpdate,
+			node[1],
+			obf(ctx, node[2])
+		];
+	},
+	stringLiteral(_ctx, node) {
+		return [NODE.stringLiteral, node[1]];
+	},
+	objectExpr(ctx, node) {
+		return [NODE.objectExpr, Object.fromEntries(Object.entries(node[1]).map(([key, value]) => [key, obf(ctx, value)]))];
+	},
+	conditionalExpr(ctx, node) {
+		return [
+			NODE.conditionalExpr,
+			obf(ctx, node[1]),
+			obf(ctx, node[2]),
+			obf(ctx, node[3])
+		];
+	}
+};
+const nodeIdToName = new Map(Object.entries(NODE).map(([key, value]) => [value, key]));
+/**
+* Traverses the AST and generates a new one that is obfuscated.
+* Copies old AST when identifiers cannot appear in a subtree,
+* e.g. in a member access property, or for operator nodes ('=', '<', ...).
+*/
+function obf(ctx, node) {
+	if (node === null) return node;
+	if (typeof node === "string") return ctx.obfuscator.obfuscate(node);
+	if (typeof node === "boolean") return node;
+	const nodeName = nodeIdToName.get(node[0]);
+	if (nodeName === void 0) throw new Error(`Internal error, no name for node type ${node[0]}.`);
+	const visitor = visitors[nodeName];
+	if (!visitor) throw new Error(`Internal error, no visitor for node '${nodeName}'.`);
+	return visitor(ctx, node);
+}
+
+//#endregion
+//#region src/core/common.ts
+/**
+* Each breaking change to the metadata format requires a bump to this number.
+* It's used at runtime by `typegpu` to determine how to interpret a function's metadata.
+*/
+const METADATA_FORMAT_VERSION = 2;
+function checkOpts(opts) {
+	if (opts.unstable_obfuscate && opts.autoNamingEnabled) throw new Error(`Options 'unstable_obfuscate' and 'autoNamingEnabled' cannot be enabled at the same time.`);
+	return opts;
+}
+function initPluginState(state, methods) {
+	var _state$opts$autoNamin;
+	state.tgpuAliases = new Set(state.opts.forceTgpuAlias ? [state.opts.forceTgpuAlias] : []);
+	state.autoNamingEnabled = (_state$opts$autoNamin = state.opts.autoNamingEnabled) !== null && _state$opts$autoNamin !== void 0 ? _state$opts$autoNamin : true;
+	state.inUseGpuScope = false;
+	Object.assign(state, methods);
+}
+/** Regular expressions used for early pruning (to avoid unnecessary parsing, which is expensive) */
+const earlyPruneRegex = [/["']use gpu["']/, /t(ype)?gpu/];
+const defaultOptions = {
+	include: /\.m?[jt]sx?(?:\?.*)?$/,
+	autoNamingEnabled: true,
+	earlyPruning: true,
+	unstable_obfuscate: false
+};
+/**
+* Returns the block scope of a function declaration, if one exists.
+* Used to hoist a function declaration to the top of the scope it's visible in.
+*/
+function getBlockScope(path) {
+	if (!path.node.id) return;
+	const binding = path.scope.getBinding(path.node.id.name);
+	if (!binding) return;
+	let scopePath = binding.scope.path;
+	if (__babel_types.isNode(scopePath.node.body)) scopePath = scopePath.get("body");
+	if (__babel_types.isBlockStatement(scopePath.node) || __babel_types.isProgram(scopePath.node)) return scopePath;
+}
+/**
+* Checks if `node` is an alias for the 'tgpu' object, traditionally
+* available via `import { tgpu } from 'typegpu'`.
+*/
+function isTgpu(state, node) {
+	let path = "";
+	let tail = node;
+	while (true) if (tail.type === "MemberExpression") {
+		if (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 state.tgpuAliases.has(path);
+}
+function gatherTgpuAliases(state, node) {
+	if (node.source.value !== "typegpu") return;
+	for (const spec of node.specifiers) if (spec.type === "ImportDefaultSpecifier" || spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && spec.imported.name === "tgpu") state.tgpuAliases.add(spec.local.name);
+	else if (spec.type === "ImportNamespaceSpecifier") state.tgpuAliases.add(`${spec.local.name}.tgpu`);
+}
+const fnShellFunctionNames = [
+	"fn",
+	"vertexFn",
+	"fragmentFn",
+	"computeFn"
+];
+function isShellImplementationCall(node, state) {
+	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(state, 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(path) {
+	if (path.node.type === "VariableDeclarator" && path.node.id.type === "Identifier" && path.node.init) return [path.node.id.name, path.get("init")];
+	else if (path.node.type === "AssignmentExpression") {
+		const maybeName = tryFindIdentifier(path.node.left);
+		if (maybeName) return [maybeName, path.get("right")];
+	} else if (path.node.type === "ObjectProperty" && path.node.key.type === "Identifier") return [path.node.key.name, path.get("value")];
+	else if (path.node.type === "ClassProperty" && path.node.value && path.node.key.type === "Identifier") return [path.node.key.name, path.get("value")];
+	else if (path.node.type === "ClassPrivateProperty" && path.node.value && path.node.key.type === "PrivateName") return [path.node.key.id.name, path.get("value")];
+}
+function getFunctionName(path) {
+	var _extractLabelledExpre, _path$node$id;
+	const maybeName = path.parentPath ? (_extractLabelledExpre = extractLabelledExpression(path.parentPath)) === null || _extractLabelledExpre === void 0 ? void 0 : _extractLabelledExpre[0] : void 0;
+	return maybeName !== null && maybeName !== void 0 ? maybeName : path.node.type === "FunctionDeclaration" || path.node.type === "FunctionExpression" ? (_path$node$id = path.node.id) === null || _path$node$id === void 0 ? void 0 : _path$node$id.name : void 0;
+}
+const resourceConstructors = [
+	"bindGroupLayout",
+	"vertexLayout",
+	"privateVar",
+	"workgroupVar",
+	"const",
+	"slot",
+	"accessor",
+	"mutableAccessor",
+	"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, state) {
+	if (node.type === "CallExpression") {
+		if (isShellImplementationCall(node, state)) 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, state);
+		}
+	}
+	if (node.type === "TaggedTemplateExpression") return containsResourceConstructorCall(node.tag, state);
+	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 === "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 (but are not limited to):
+*
+* `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(state, path, namingCallback) {
+	if (!state.autoNamingEnabled) return;
+	const labelledExpression = extractLabelledExpression(path);
+	if (labelledExpression) {
+		const [label, expressionPath] = labelledExpression;
+		if (containsResourceConstructorCall(expressionPath.node, state)) namingCallback(expressionPath, label);
+	}
+}
+const operators = {
+	"+": "__tsover_add",
+	"-": "__tsover_sub",
+	"*": "__tsover_mul",
+	"/": "__tsover_div",
+	"%": "__tsover_mod",
+	"+=": "__tsover_add",
+	"-=": "__tsover_sub",
+	"*=": "__tsover_mul",
+	"/=": "__tsover_div",
+	"%=": "__tsover_mod"
+};
+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("use gpu");
+}
+const fnNodeToTranspiledMap = /* @__PURE__ */ new WeakMap();
+function functionOnExit(path, state) {
+	const node = path.node;
+	if (!containsUseGpuDirective(node) || getEmbeddedTypegpuMetadata(path) !== void 0) return;
+	state.inUseGpuScope = false;
+	const ast = fnNodeToTranspiledMap.get(path.node);
+	const maybeName = getFunctionName(path);
+	if (!ast) throw new Error(`No metadata found for function ${maybeName !== null && maybeName !== void 0 ? maybeName : "<unnamed>"}`);
+	state.assignMetadata(path, maybeName, ast);
+	path.skip();
+}
+function transpile(rootNode, obf$1) {
+	const result = (0, tinyest_for_wgsl.transpileFn)(rootNode);
+	if (obf$1) return obfuscate(result);
+	return result;
+}
+const functionVisitor = {
+	ImportDeclaration(path, state) {
+		gatherTgpuAliases(state, path.node);
+	},
+	VariableDeclarator(path, state) {
+		performExpressionNaming(state, path, (pathToName, name) => {
+			state.wrapInAutoName(pathToName, name);
+		});
+	},
+	ObjectProperty(path, state) {
+		performExpressionNaming(state, path, (pathToName, name) => state.wrapInAutoName(pathToName, name));
+	},
+	ClassProperty(path, state) {
+		performExpressionNaming(state, path, (pathToName, name) => state.wrapInAutoName(pathToName, name));
+	},
+	ClassPrivateProperty(path, state) {
+		performExpressionNaming(state, path, (pathToName, name) => state.wrapInAutoName(pathToName, name));
+	},
+	AssignmentExpression: { exit(path, state) {
+		const runtimeFn = operators[path.node.operator];
+		if (state.inUseGpuScope && runtimeFn) state.replaceWithAssignmentOverload(path, runtimeFn);
+		performExpressionNaming(state, path, (pathToName, name) => state.wrapInAutoName(pathToName, name));
+		path.skip();
+	} },
+	BinaryExpression: { exit(path, state) {
+		const runtimeFn = operators[path.node.operator];
+		if (state.inUseGpuScope && runtimeFn) state.replaceWithBinaryOverload(path, runtimeFn);
+		path.skip();
+	} },
+	ArrowFunctionExpression: {
+		enter(path, state) {
+			if (containsUseGpuDirective(path.node) && getEmbeddedTypegpuMetadata(path) === void 0) {
+				fnNodeToTranspiledMap.set(path.node, transpile(path.node, this.opts.unstable_obfuscate));
+				if (state.inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+				state.inUseGpuScope = true;
+			}
+		},
+		exit: functionOnExit
+	},
+	FunctionExpression: {
+		enter(path, state) {
+			if (containsUseGpuDirective(path.node) && getEmbeddedTypegpuMetadata(path) === void 0) {
+				fnNodeToTranspiledMap.set(path.node, transpile(path.node, this.opts.unstable_obfuscate));
+				if (state.inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+				state.inUseGpuScope = true;
+			}
+		},
+		exit: functionOnExit
+	},
+	FunctionDeclaration: {
+		enter(path, state) {
+			if (containsUseGpuDirective(path.node) && getEmbeddedTypegpuMetadata(path) === void 0) {
+				fnNodeToTranspiledMap.set(path.node, transpile(path.node, this.opts.unstable_obfuscate));
+				if (state.inUseGpuScope) throw new Error(`Nesting 'use gpu' functions is not allowed`);
+				state.inUseGpuScope = true;
+			}
+		},
+		exit: functionOnExit
+	},
+	CallExpression: { exit(path, state) {
+		const node = path.node;
+		if (isShellImplementationCall(node, state)) {
+			const implementation = node.arguments[0];
+			if (implementation && (implementation.type === "FunctionExpression" || implementation.type === "ArrowFunctionExpression") && !containsUseGpuDirective(implementation)) state.assignMetadata(path.get("arguments.0"), getFunctionName(path.get("arguments.0")), transpile(implementation, this.opts.unstable_obfuscate));
+		}
+	} }
+};
+
+//#endregion
+Object.defineProperty(exports, 'METADATA_FORMAT_VERSION', {
+  enumerable: true,
+  get: function () {
+    return METADATA_FORMAT_VERSION;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, '_objectSpread2', {
+  enumerable: true,
+  get: function () {
+    return _objectSpread2;
+  }
+});
+Object.defineProperty(exports, 'checkOpts', {
+  enumerable: true,
+  get: function () {
+    return checkOpts;
+  }
+});
+Object.defineProperty(exports, 'defaultOptions', {
+  enumerable: true,
+  get: function () {
+    return defaultOptions;
+  }
+});
+Object.defineProperty(exports, 'earlyPruneRegex', {
+  enumerable: true,
+  get: function () {
+    return earlyPruneRegex;
+  }
+});
+Object.defineProperty(exports, 'functionVisitor', {
+  enumerable: true,
+  get: function () {
+    return functionVisitor;
+  }
+});
+Object.defineProperty(exports, 'getBlockScope', {
+  enumerable: true,
+  get: function () {
+    return getBlockScope;
+  }
+});
+Object.defineProperty(exports, 'initPluginState', {
+  enumerable: true,
+  get: function () {
+    return initPluginState;
+  }
+});