unplugin-typegpu 0.10.2 → 0.11.1

package/common-CElmMmuq.js

@@ -0,0 +1,279 @@
+import { transpileFn } from "tinyest-for-wgsl";
+import * as t from "@babel/types";
+import { MagicStringAST } from "magic-string-ast";
+
+//#region src/core/polyfill-process.ts
+if (typeof globalThis.process === "undefined") globalThis.process = {};
+if (typeof globalThis.process.env === "undefined") globalThis.process.env = {};
+
+//#endregion
+//#region src/core/common.ts
+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;
+	state.alreadyTransformed = /* @__PURE__ */ new WeakSet();
+	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
+};
+/**
+* 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 (t.isNode(scopePath.node.body)) scopePath = scopePath.get("body");
+	if (t.isBlockStatement(scopePath.node) || t.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")];
+}
+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:
+*
+* `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)) return;
+	state.inUseGpuScope = false;
+	if (state.alreadyTransformed.has(node)) return;
+	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);
+	state.alreadyTransformed.add(node);
+	path.skip();
+}
+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));
+	},
+	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)) {
+				fnNodeToTranspiledMap.set(path.node, transpileFn(path.node));
+				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)) {
+				fnNodeToTranspiledMap.set(path.node, transpileFn(path.node));
+				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)) {
+				fnNodeToTranspiledMap.set(path.node, transpileFn(path.node));
+				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")), transpileFn(implementation));
+		}
+	} }
+};
+
+//#endregion
+export { initPluginState as a, getBlockScope as i, earlyPruneRegex as n, t as o, functionVisitor as r, defaultOptions as t };

package/common-DZ2cLtbe.d.cts

@@ -0,0 +1,84 @@
+import { NodePath } from "@babel/traverse";
+import * as t from "@babel/types";
+import { FilterPattern } from "unplugin";
+import { transpileFn } from "tinyest-for-wgsl";
+
+//#region src/core/common.d.ts
+interface Options {
+  /** @default [/\.m?[jt]sx?$/] */
+  include?: FilterPattern;
+  /** @default undefined */
+  exclude?: FilterPattern;
+  /** @default undefined */
+  enforce?: 'post' | 'pre' | undefined;
+  /** @default undefined */
+  forceTgpuAlias?: string | undefined;
+  /** @default true */
+  autoNamingEnabled?: boolean | undefined;
+  /**
+   * Skipping files that don't contain "typegpu", "tgpu" or "use gpu".
+   * In case this early pruning hinders transformation, you
+   * can disable it.
+   *
+   * @default true
+   */
+  earlyPruning?: boolean | undefined;
+}
+type MetadatableFunction = t.FunctionDeclaration | t.FunctionExpression | t.ArrowFunctionExpression;
+interface TransformMethods {
+  warn(message: string): void;
+  /**
+   * For function statements to have metadata assigned, they first have to be manually hoisted
+   * to the top of their scope, then replaced with a variable declaration.
+   *
+   * @example
+   * ```ts
+   * const value = mod(13, 10);
+   * function mod(a: number, b: number): number {
+   *   'use gpu';
+   *   return a % b;
+   * }
+   * ```
+   *
+   * Should be transformed to:
+   *
+   * ```ts
+   * const mod = (a: number, b: number): number => {
+   *   'use gpu';
+   *   return a % b;
+   * };
+   * const value = mod(13, 10);
+   * ```
+   *
+   * Note that named function expressions aren't hoisted, so they don't pose a problem.
+   * ```ts
+   * double(2); // Uncaught ReferenceError: double is not defined
+   * console.log(function double(a) { return a * 2; });
+   * ```
+   */
+  assignMetadata(this: PluginState, path: NodePath<MetadatableFunction>, name: string | undefined, ast: ReturnType<typeof transpileFn>): void;
+  wrapInAutoName(this: PluginState, path: NodePath<t.Expression>, name: string): void;
+  replaceWithAssignmentOverload(path: NodePath<t.AssignmentExpression>, runtimeFn: string): void;
+  replaceWithBinaryOverload(path: NodePath<t.BinaryExpression>, runtimeFn: string): void;
+}
+interface PluginState extends TransformMethods {
+  /**
+   * How the `tgpu` object is used in code. Since it can be aliased, we
+   * need to catch that and act accordingly.
+   */
+  tgpuAliases: Set<string>;
+  autoNamingEnabled: boolean;
+  /**
+   * Populated by Babel
+   */
+  filename?: string | undefined;
+  /**
+   * In Babel, options are assigned to the property `opts` on the plugin state.
+   * We use this pattern everywhere for consistency.
+   */
+  opts: Options;
+  inUseGpuScope: boolean;
+  alreadyTransformed: WeakSet<t.Node>;
+}
+//#endregion
+export { PluginState as n, t as r, Options as t };

package/esbuild.cjs

@@ -1,8 +1,11 @@
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-const require_index = require('./index.cjs');
+Object.defineProperty(exports, '__esModule', { value: true });
+require('./common-BoeQmwpt.cjs');
+require('./babel-Dis-Pwfu.cjs');
+require('./bun-DCACcaN2.cjs');
+const require_src = require('./src-bIj7OBnd.cjs');
 
 //#region src/esbuild.ts
-var esbuild_default = require_index.esbuildPlugin;
+var esbuild_default = require_src.esbuildPlugin;
 
 //#endregion
 exports.default = esbuild_default;

package/esbuild.d.cts

@@ -1,2 +1,5 @@
-import { esbuildPlugin } from "./index.cjs";
+import "./common-DZ2cLtbe.cjs";
+import "./babel-C8UzthFd.cjs";
+import "./bun-cwXs2EDP.cjs";
+import { t as esbuildPlugin } from "./index-COIv1oYx.cjs";
 export = esbuildPlugin;

package/esbuild.d.ts

@@ -0,0 +1,5 @@
+import "./common-BlvLUwEz.js";
+import "./babel-CmCnq-43.js";
+import "./bun-ovScJ4Es.js";
+import { t as esbuildPlugin } from "./index-PPreQbn5.js";
+export { esbuildPlugin as default };

package/esbuild.js

@@ -0,0 +1,10 @@
+import "./common-CElmMmuq.js";
+import "./babel-CbManzjz.js";
+import "./bun-CDECNeIU.js";
+import { t as esbuildPlugin } from "./src-D84rmPxv.js";
+
+//#region src/esbuild.ts
+var esbuild_default = esbuildPlugin;
+
+//#endregion
+export { esbuild_default as default };

package/farm.cjs

@@ -1,8 +1,11 @@
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-const require_index = require('./index.cjs');
+Object.defineProperty(exports, '__esModule', { value: true });
+require('./common-BoeQmwpt.cjs');
+require('./babel-Dis-Pwfu.cjs');
+require('./bun-DCACcaN2.cjs');
+const require_src = require('./src-bIj7OBnd.cjs');
 
 //#region src/farm.ts
-var farm_default = require_index.farmPlugin;
+var farm_default = require_src.farmPlugin;
 
 //#endregion
 exports.default = farm_default;

package/farm.d.cts

@@ -1,2 +1,5 @@
-import { farmPlugin } from "./index.cjs";
+import "./common-DZ2cLtbe.cjs";
+import "./babel-C8UzthFd.cjs";
+import "./bun-cwXs2EDP.cjs";
+import { n as farmPlugin } from "./index-COIv1oYx.cjs";
 export = farmPlugin;

package/farm.d.ts

@@ -0,0 +1,5 @@
+import "./common-BlvLUwEz.js";
+import "./babel-CmCnq-43.js";
+import "./bun-ovScJ4Es.js";
+import { n as farmPlugin } from "./index-PPreQbn5.js";
+export { farmPlugin as default };

package/farm.js

@@ -0,0 +1,10 @@
+import "./common-CElmMmuq.js";
+import "./babel-CbManzjz.js";
+import "./bun-CDECNeIU.js";
+import { n as farmPlugin } from "./src-D84rmPxv.js";
+
+//#region src/farm.ts
+var farm_default = farmPlugin;
+
+//#endregion
+export { farm_default as default };

package/index-COIv1oYx.d.cts

@@ -0,0 +1,48 @@
+import { t as Options } from "./common-DZ2cLtbe.cjs";
+import * as unplugin8 from "unplugin";
+import * as magic_string_ast0 from "magic-string-ast";
+
+//#region src/rolldown-browser.d.ts
+declare const _default$1: (options?: Options) => {
+  name: "unplugin-typegpu";
+  enforce: "post" | "pre" | undefined;
+  transform: {
+    filter: {
+      id: Omit<Options, "include" | "autoNamingEnabled" | "earlyPruning"> & Omit<{
+        include: RegExp;
+        autoNamingEnabled: boolean;
+        earlyPruning: boolean;
+      }, "include" | "autoNamingEnabled" | "earlyPruning"> & {
+        include: string | RegExp | unplugin8.StringOrRegExp[];
+        autoNamingEnabled: boolean;
+        earlyPruning: boolean;
+      };
+      code: RegExp[];
+    } | {
+      id: Omit<Options, "include" | "autoNamingEnabled" | "earlyPruning"> & Omit<{
+        include: RegExp;
+        autoNamingEnabled: boolean;
+        earlyPruning: boolean;
+      }, "include" | "autoNamingEnabled" | "earlyPruning"> & {
+        include: string | RegExp | unplugin8.StringOrRegExp[];
+        autoNamingEnabled: boolean;
+        earlyPruning: boolean;
+      };
+      code?: never;
+    };
+    handler(this: unplugin8.UnpluginBuildContext & unplugin8.UnpluginContext, code: string, id: string): magic_string_ast0.CodeTransform | undefined;
+  };
+};
+//#endregion
+//#region src/index.d.ts
+declare const typegpu: unplugin8.UnpluginInstance<Options | undefined, boolean>;
+declare const vitePlugin: (options?: Options | undefined) => unplugin8.VitePlugin<any> | unplugin8.VitePlugin<any>[];
+declare const rollupPlugin: (options?: Options | undefined) => unplugin8.RollupPlugin<any> | unplugin8.RollupPlugin<any>[];
+declare const rolldownPlugin: (options?: Options | undefined) => unplugin8.RolldownPlugin<any> | unplugin8.RolldownPlugin<any>[];
+declare const webpackPlugin: (options?: Options | undefined) => unplugin8.WebpackPluginInstance;
+declare const rspackPlugin: (options?: Options | undefined) => RspackPluginInstance;
+declare const esbuildPlugin: (options?: Options | undefined) => unplugin8.EsbuildPlugin;
+declare const farmPlugin: (options?: Options | undefined) => JsPlugin;
+declare const unloaderPlugin: (options?: Options | undefined) => any;
+//#endregion
+export { rspackPlugin as a, vitePlugin as c, rollupPlugin as i, webpackPlugin as l, farmPlugin as n, typegpu as o, rolldownPlugin as r, unloaderPlugin as s, esbuildPlugin as t, _default$1 as u };

package/index-PPreQbn5.d.ts

@@ -0,0 +1,48 @@
+import { t as Options } from "./common-BlvLUwEz.js";
+import * as magic_string_ast0 from "magic-string-ast";
+import * as unplugin8 from "unplugin";
+
+//#region src/rolldown-browser.d.ts
+declare const _default$1: (options?: Options) => {
+  name: "unplugin-typegpu";
+  enforce: "post" | "pre" | undefined;
+  transform: {
+    filter: {
+      id: Omit<Options, "include" | "autoNamingEnabled" | "earlyPruning"> & Omit<{
+        include: RegExp;
+        autoNamingEnabled: boolean;
+        earlyPruning: boolean;
+      }, "include" | "autoNamingEnabled" | "earlyPruning"> & {
+        include: string | RegExp | unplugin8.StringOrRegExp[];
+        autoNamingEnabled: boolean;
+        earlyPruning: boolean;
+      };
+      code: RegExp[];
+    } | {
+      id: Omit<Options, "include" | "autoNamingEnabled" | "earlyPruning"> & Omit<{
+        include: RegExp;
+        autoNamingEnabled: boolean;
+        earlyPruning: boolean;
+      }, "include" | "autoNamingEnabled" | "earlyPruning"> & {
+        include: string | RegExp | unplugin8.StringOrRegExp[];
+        autoNamingEnabled: boolean;
+        earlyPruning: boolean;
+      };
+      code?: never;
+    };
+    handler(this: unplugin8.UnpluginBuildContext & unplugin8.UnpluginContext, code: string, id: string): magic_string_ast0.CodeTransform | undefined;
+  };
+};
+//#endregion
+//#region src/index.d.ts
+declare const typegpu: unplugin8.UnpluginInstance<Options | undefined, boolean>;
+declare const vitePlugin: (options?: Options | undefined) => unplugin8.VitePlugin<any> | unplugin8.VitePlugin<any>[];
+declare const rollupPlugin: (options?: Options | undefined) => unplugin8.RollupPlugin<any> | unplugin8.RollupPlugin<any>[];
+declare const rolldownPlugin: (options?: Options | undefined) => unplugin8.RolldownPlugin<any> | unplugin8.RolldownPlugin<any>[];
+declare const webpackPlugin: (options?: Options | undefined) => unplugin8.WebpackPluginInstance;
+declare const rspackPlugin: (options?: Options | undefined) => RspackPluginInstance;
+declare const esbuildPlugin: (options?: Options | undefined) => unplugin8.EsbuildPlugin;
+declare const farmPlugin: (options?: Options | undefined) => JsPlugin;
+declare const unloaderPlugin: (options?: Options | undefined) => any;
+//#endregion
+export { rspackPlugin as a, vitePlugin as c, rollupPlugin as i, webpackPlugin as l, farmPlugin as n, typegpu as o, rolldownPlugin as r, unloaderPlugin as s, esbuildPlugin as t, _default$1 as u };

package/index.cjs

@@ -1,29 +1,18 @@
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-const require_filter = require('./filter-CKmD4HRk.cjs');
-const require_rolldown_browser = require('./rolldown-browser-DUanNY-R.cjs');
-const require_babel = require('./babel.cjs');
-const require_bun = require('./bun.cjs');
-let unplugin = require("unplugin");
+Object.defineProperty(exports, '__esModule', { value: true });
+require('./common-BoeQmwpt.cjs');
+const require_babel = require('./babel-Dis-Pwfu.cjs');
+const require_bun = require('./bun-DCACcaN2.cjs');
+const require_src = require('./src-bIj7OBnd.cjs');
 
-//#region src/index.ts
-const typegpu = (0, unplugin.createUnplugin)(require_rolldown_browser.rollUpImpl);
-const vitePlugin = typegpu.vite;
-const rollupPlugin = typegpu.rollup;
-const rolldownPlugin = typegpu.rolldown;
-const webpackPlugin = typegpu.webpack;
-const rspackPlugin = typegpu.rspack;
-const esbuildPlugin = typegpu.esbuild;
-const farmPlugin = typegpu.farm;
-
-//#endregion
-exports.babelPlugin = require_babel.default;
-exports.bunPlugin = require_bun.default;
-exports.default = typegpu;
-exports.esbuildPlugin = esbuildPlugin;
-exports.farmPlugin = farmPlugin;
-exports.rolldownBrowserPlugin = require_rolldown_browser.rolldown_browser_default;
-exports.rolldownPlugin = rolldownPlugin;
-exports.rollupPlugin = rollupPlugin;
-exports.rspackPlugin = rspackPlugin;
-exports.vitePlugin = vitePlugin;
-exports.webpackPlugin = webpackPlugin;
+exports.babelPlugin = require_babel.TypeGPUPlugin;
+exports.bunPlugin = require_bun.bun_default;
+exports.default = require_src.src_default;
+exports.esbuildPlugin = require_src.esbuildPlugin;
+exports.farmPlugin = require_src.farmPlugin;
+exports.rolldownBrowserPlugin = require_src.rolldown_browser_default;
+exports.rolldownPlugin = require_src.rolldownPlugin;
+exports.rollupPlugin = require_src.rollupPlugin;
+exports.rspackPlugin = require_src.rspackPlugin;
+exports.unloaderPlugin = require_src.unloaderPlugin;
+exports.vitePlugin = require_src.vitePlugin;
+exports.webpackPlugin = require_src.webpackPlugin;

package/index.d.cts

@@ -1,17 +1,5 @@
-import export_default from "./babel.cjs";
-import { t as Options } from "./common-Dpl8jppn.cjs";
-import _default from "./bun.cjs";
-import { n as Plugin, t as rollUpImpl } from "./rollup-impl-DqC_d-_W.cjs";
-import * as unplugin from "unplugin";
-
-//#region src/index.d.ts
-declare const typegpu: unplugin.UnpluginInstance<Options, boolean>;
-declare const vitePlugin: (options: Options) => unplugin.VitePlugin<any> | unplugin.VitePlugin<any>[];
-declare const rollupPlugin: (options: Options) => Plugin<any> | Plugin<any>[];
-declare const rolldownPlugin: (options: Options) => unplugin.RolldownPlugin<any> | unplugin.RolldownPlugin<any>[];
-declare const webpackPlugin: (options: Options) => unplugin.WebpackPluginInstance;
-declare const rspackPlugin: (options: Options) => RspackPluginInstance;
-declare const esbuildPlugin: (options: Options) => unplugin.EsbuildPlugin;
-declare const farmPlugin: (options: Options) => JsPlugin;
-//#endregion
-export { type Options, export_default as babelPlugin, _default as bunPlugin, typegpu as default, esbuildPlugin, farmPlugin, rollUpImpl as rolldownBrowserPlugin, rolldownPlugin, rollupPlugin, rspackPlugin, vitePlugin, webpackPlugin };
+import { t as Options } from "./common-DZ2cLtbe.cjs";
+import { t as TypeGPUPlugin } from "./babel-C8UzthFd.cjs";
+import { t as _default } from "./bun-cwXs2EDP.cjs";
+import { a as rspackPlugin, c as vitePlugin, i as rollupPlugin, l as webpackPlugin, n as farmPlugin, o as typegpu, r as rolldownPlugin, s as unloaderPlugin, t as esbuildPlugin, u as _default$1 } from "./index-COIv1oYx.cjs";
+export { Options, TypeGPUPlugin as babelPlugin, _default as bunPlugin, typegpu as default, esbuildPlugin, farmPlugin, _default$1 as rolldownBrowserPlugin, rolldownPlugin, rollupPlugin, rspackPlugin, unloaderPlugin, vitePlugin, webpackPlugin };

package/index.d.ts

@@ -0,0 +1,5 @@
+import { t as Options } from "./common-BlvLUwEz.js";
+import { t as TypeGPUPlugin } from "./babel-CmCnq-43.js";
+import { t as _default } from "./bun-ovScJ4Es.js";
+import { a as rspackPlugin, c as vitePlugin, i as rollupPlugin, l as webpackPlugin, n as farmPlugin, o as typegpu, r as rolldownPlugin, s as unloaderPlugin, t as esbuildPlugin, u as _default$1 } from "./index-PPreQbn5.js";
+export { Options, TypeGPUPlugin as babelPlugin, _default as bunPlugin, typegpu as default, esbuildPlugin, farmPlugin, _default$1 as rolldownBrowserPlugin, rolldownPlugin, rollupPlugin, rspackPlugin, unloaderPlugin, vitePlugin, webpackPlugin };

package/index.js

@@ -0,0 +1,6 @@
+import "./common-CElmMmuq.js";
+import { t as TypeGPUPlugin } from "./babel-CbManzjz.js";
+import { t as bun_default } from "./bun-CDECNeIU.js";
+import { a as rspackPlugin, c as vitePlugin, i as rollupPlugin, l as webpackPlugin, n as farmPlugin, o as src_default, r as rolldownPlugin, s as unloaderPlugin, t as esbuildPlugin, u as rolldown_browser_default } from "./src-D84rmPxv.js";
+
+export { TypeGPUPlugin as babelPlugin, bun_default as bunPlugin, src_default as default, esbuildPlugin, farmPlugin, rolldown_browser_default as rolldownBrowserPlugin, rolldownPlugin, rollupPlugin, rspackPlugin, unloaderPlugin, vitePlugin, webpackPlugin };