typegpu 0.11.1 → 0.11.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",

package/resolutionCtx.d.ts

@@ -1,6 +1,17 @@
+import "./data/snippet.js";
+import "./tgsl/shellless.js";
 import { LogResources } from "./tgsl/consoleLog/types.js";
+import "./core/slot/slotTypes.js";
 import { TgpuBindGroup, TgpuBindGroupLayout } from "./tgpuBindGroupLayout.js";
+import "./tgsl/shaderGenerator.js";
+import "./core/root/rootTypes.js";
+import "./types.js";
+import "./data/wgslTypes.js";
+import "./data/dataTypes.js";
+import "./core/resolve/namespace.js";
+
 //#region src/resolutionCtx.d.ts
+
 /**
  * The results of a WGSL resolution.
  *

package/resolutionCtx.js

@@ -1,7 +1,7 @@
 import { $internal, $providing, $resolve, isMarkedInternal } from "./shared/symbols.js";
 import { getName, hasTinyestMetadata, setName } from "./shared/meta.js";
 import { Void, isPtr, isWgslArray, isWgslStruct } from "./data/wgslTypes.js";
-import { UnknownData, isData, undecorate } from "./data/dataTypes.js";
+import { UnknownData, isData } from "./data/dataTypes.js";
 import { snip } from "./data/snippet.js";
 import { MissingSlotValueError, ResolutionError, WgslTypeError, invariant } from "./errors.js";
 import { isLazy, isProviding, isSlot } from "./core/slot/slotTypes.js";
@@ -12,7 +12,6 @@ import { safeStringify } from "./shared/stringify.js";
 import { getBestConversion } from "./tgsl/conversion.js";
 import { bool } from "./data/numeric.js";
 import { coerceToSnippet, concretize, numericLiteralToSnippet } from "./tgsl/generationHelpers.js";
-import { getAttributesString } from "./data/attributes.js";
 import { createIoSchema } from "./core/function/ioSchema.js";
 import { AutoStruct } from "./data/autoStruct.js";
 import { EntryInputRouter } from "./core/function/entryInputRouter.js";
@@ -23,8 +22,9 @@ import { ConfigurableImpl } from "./core/root/configurableImpl.js";
 import { naturalsExcept } from "./shared/generators.js";
 import { TgpuBindGroupImpl, bindGroupLayout } from "./tgpuBindGroupLayout.js";
 import { LogGeneratorImpl, LogGeneratorNullImpl } from "./tgsl/consoleLog/logGenerator.js";
-import wgslGenerator from "./tgsl/wgslGenerator.js";
+import wgslGenerator_default from "./tgsl/wgslGenerator.js";
 import { FuncParameterType } from "tinyest";
+
 //#region src/resolutionCtx.ts
 /**
 * Inserted into bind group entry definitions that belong
@@ -63,12 +63,11 @@ var ItemStateStackImpl = class {
 			bindingMap: new WeakMap(pairs)
 		});
 	}
-	pushFunctionScope(functionType, args, argAliases, returnType, externalMap) {
+	pushFunctionScope(functionType, argAccess, returnType, externalMap) {
 		const scope = {
 			type: "functionScope",
 			functionType,
-			args,
-			argAliases,
+			argAccess,
 			returnType,
 			externalMap,
 			reportedReturnTypes: /* @__PURE__ */ new Set()
@@ -105,9 +104,8 @@ var ItemStateStackImpl = class {
 		for (let i = this._stack.length - 1; i >= 0; --i) {
 			const layer = this._stack[i];
 			if (layer?.type === "functionScope") {
-				const arg = layer.args.find((a) => a.value === id);
-				if (arg !== void 0) return arg;
-				if (layer.argAliases[id]) return layer.argAliases[id];
+				const access = layer.argAccess[id];
+				if (access) return access();
 				const external = layer.externalMap[id];
 				if (external !== void 0 && external !== null) return coerceToSnippet(external);
 				return;
@@ -188,6 +186,27 @@ var IndentController = class {
 		}
 	}
 };
+function createArgument(name, type, origin = "argument") {
+	let used = false;
+	return {
+		name,
+		access: () => {
+			used = true;
+			return snip(name, type, origin);
+		},
+		decoratedType: type,
+		get used() {
+			return used;
+		}
+	};
+}
+function createArgumentPropAccess(argAccess, prop) {
+	return () => {
+		const argSnippet = argAccess();
+		if (!argSnippet) return;
+		return accessProp(argSnippet, prop);
+	};
+}
 var ResolutionCtxImpl = class {
 	#namespaceInternal;
 	_indentController = new IndentController();
@@ -215,7 +234,7 @@ var ResolutionCtxImpl = class {
 	expectedType;
 	constructor(opts) {
 		this.enableExtensions = opts.enableExtensions;
-		this.gen = opts.shaderGenerator ?? wgslGenerator;
+		this.gen = opts.shaderGenerator ?? wgslGenerator_default;
 		this.#logGenerator = opts.root ? new LogGeneratorImpl(opts.root) : new LogGeneratorNullImpl();
 		this.#namespaceInternal = opts.namespace[$internal];
 	}
@@ -286,107 +305,93 @@ var ResolutionCtxImpl = class {
 		try {
 			this.#namespaceInternal.nameRegistry.pushFunctionScope();
 			const args = [];
-			const argAliases = [];
-			const pendingHeaderEntries = [];
+			const argAccess = {};
 			if (options.entryInput) {
 				const { dataSchema, positionalArgs } = options.entryInput;
 				const firstParam = options.params[0];
-				const structArgName = this.makeNameValid("_arg_0");
-				const structArg = dataSchema ? snip(structArgName, dataSchema, "argument") : void 0;
-				if (structArg) {
-					args.push(structArg);
-					pendingHeaderEntries.push({
-						argName: structArgName,
-						header: `${structArgName}: ${this.resolve(dataSchema).value}`
-					});
-				}
+				const structArg = dataSchema ? createArgument(this.makeNameValid("_arg_0"), dataSchema) : void 0;
+				if (structArg) args.push(structArg);
 				if (firstParam?.type === FuncParameterType.destructuredObject) for (const { name, alias } of firstParam.props) {
 					const argInfo = positionalArgs.find((a) => a.schemaKey === name);
 					if (argInfo) {
-						const argName = this.makeNameValid(alias);
-						const argSnippet = snip(argName, argInfo.type, "argument");
-						args.push(argSnippet);
-						argAliases.push([alias, argSnippet]);
-						pendingHeaderEntries.push({
-							argName,
-							header: `${getAttributesString(argInfo.type)}${argName}: ${this.resolve(undecorate(argInfo.type)).value}`
-						});
-					} else if (structArg) {
-						const propSnippet = accessProp(structArg, name);
-						if (propSnippet) argAliases.push([alias, propSnippet]);
-					}
+						const arg = createArgument(this.makeNameValid(alias), argInfo.type);
+						args.push(arg);
+						argAccess[alias] = arg.access;
+					} else if (structArg) argAccess[alias] = createArgumentPropAccess(structArg.access, name);
 				}
 				else if (firstParam?.type === FuncParameterType.identifier) {
 					const proxyEntries = [];
 					for (const a of positionalArgs) {
-						const argName = this.makeNameValid(`_arg_${a.schemaKey}`);
-						const s = snip(argName, a.type, "argument");
-						args.push(s);
+						const arg = createArgument(this.makeNameValid(`_arg_${a.schemaKey}`), a.type);
+						args.push(arg);
 						proxyEntries.push({
 							schemaKey: a.schemaKey,
-							argName,
-							type: a.type
-						});
-						pendingHeaderEntries.push({
-							argName,
-							header: `${getAttributesString(a.type)}${argName}: ${this.resolve(undecorate(a.type)).value}`
+							arg: arg.access
 						});
 					}
-					const router = new EntryInputRouter(structArgName, dataSchema, proxyEntries);
-					argAliases.push([firstParam.name, snip(firstParam.name, router, "argument")]);
+					const router = new EntryInputRouter(structArg?.access, proxyEntries);
+					argAccess[firstParam.name] = () => snip("N/A", router, "argument");
 				} else for (const a of positionalArgs) {
 					const argName = this.makeNameValid(`_arg_${a.schemaKey}`);
-					args.push(snip(argName, a.type, "argument"));
-					pendingHeaderEntries.push({
-						argName,
-						header: `${getAttributesString(a.type)}${argName}: ${this.resolve(undecorate(a.type)).value}`
-					});
+					const arg = createArgument(argName, a.type);
+					args.push(arg);
+					argAccess[argName] = arg.access;
 				}
 			} else for (const [i, argType] of options.argTypes.entries()) {
 				const astParam = options.params[i];
 				const origin = isPtr(argType) ? argType.addressSpace === "storage" ? argType.access === "read" ? "readonly" : "mutable" : argType.addressSpace : "argument";
 				switch (astParam?.type) {
 					case FuncParameterType.identifier: {
-						const rawName = astParam.name;
-						const snippet = snip(this.makeNameValid(rawName), argType, origin);
-						args.push(snippet);
-						if (snippet.value !== rawName) argAliases.push([rawName, snippet]);
+						const arg = createArgument(this.makeNameValid(astParam.name), argType, origin);
+						args.push(arg);
+						argAccess[astParam.name] = arg.access;
 						break;
 					}
 					case FuncParameterType.destructuredObject: {
-						const objSnippet = snip(`_arg_${i}`, argType, origin);
-						args.push(objSnippet);
-						argAliases.push(...astParam.props.map(({ name, alias }) => [alias, accessProp(objSnippet, name)]));
+						const objArg = createArgument(this.makeNameValid(`_arg_${i}`), argType, origin);
+						args.push(objArg);
+						for (const { name, alias } of astParam.props) argAccess[alias] = createArgumentPropAccess(objArg.access, name);
 						break;
 					}
-					case void 0: if (!(argType instanceof AutoStruct)) args.push(snip(`_arg_${i}`, argType, origin));
+					case void 0: if (!(argType instanceof AutoStruct)) args.push({
+						name: this.makeNameValid(`_arg_${i}`),
+						access: () => {
+							throw new Error(`Unreachable: Accessing an argument that wasn't named in the function signature`);
+						},
+						decoratedType: argType,
+						used: false
+					});
 				}
 			}
-			const scope = this._itemStateStack.pushFunctionScope(options.functionType, args, Object.fromEntries(argAliases), options.returnType, options.externalMap);
+			const scope = this._itemStateStack.pushFunctionScope(options.functionType, argAccess, options.returnType, options.externalMap);
 			fnScopePushed = true;
-			const body = this.gen.functionDefinition(options.body);
-			let returnType = options.returnType;
-			if (returnType instanceof AutoStruct) if (isWgslStruct(scope.reportedReturnTypes.values().next().value)) returnType = returnType.completeStruct;
-			else returnType = void 0;
-			if (!returnType) {
-				const returnTypes = [...scope.reportedReturnTypes];
-				if (returnTypes.length === 0) returnType = Void;
-				else {
-					const conversion = getBestConversion(returnTypes);
-					if (conversion && !conversion.hasImplicitConversions) returnType = conversion.targetType;
+			let returnType;
+			const code = this.gen.functionDefinition({
+				functionType: options.functionType,
+				args,
+				body: options.body,
+				determineReturnType: () => {
+					if (returnType) return returnType;
+					returnType = options.returnType;
+					if (returnType instanceof AutoStruct) if (isWgslStruct(scope.reportedReturnTypes.values().next().value)) returnType = returnType.completeStruct;
+					else returnType = void 0;
+					if (!returnType) {
+						const returnTypes = [...scope.reportedReturnTypes];
+						if (returnTypes.length === 0) returnType = Void;
+						else {
+							const conversion = getBestConversion(returnTypes);
+							if (conversion && !conversion.hasImplicitConversions) returnType = conversion.targetType;
+						}
+						if (!returnType) throw new Error(`Expected function to have a single return type, got [${returnTypes.join(", ")}]. Cast explicitly to the desired type.`);
+						returnType = concretize(returnType);
+						if (options.functionType === "vertex" || options.functionType === "fragment") returnType = createIoSchema(returnType);
+					}
+					return returnType;
 				}
-				if (!returnType) throw new Error(`Expected function to have a single return type, got [${returnTypes.join(", ")}]. Cast explicitly to the desired type.`);
-				returnType = concretize(returnType);
-				if (options.functionType === "vertex" || options.functionType === "fragment") returnType = createIoSchema(returnType);
-			}
-			if (options.entryInput) return {
-				head: `(${pendingHeaderEntries.filter(({ argName }) => isArgUsedInBody(argName, body)).map(({ header }) => header).join(", ")}) ${returnType.type !== "void" ? `-> ${getAttributesString(returnType)}${this.resolve(returnType).value} ` : ""}`,
-				body,
-				returnType
-			};
+			});
+			if (!returnType) throw new Error(`Failed to determine return type`);
 			return {
-				head: resolveFunctionHeader(this, args, returnType),
-				body,
+				code,
 				returnType
 			};
 		} finally {
@@ -601,12 +606,6 @@ function resolve(item, options) {
 		logResources: ctx.logResources
 	};
 }
-function isArgUsedInBody(argName, body) {
-	return new RegExp(`\\b${argName}\\b`).test(body);
-}
-function resolveFunctionHeader(ctx, args, returnType) {
-	const argList = args.map((arg) => `${arg.value}: ${ctx.resolve(arg.dataType).value}`).join(", ");
-	return returnType.type !== "void" ? `(${argList}) -> ${getAttributesString(returnType)}${ctx.resolve(returnType).value} ` : `(${argList}) `;
-}
+
 //#endregion
-export { ResolutionCtxImpl, resolve };
+export { ResolutionCtxImpl, resolve };

package/shared/env.js

@@ -8,5 +8,6 @@
 */
 const DEV = process.env.NODE_ENV === "development";
 const TEST = process.env.NODE_ENV === "test";
+
 //#endregion
-export { DEV, TEST };
+export { DEV, TEST };

package/shared/generators.js

@@ -9,5 +9,6 @@ function* naturalsExcept(excluded) {
 		next++;
 	}
 }
+
 //#endregion
-export { naturalsExcept };
+export { naturalsExcept };

package/shared/meta.js

@@ -1,6 +1,7 @@
 import { version } from "../package.js";
 import { DEV, TEST } from "./env.js";
 import { $getNameForward, isMarkedInternal } from "./symbols.js";
+
 //#region src/shared/meta.ts
 const globalWithMeta = globalThis;
 if (globalWithMeta.__TYPEGPU_VERSION__ !== void 0) console.warn(`Found duplicate TypeGPU version. First was ${globalWithMeta.__TYPEGPU_VERSION__}, this one is ${version}. This may cause unexpected behavior.`);
@@ -57,5 +58,6 @@ function setMetaData(definition, metaData) {
 		...metaData
 	});
 }
+
 //#endregion
-export { PERF, getMetaData, getName, hasTinyestMetadata, isNamable, setName };
+export { PERF, getMetaData, getName, hasTinyestMetadata, isNamable, setName };

package/shared/repr.d.ts

@@ -7,6 +7,7 @@ import { TgpuTexture } from "../core/texture/texture.js";
 import { Disarray, Undecorate } from "../data/dataTypes.js";
 
 //#region src/shared/repr.d.ts
+
 /**
  * Extracts the inferred representation of a resource.
  * For inferring types as seen by the GPU, see {@link InferGPU}

package/shared/stringify.js

@@ -1,4 +1,5 @@
 import { isMatInstance, isVecInstance } from "../data/wgslTypes.js";
+
 //#region src/shared/stringify.ts
 function safeStringify(item) {
 	const asString = String(item);
@@ -16,5 +17,6 @@ function niceStringify(item) {
 	if (item && typeof item === "object") return `{ ${Object.entries(item).map(([key, value]) => `${key}: ${niceStringify(value)}`).join(", ")} }`;
 	return String(item);
 }
+
 //#endregion
-export { niceStringify, safeStringify };
+export { niceStringify, safeStringify };

package/shared/symbols.js

@@ -1,4 +1,5 @@
 import { version } from "../package.js";
+
 //#region src/shared/symbols.ts
 const $internal = Symbol(`typegpu:${version}:$internal`);
 /**
@@ -32,17 +33,48 @@ const $gpuCallable = Symbol(`typegpu:${version}:$gpuCallable`);
 * Type token for the inferred (CPU & GPU) representation of a resource
 */
 const $repr = Symbol(`typegpu:${version}:$repr`);
-Symbol(`typegpu:${version}:$gpuRepr`);
-Symbol(`typegpu:${version}:$reprPartial`);
-Symbol(`typegpu:${version}:$reprPatch`);
-Symbol(`typegpu:${version}:$inRepr`);
-Symbol(`typegpu:${version}:$memIdent`);
-Symbol(`typegpu:${version}:$invalidStorageSchema`);
-Symbol(`typegpu:${version}:$validUniformSchema`);
-Symbol(`typegpu:${version}:$validVertexSchema`);
-Symbol(`typegpu:${version}:$invalidSchemaReason`);
+/**
+* Type token for the inferred (GPU-side) representation of a resource
+* If present, it shadows the value of `$repr` for GPU-side inference.
+*/
+const $gpuRepr = Symbol(`typegpu:${version}:$gpuRepr`);
+/**
+* Type token for the inferred partial representation of a resource.
+* If present, it shadows the value of `$repr` for use in partial IO.
+*/
+const $reprPartial = Symbol(`typegpu:${version}:$reprPartial`);
+/**
+* Type token for the inferred patch representation of a resource.
+* Used by the `buffer.patch` API with `Record<number, T>` sparse arrays.
+*/
+const $reprPatch = Symbol(`typegpu:${version}:$reprPatch`);
+/**
+* Type token for the write-side (input) representation of a resource.
+*/
+const $inRepr = Symbol(`typegpu:${version}:$inRepr`);
+/**
+* Type token holding schemas that are identical in memory layout.
+*/
+const $memIdent = Symbol(`typegpu:${version}:$memIdent`);
+/**
+* Type token, signaling that a schema can be used in a storage buffer.
+*/
+const $validStorageSchema = Symbol(`typegpu:${version}:$invalidStorageSchema`);
+/**
+* Type token, signaling that a schema can be used in a uniform buffer.
+*/
+const $validUniformSchema = Symbol(`typegpu:${version}:$validUniformSchema`);
+/**
+* Type token, signaling that a schema can be used in a vertex buffer.
+*/
+const $validVertexSchema = Symbol(`typegpu:${version}:$validVertexSchema`);
+/**
+* Type token, containing a reason for why the schema is invalid (if it is).
+*/
+const $invalidSchemaReason = Symbol(`typegpu:${version}:$invalidSchemaReason`);
 function isMarkedInternal(value) {
 	return !!value?.[$internal];
 }
+
 //#endregion
-export { $cast, $getNameForward, $gpuCallable, $gpuValueOf, $internal, $ownSnippet, $providing, $repr, $resolve, isMarkedInternal };
+export { $cast, $getNameForward, $gpuCallable, $gpuValueOf, $internal, $ownSnippet, $providing, $repr, $resolve, isMarkedInternal };

package/shared/utilityTypes.js

@@ -2,5 +2,6 @@
 function assertExhaustive(x, location) {
 	throw new Error(`Failed to handle ${x} at ${location}`);
 }
+
 //#endregion
-export { assertExhaustive };
+export { assertExhaustive };

package/shared/vertexFormat.js

@@ -59,5 +59,6 @@ const kindToDefaultFormatMap = {
 	vec3i: "sint32x3",
 	vec4i: "sint32x4"
 };
+
 //#endregion
-export { kindToDefaultFormatMap, vertexFormats };
+export { kindToDefaultFormatMap, vertexFormats };

package/std/array.d.ts

@@ -2,6 +2,6 @@ import { DualFn } from "../types.js";
 import { _ref } from "../data/ref.js";
 
 //#region src/std/array.d.ts
-declare const arrayLength: DualFn;
+declare const arrayLength: DualFn<(a: unknown[] | _ref<unknown[]>) => number>;
 //#endregion
 export { arrayLength };

package/std/array.js

@@ -4,6 +4,7 @@ import { ptrFn } from "../data/ptr.js";
 import { isRef } from "../data/ref.js";
 import { abstractInt, u32 } from "../data/numeric.js";
 import { dualImpl } from "../core/function/dualImpl.js";
+
 //#region src/std/array.ts
 const sizeOfPointedToArray = (dataType) => isPtr(dataType) && isWgslArray(dataType.inner) ? dataType.inner.elementCount : 0;
 const arrayLength = dualImpl({
@@ -21,5 +22,6 @@ const arrayLength = dualImpl({
 		return length > 0 ? `${length}` : stitch`arrayLength(${a})`;
 	}
 });
+
 //#endregion
-export { arrayLength };
+export { arrayLength };

package/std/atomic.d.ts

@@ -3,17 +3,17 @@ import { atomicI32, atomicU32 } from "../data/wgslTypes.js";
 
 //#region src/std/atomic.d.ts
 type AnyAtomic = atomicI32 | atomicU32;
-declare const workgroupBarrier: DualFn;
-declare const storageBarrier: DualFn;
-declare const textureBarrier: DualFn;
-declare const atomicLoad: DualFn;
-declare const atomicStore: DualFn;
-declare const atomicAdd: DualFn;
-declare const atomicSub: DualFn;
-declare const atomicMax: DualFn;
-declare const atomicMin: DualFn;
-declare const atomicAnd: DualFn;
-declare const atomicOr: DualFn;
-declare const atomicXor: DualFn;
+declare const workgroupBarrier: DualFn<(...args: never[]) => unknown>;
+declare const storageBarrier: DualFn<(...args: never[]) => unknown>;
+declare const textureBarrier: DualFn<(...args: never[]) => unknown>;
+declare const atomicLoad: DualFn<(<T extends AnyAtomic>(a: T) => number)>;
+declare const atomicStore: DualFn<(<T extends AnyAtomic>(a: T, value: number) => void)>;
+declare const atomicAdd: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicSub: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicMax: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicMin: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicAnd: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicOr: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicXor: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
 //#endregion
 export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier };

package/std/atomic.js

@@ -3,6 +3,7 @@ import { stitch } from "../core/resolve/stitch.js";
 import { safeStringify } from "../shared/stringify.js";
 import { i32, u32 } from "../data/numeric.js";
 import { dualImpl } from "../core/function/dualImpl.js";
+
 //#region src/std/atomic.ts
 const workgroupBarrier = dualImpl({
 	name: "workgroupBarrier",
@@ -107,5 +108,6 @@ const atomicXor = dualImpl({
 	signature: atomicOpSignature,
 	codegenImpl: (_ctx, [a, value]) => stitch`atomicXor(&${a}, ${value})`
 });
+
 //#endregion
-export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier };
+export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier };

package/std/bitcast.d.ts

@@ -3,8 +3,8 @@ import { v2f, v2i, v2u, v3f, v3i, v3u, v4f, v4i, v4u } from "../data/wgslTypes.j
 
 //#region src/std/bitcast.d.ts
 type BitcastU32toF32Overload = ((value: number) => number) & ((value: v2u) => v2f) & ((value: v3u) => v3f) & ((value: v4u) => v4f);
-declare const bitcastU32toF32: DualFn;
+declare const bitcastU32toF32: DualFn<BitcastU32toF32Overload>;
 type BitcastU32toI32Overload = ((value: number) => number) & ((value: v2u) => v2i) & ((value: v3u) => v3i) & ((value: v4u) => v4i);
-declare const bitcastU32toI32: DualFn;
+declare const bitcastU32toI32: DualFn<BitcastU32toI32Overload>;
 //#endregion
 export { bitcastU32toF32, bitcastU32toI32 };

package/std/bitcast.js

@@ -6,6 +6,7 @@ import { vec2f, vec2i, vec3f, vec3i, vec4f, vec4i } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 import { bitcastU32toF32Impl, bitcastU32toI32Impl } from "../data/numberOps.js";
 import { VectorOps } from "../data/vectorOps.js";
+
 //#region src/std/bitcast.ts
 const bitcastU32toF32 = dualImpl({
 	name: "bitcastU32toF32",
@@ -37,5 +38,6 @@ const bitcastU32toI32 = dualImpl({
 		};
 	}
 });
+
 //#endregion
-export { bitcastU32toF32, bitcastU32toI32 };
+export { bitcastU32toF32, bitcastU32toI32 };