typegpu 0.8.2 → 0.10.0

package/operators-HTxa_0k9.js

@@ -0,0 +1,4156 @@
+//#region package.json
+var version = "0.10.0";
+
+//#endregion
+//#region src/shared/env.ts
+/**
+* This can be used to branch functionality between "dev" and "prod" modes, so that our
+* library can omit doing unnecessary work once it's out in the wild
+*
+* Even though the value of this constant uses Node.js specific APIs, pretty much every
+* bundler replaces the expression below with either `development` or `production`
+*/
+const DEV = process.env.NODE_ENV === "development";
+const TEST = process.env.NODE_ENV === "test";
+
+//#endregion
+//#region src/shared/symbols.ts
+const $internal = Symbol(`typegpu:${version}:$internal`);
+/**
+* The getter to the value of this resource, accessible on the GPU
+*/
+const $gpuValueOf = Symbol(`typegpu:${version}:$gpuValueOf`);
+/**
+* If this symbol is present, this means that getName and setName
+* will refer to object behind this property instead.
+*/
+const $getNameForward = Symbol(`typegpu:${version}:$getNameForward`);
+/**
+* Marks an object with slot-value bindings
+*/
+const $providing = Symbol(`typegpu:${version}:$providing`);
+/**
+* Objects can provide the snippet that represents them.
+*/
+const $ownSnippet = Symbol(`typegpu:${version}:$ownSnippet`);
+const $resolve = Symbol(`typegpu:${version}:$resolve`);
+/**
+* A way for a schema to provide casting behavior, without the need to be explicitly
+* callable by the end-user (e.g. vertex formats)
+*/
+const $cast = Symbol(`typegpu:${version}:$cast`);
+/**
+* Can be called on the GPU
+*/
+const $gpuCallable = Symbol(`typegpu:${version}:$gpuCallable`);
+/**
+* Type token for the inferred (CPU & GPU) representation of a resource
+*/
+const $repr = Symbol(`typegpu:${version}:$repr`);
+/**
+* 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 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
+//#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.`);
+globalWithMeta.__TYPEGPU_VERSION__ = version;
+globalWithMeta.__TYPEGPU_AUTONAME__ = (exp, label) => isNamable(exp) && isMarkedInternal(exp) && !getName(exp) ? exp.$name(label) : exp;
+/**
+* Performance measurements are only enabled in dev & test environments for now
+*/
+const PERF = (DEV || TEST) && {
+	get enabled() {
+		return !!globalWithMeta.__TYPEGPU_MEASURE_PERF__;
+	},
+	record(name, data) {
+		const records = globalWithMeta.__TYPEGPU_PERF_RECORDS__ ??= /* @__PURE__ */ new Map();
+		let entries = records.get(name);
+		if (!entries) {
+			entries = [];
+			records.set(name, entries);
+		}
+		entries.push(data);
+	}
+} || void 0;
+function isForwarded(value) {
+	return !!value?.[$getNameForward];
+}
+function getName(definition) {
+	if (isForwarded(definition)) return getName(definition[$getNameForward]);
+	return getMetaData(definition)?.name;
+}
+function setName(definition, name) {
+	if (isForwarded(definition)) {
+		setName(definition[$getNameForward], name);
+		return;
+	}
+	setMetaData(definition, { name });
+}
+function isNamable(value) {
+	return !!value?.$name;
+}
+/**
+* AST's are given to functions with a 'use gpu' directive, which this function checks for.
+*/
+function hasTinyestMetadata(value) {
+	return !!getMetaData(value)?.ast;
+}
+function getMetaData(definition) {
+	return globalWithMeta.__TYPEGPU_META__.get(definition);
+}
+function setMetaData(definition, metaData) {
+	globalWithMeta.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap();
+	const map = globalWithMeta.__TYPEGPU_META__;
+	map.set(definition, {
+		...map.get(definition),
+		...metaData
+	});
+}
+
+//#endregion
+//#region src/shared/vertexFormat.ts
+const vertexFormats = [
+	"uint8",
+	"uint8x2",
+	"uint8x4",
+	"sint8",
+	"sint8x2",
+	"sint8x4",
+	"unorm8",
+	"unorm8x2",
+	"unorm8x4",
+	"snorm8",
+	"snorm8x2",
+	"snorm8x4",
+	"uint16",
+	"uint16x2",
+	"uint16x4",
+	"sint16",
+	"sint16x2",
+	"sint16x4",
+	"unorm16",
+	"unorm16x2",
+	"unorm16x4",
+	"snorm16",
+	"snorm16x2",
+	"snorm16x4",
+	"float16",
+	"float16x2",
+	"float16x4",
+	"float32",
+	"float32x2",
+	"float32x3",
+	"float32x4",
+	"uint32",
+	"uint32x2",
+	"uint32x3",
+	"uint32x4",
+	"sint32",
+	"sint32x2",
+	"sint32x3",
+	"sint32x4",
+	"unorm10-10-10-2",
+	"unorm8x4-bgra"
+];
+const kindToDefaultFormatMap = {
+	f32: "float32",
+	vec2f: "float32x2",
+	vec3f: "float32x3",
+	vec4f: "float32x4",
+	f16: "float16",
+	vec2h: "float16x2",
+	vec4h: "float16x4",
+	u32: "uint32",
+	vec2u: "uint32x2",
+	vec3u: "uint32x3",
+	vec4u: "uint32x4",
+	i32: "sint32",
+	vec2i: "sint32x2",
+	vec3i: "sint32x3",
+	vec4i: "sint32x4"
+};
+
+//#endregion
+//#region src/data/wgslTypes.ts
+const Void = {
+	[$internal]: {},
+	type: "void",
+	toString() {
+		return "void";
+	}
+};
+const wgslTypeLiterals = [
+	"bool",
+	"f32",
+	"f16",
+	"i32",
+	"u32",
+	"u16",
+	"vec2f",
+	"vec2h",
+	"vec2i",
+	"vec2u",
+	"vec2<bool>",
+	"vec3f",
+	"vec3h",
+	"vec3i",
+	"vec3u",
+	"vec3<bool>",
+	"vec4f",
+	"vec4h",
+	"vec4i",
+	"vec4u",
+	"vec4<bool>",
+	"mat2x2f",
+	"mat3x3f",
+	"mat4x4f",
+	"struct",
+	"array",
+	"ptr",
+	"atomic",
+	"decorated",
+	"abstractInt",
+	"abstractFloat",
+	"void",
+	"texture_1d",
+	"texture_storage_1d",
+	"texture_2d",
+	"texture_storage_2d",
+	"texture_multisampled_2d",
+	"texture_depth_2d",
+	"texture_depth_multisampled_2d",
+	"texture_2d_array",
+	"texture_storage_2d_array",
+	"texture_depth_2d_array",
+	"texture_cube",
+	"texture_depth_cube",
+	"texture_cube_array",
+	"texture_depth_cube_array",
+	"texture_3d",
+	"texture_storage_3d",
+	"texture_external",
+	"sampler",
+	"sampler_comparison"
+];
+function isVecInstance(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.kind === "string" && v.kind.startsWith("vec");
+}
+function isVec2(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.type === "string" && v.type.startsWith("vec2");
+}
+function isVec3(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.type === "string" && v.type.startsWith("vec3");
+}
+function isVec4(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.type === "string" && v.type.startsWith("vec4");
+}
+function isVec(value) {
+	return isVec2(value) || isVec3(value) || isVec4(value);
+}
+function isVecBool(value) {
+	return isVec(value) && value.type.includes("b");
+}
+function isMatInstance(value) {
+	const v = value;
+	return isMarkedInternal(v) && typeof v.kind?.startsWith === "function" && v.kind.startsWith("mat");
+}
+function isMat2x2f(value) {
+	return isMarkedInternal(value) && value?.type === "mat2x2f";
+}
+function isMat3x3f(value) {
+	return isMarkedInternal(value) && value?.type === "mat3x3f";
+}
+function isMat4x4f(value) {
+	return isMarkedInternal(value) && value?.type === "mat4x4f";
+}
+function isMat(value) {
+	return isMat2x2f(value) || isMat3x3f(value) || isMat4x4f(value);
+}
+function isFloat32VecInstance(element) {
+	return isVecInstance(element) && [
+		"vec2f",
+		"vec3f",
+		"vec4f"
+	].includes(element.kind);
+}
+function isWgslData(value) {
+	return isMarkedInternal(value) && wgslTypeLiterals.includes(value?.type);
+}
+/**
+* Checks whether passed in value is an array schema,
+* as opposed to, e.g., a disarray schema.
+*
+* Array schemas can be used to describe uniform and storage buffers,
+* whereas disarray schemas cannot.
+*
+* @example
+* isWgslArray(d.arrayOf(d.u32, 4)) // true
+* isWgslArray(d.disarray(d.u32, 4)) // false
+* isWgslArray(d.vec3f) // false
+*/
+function isWgslArray(schema) {
+	return isMarkedInternal(schema) && schema?.type === "array";
+}
+/**
+* Checks whether passed in value is a struct schema,
+* as opposed to, e.g., an unstruct schema.
+*
+* Struct schemas can be used to describe uniform and storage buffers,
+* whereas unstruct schemas cannot.
+*
+* @example
+* isWgslStruct(d.struct({ a: d.u32 })) // true
+* isWgslStruct(d.unstruct({ a: d.u32 })) // false
+* isWgslStruct(d.vec3f) // false
+*/
+function isWgslStruct(schema) {
+	return isMarkedInternal(schema) && schema?.type === "struct";
+}
+/**
+* Checks whether passed in value is a pointer schema.
+*
+* @example
+* isPtr(d.ptrFn(d.f32)) // true
+* isPtr(d.ptrPrivate(d.f32)) // true
+* isPtr(d.f32) // false
+*/
+function isPtr(schema) {
+	return isMarkedInternal(schema) && schema?.type === "ptr";
+}
+/**
+* Checks whether the passed in value is an atomic schema.
+*
+* @example
+* isAtomic(d.atomic(d.u32)) // true
+* isAtomic(d.u32) // false
+*/
+function isAtomic(schema) {
+	return isMarkedInternal(schema) && schema?.type === "atomic";
+}
+function isAlignAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@align";
+}
+function isSizeAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@size";
+}
+function isLocationAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@location";
+}
+function isInterpolateAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@interpolate";
+}
+function isBuiltinAttrib(value) {
+	return isMarkedInternal(value) && value?.type === "@builtin";
+}
+function isDecorated(value) {
+	return isMarkedInternal(value) && value?.type === "decorated";
+}
+function isVoid(value) {
+	return isMarkedInternal(value) && value.type === "void";
+}
+function isNumericSchema(schema) {
+	const type = schema?.type;
+	return isMarkedInternal(schema) && (type === "abstractInt" || type === "abstractFloat" || type === "f32" || type === "f16" || type === "i32" || type === "u32");
+}
+function isHalfPrecisionSchema(schema) {
+	const type = schema?.type;
+	return isMarkedInternal(schema) && (type === "f16" || type === "vec2h" || type === "vec3h" || type === "vec4h");
+}
+const ephemeralTypes = [
+	"abstractInt",
+	"abstractFloat",
+	"f32",
+	"f16",
+	"i32",
+	"u32",
+	"bool"
+];
+/**
+* Returns true for schemas that are not naturally referential in JS (primitives).
+* @param schema
+* @returns
+*/
+function isNaturallyEphemeral(schema) {
+	return !isMarkedInternal(schema) || ephemeralTypes.includes(schema?.type);
+}
+function WORKAROUND_getSchema(vec) {
+	return vec.schema;
+}
+
+//#endregion
+//#region src/data/dataTypes.ts
+/**
+* Runtime function to extract the inner data type from decorated types.
+* If the data is not decorated, returns the data as-is.
+*/
+function undecorate(data) {
+	if (isDecorated(data) || isLooseDecorated(data)) return data.inner;
+	return data;
+}
+function unptr(data) {
+	if (isPtr(data)) return data.inner;
+	return data;
+}
+const looseTypeLiterals = [
+	"unstruct",
+	"disarray",
+	"loose-decorated",
+	...vertexFormats
+];
+function isLooseData(data) {
+	return isMarkedInternal(data) && looseTypeLiterals.includes(data?.type);
+}
+/**
+* Checks whether the passed in value is a disarray schema,
+* as opposed to, e.g., a regular array schema.
+*
+* Array schemas can be used to describe uniform and storage buffers,
+* whereas disarray schemas cannot. Disarrays are useful for
+* defining vertex buffers instead.
+*
+* @example
+* isDisarray(d.arrayOf(d.u32, 4)) // false
+* isDisarray(d.disarrayOf(d.u32, 4)) // true
+* isDisarray(d.vec3f) // false
+*/
+function isDisarray(schema) {
+	return isMarkedInternal(schema) && schema?.type === "disarray";
+}
+/**
+* Checks whether passed in value is a unstruct schema,
+* as opposed to, e.g., a struct schema.
+*
+* Struct schemas can be used to describe uniform and storage buffers,
+* whereas unstruct schemas cannot. Unstructs are useful for
+* defining vertex buffers instead.
+*
+* @example
+* isUnstruct(d.struct({ a: d.u32 })) // false
+* isUnstruct(d.unstruct({ a: d.u32 })) // true
+* isUnstruct(d.vec3f) // false
+*/
+function isUnstruct(schema) {
+	return isMarkedInternal(schema) && schema?.type === "unstruct";
+}
+function isLooseDecorated(value) {
+	return isMarkedInternal(value) && value?.type === "loose-decorated";
+}
+function getCustomAlignment(data) {
+	return data.attribs?.find(isAlignAttrib)?.params[0];
+}
+function getCustomSize(data) {
+	return data.attribs?.find(isSizeAttrib)?.params[0];
+}
+function getCustomLocation(data) {
+	return data.attribs?.find(isLocationAttrib)?.params[0];
+}
+function isData(value) {
+	return isWgslData(value) || isLooseData(value);
+}
+const UnknownData = Symbol("UNKNOWN");
+var InfixDispatch = class {
+	constructor(name, lhs, operator) {
+		this.name = name;
+		this.lhs = lhs;
+		this.operator = operator;
+	}
+};
+var MatrixColumnsAccess = class {
+	constructor(matrix) {
+		this.matrix = matrix;
+	}
+};
+var ConsoleLog = class {
+	[$internal] = true;
+	constructor(op) {
+		this.op = op;
+		setName(this, "consoleLog");
+	}
+};
+
+//#endregion
+//#region src/data/snippet.ts
+function isEphemeralOrigin(space) {
+	return space === "runtime" || space === "constant" || space === "argument";
+}
+function isEphemeralSnippet(snippet) {
+	return isEphemeralOrigin(snippet.origin);
+}
+const originToPtrParams = {
+	uniform: {
+		space: "uniform",
+		access: "read"
+	},
+	readonly: {
+		space: "storage",
+		access: "read"
+	},
+	mutable: {
+		space: "storage",
+		access: "read-write"
+	},
+	workgroup: {
+		space: "workgroup",
+		access: "read-write"
+	},
+	private: {
+		space: "private",
+		access: "read-write"
+	},
+	function: {
+		space: "function",
+		access: "read-write"
+	},
+	"this-function": {
+		space: "function",
+		access: "read-write"
+	}
+};
+var SnippetImpl = class {
+	constructor(value, dataType, origin) {
+		this.value = value;
+		this.dataType = dataType;
+		this.origin = origin;
+	}
+};
+function isSnippet(value) {
+	return value instanceof SnippetImpl;
+}
+function isSnippetNumeric(snippet) {
+	return isNumericSchema(snippet.dataType);
+}
+function snip(value, dataType, origin) {
+	if (DEV && isSnippet(value)) throw new Error("Cannot nest snippets");
+	return new SnippetImpl(value, undecorate(dataType), origin);
+}
+
+//#endregion
+//#region src/errors.ts
+const prefix = "Invariant failed";
+/**
+* Inspired by: https://github.com/alexreardon/tiny-invariant/blob/master/src/tiny-invariant.ts
+*/
+function invariant(condition, message) {
+	if (condition) return;
+	if (!DEV && !TEST) throw new Error(prefix);
+	const provided = typeof message === "function" ? message() : message;
+	const value = provided ? `${prefix}: ${provided}` : prefix;
+	throw new Error(value);
+}
+/**
+* An error that happens during resolution of WGSL code.
+* Contains a trace of all ancestor resolvables in
+* which this error originated.
+*
+* @category Errors
+*/
+var ResolutionError = class ResolutionError extends Error {
+	constructor(cause, trace) {
+		let entries = trace.map((ancestor) => `- ${hasTinyestMetadata(ancestor) ? `fn*:${getName(ancestor)}` : ancestor}`);
+		if (entries.length > 20) entries = [
+			...entries.slice(0, 11),
+			"...",
+			...entries.slice(-10)
+		];
+		super(`Resolution of the following tree failed:\n${entries.join("\n")}: ${cause && typeof cause === "object" && "message" in cause ? cause.message : cause}`);
+		this.cause = cause;
+		this.trace = trace;
+		Object.setPrototypeOf(this, ResolutionError.prototype);
+	}
+	appendToTrace(ancestor) {
+		const newTrace = [ancestor, ...this.trace];
+		return new ResolutionError(this.cause, newTrace);
+	}
+};
+/**
+* An error that happens during execution of TypeGPU functions.
+* Contains a trace of all TypeGPU functions called along the way.
+*
+* @category Errors
+*/
+var ExecutionError = class ExecutionError extends Error {
+	constructor(cause, trace) {
+		let entries = trace.map((ancestor) => `- ${ancestor}`);
+		if (entries.length > 20) entries = [
+			...entries.slice(0, 11),
+			"...",
+			...entries.slice(-10)
+		];
+		super(`Execution of the following tree failed:\n${entries.join("\n")}: ${cause && typeof cause === "object" && "message" in cause ? cause.message : cause}`);
+		this.cause = cause;
+		this.trace = trace;
+		Object.setPrototypeOf(this, ExecutionError.prototype);
+	}
+	appendToTrace(ancestor) {
+		const newTrace = [ancestor, ...this.trace];
+		return new ExecutionError(this.cause, newTrace);
+	}
+};
+/**
+* @category Errors
+*/
+var MissingSlotValueError = class MissingSlotValueError extends Error {
+	constructor(slot) {
+		super(`Missing value for '${slot}'`);
+		this.slot = slot;
+		Object.setPrototypeOf(this, MissingSlotValueError.prototype);
+	}
+};
+/**
+* @category Errors
+*/
+var NotUniformError = class NotUniformError extends Error {
+	constructor(value) {
+		super(`Buffer '${getName(value) ?? "<unnamed>"}' is not bindable as a uniform. Use .$usage('uniform') to allow it.`);
+		Object.setPrototypeOf(this, NotUniformError.prototype);
+	}
+};
+var MissingLinksError = class MissingLinksError extends Error {
+	constructor(fnLabel, externalNames) {
+		super(`The function '${fnLabel ?? "<unnamed>"}' is missing links to the following external values: ${externalNames}.`);
+		Object.setPrototypeOf(this, MissingLinksError.prototype);
+	}
+};
+var MissingBindGroupsError = class MissingBindGroupsError extends Error {
+	constructor(layouts) {
+		super(`Missing bind groups for layouts: '${[...layouts].map((layout) => getName(layout) ?? "<unnamed>").join(", ")}'. Please provide it using pipeline.with(bindGroup).(...)`);
+		Object.setPrototypeOf(this, MissingBindGroupsError.prototype);
+	}
+};
+var MissingVertexBuffersError = class MissingVertexBuffersError extends Error {
+	constructor(layouts) {
+		super(`Missing vertex buffers for layouts: '${[...layouts].map((layout) => getName(layout) ?? "<unnamed>").join(", ")}'. Please provide it using pipeline.with(layout, buffer).(...)`);
+		Object.setPrototypeOf(this, MissingVertexBuffersError.prototype);
+	}
+};
+var IllegalVarAccessError = class IllegalVarAccessError extends Error {
+	constructor(msg) {
+		super(msg);
+		Object.setPrototypeOf(this, IllegalVarAccessError.prototype);
+	}
+};
+var IllegalBufferAccessError = class IllegalBufferAccessError extends Error {
+	constructor(msg) {
+		super(msg);
+		Object.setPrototypeOf(this, IllegalBufferAccessError.prototype);
+	}
+};
+var WgslTypeError = class WgslTypeError extends Error {
+	constructor(msg) {
+		super(msg);
+		Object.setPrototypeOf(this, WgslTypeError.prototype);
+	}
+};
+var SignatureNotSupportedError = class SignatureNotSupportedError extends Error {
+	constructor(actual, candidates) {
+		super(`Unsupported data types: ${actual.map((a) => a.type).join(", ")}. Supported types are: ${candidates.map((r) => r.type).join(", ")}.`);
+		Object.setPrototypeOf(this, SignatureNotSupportedError.prototype);
+	}
+};
+
+//#endregion
+//#region src/core/slot/slotTypes.ts
+function isSlot(value) {
+	return value?.resourceType === "slot";
+}
+function isLazy(value) {
+	return value?.resourceType === "lazy";
+}
+function isProviding(value) {
+	return value?.[$providing] !== void 0;
+}
+function isAccessor(value) {
+	return value?.resourceType === "accessor";
+}
+function isMutableAccessor(value) {
+	return value?.resourceType === "mutable-accessor";
+}
+
+//#endregion
+//#region src/types.ts
+var NormalState = class {
+	type = "normal";
+};
+var CodegenState = class {
+	type = "codegen";
+};
+var SimulationState = class {
+	type = "simulate";
+	constructor(buffers, vars) {
+		this.buffers = buffers;
+		this.vars = vars;
+	}
+};
+function isSelfResolvable(value) {
+	return !!value?.[$resolve];
+}
+function getOwnSnippet(value) {
+	return value?.[$ownSnippet];
+}
+function isGPUCallable(value) {
+	return !!value?.[$gpuCallable];
+}
+function hasCast(value) {
+	return !!value?.[$cast];
+}
+function isKnownAtComptime(snippet) {
+	return (typeof snippet.value !== "string" || snippet.dataType === UnknownData) && getOwnSnippet(snippet.value) === void 0;
+}
+function isWgsl(value) {
+	return typeof value === "number" || typeof value === "boolean" || typeof value === "string" || isSelfResolvable(value) || isWgslData(value) || isSlot(value) || isLazy(value) || isProviding(value);
+}
+function isGPUBuffer(value) {
+	return !!value && typeof value === "object" && "getMappedRange" in value && "mapAsync" in value;
+}
+
+//#endregion
+//#region src/execMode.ts
+/**
+* Used to track if the code we're currently
+* executing is inside an executing TypeGPU function.
+*
+* Helpful for providing better error messages.
+*/
+let insideTgpuFn = false;
+function provideInsideTgpuFn(callback) {
+	if (insideTgpuFn) return callback();
+	try {
+		insideTgpuFn = true;
+		return callback();
+	} finally {
+		insideTgpuFn = false;
+	}
+}
+function isInsideTgpuFn() {
+	return insideTgpuFn;
+}
+let resolutionCtx;
+function provideCtx(ctx, callback) {
+	invariant(resolutionCtx === void 0 || resolutionCtx === ctx, "Cannot nest context providers");
+	if (resolutionCtx === ctx) return callback();
+	resolutionCtx = ctx;
+	try {
+		return callback();
+	} finally {
+		resolutionCtx = void 0;
+	}
+}
+function getResolutionCtx() {
+	return resolutionCtx;
+}
+/**
+* Applicable when code is being executed outside of any
+* execution-altering APIs.
+*/
+const topLevelState = new NormalState();
+function getExecMode() {
+	return resolutionCtx?.mode ?? topLevelState;
+}
+function inCodegenMode() {
+	return resolutionCtx?.mode.type === "codegen";
+}
+
+//#endregion
+//#region src/core/resolve/stitch.ts
+/**
+* "The reverse of snipping"
+* Injects resolved snippets into a template string.
+*/
+function stitch(strings, ...snippets) {
+	const ctx = getResolutionCtx();
+	function resolveSnippet(maybeSnippet) {
+		return isSnippet(maybeSnippet) ? ctx.resolve(maybeSnippet.value, maybeSnippet.dataType).value : maybeSnippet;
+	}
+	let result = "";
+	for (let i = 0; i < strings.length; ++i) {
+		result += strings[i];
+		const snippet = snippets[i];
+		if (Array.isArray(snippet)) result += snippet.filter((s) => s !== void 0).map(resolveSnippet).join(", ");
+		else if (snippet) result += resolveSnippet(snippet);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/data/ptr.ts
+function ptrFn(inner) {
+	return INTERNAL_createPtr("function", inner, "read-write");
+}
+function ptrPrivate(inner) {
+	return INTERNAL_createPtr("private", inner, "read-write");
+}
+function ptrWorkgroup(inner) {
+	return INTERNAL_createPtr("workgroup", inner, "read-write");
+}
+function ptrStorage(inner, access = "read") {
+	return INTERNAL_createPtr("storage", inner, access);
+}
+function ptrUniform(inner) {
+	return INTERNAL_createPtr("uniform", inner, "read");
+}
+function ptrHandle(inner) {
+	return INTERNAL_createPtr("handle", inner, "read");
+}
+function INTERNAL_createPtr(addressSpace, inner, access, implicit = false) {
+	return {
+		[$internal]: {},
+		type: "ptr",
+		addressSpace,
+		inner,
+		access,
+		implicit,
+		toString: () => `ptr<${addressSpace}, ${inner}, ${access}>`
+	};
+}
+function createPtrFromOrigin(origin, innerDataType) {
+	const ptrParams = originToPtrParams[origin];
+	if (ptrParams) return INTERNAL_createPtr(ptrParams.space, innerDataType, ptrParams.access);
+}
+function implicitFrom(ptr) {
+	return INTERNAL_createPtr(ptr.addressSpace, ptr.inner, ptr.access, true);
+}
+function explicitFrom(ptr) {
+	return INTERNAL_createPtr(ptr.addressSpace, ptr.inner, ptr.access, false);
+}
+
+//#endregion
+//#region src/data/ref.ts
+const _ref = (() => {
+	const impl = ((value) => INTERNAL_createRef(value));
+	setName(impl, "ref");
+	impl.toString = () => "ref";
+	impl[$internal] = true;
+	impl[$gpuCallable] = { call(_ctx, [value]) {
+		if (value.origin === "argument") throw new WgslTypeError(stitch`d.ref(${value}) is illegal, cannot take a reference of an argument. Copy the value locally first, and take a reference of the copy.`);
+		if (isPtr(value.dataType)) return snip(value.value, explicitFrom(value.dataType), value.origin);
+		/**
+		* Pointer type only exists if the ref was created from a reference (buttery-butter).
+		*
+		* @example
+		* ```ts
+		* const life = ref(42); // created from a value
+		* const boid = ref(layout.$.boids[0]); // created from a reference
+		* ```
+		*/
+		const ptrType = createPtrFromOrigin(value.origin, value.dataType);
+		return snip(new RefOperator(value, ptrType), ptrType ?? UnknownData, "runtime");
+	} };
+	return impl;
+})();
+function isRef(value) {
+	return value?.[$internal]?.type === "ref";
+}
+function INTERNAL_createRef(value) {
+	const target = {
+		[$internal]: { type: "ref" },
+		get $() {
+			return value;
+		},
+		set $(newValue) {
+			if (newValue && typeof newValue === "object") for (const key of Object.keys(newValue)) value[key] = newValue[key];
+			else value = newValue;
+		}
+	};
+	if (value === void 0 || value === null) throw new Error("Cannot create a ref from undefined or null");
+	if (typeof value === "object") return new Proxy(target, {
+		get(target, prop) {
+			if (prop in target) return target[prop];
+			return value[prop];
+		},
+		set(_target, prop, propValue) {
+			if (prop === $internal) return false;
+			if (prop === "$") {
+				console.log("Setting ref value:", propValue);
+				return Reflect.set(target, prop, propValue);
+			}
+			return Reflect.set(value, prop, propValue);
+		}
+	});
+	return target;
+}
+/**
+* The result of calling `d.ref(...)`. The code responsible for
+* generating shader code can check if the value of a snippet is
+* an instance of `RefOperator`, and act accordingly.
+*/
+var RefOperator = class {
+	[$internal];
+	snippet;
+	#ptrType;
+	constructor(snippet, ptrType) {
+		this[$internal] = true;
+		this.snippet = snippet;
+		this.#ptrType = ptrType;
+	}
+	get [$ownSnippet]() {
+		if (!this.#ptrType) throw new Error(stitch`Cannot take a reference of ${this.snippet}`);
+		return snip(this, this.#ptrType, this.snippet.origin);
+	}
+	[$resolve]() {
+		if (!this.#ptrType) throw new Error(stitch`Cannot take a reference of ${this.snippet}`);
+		return snip(stitch`(&${this.snippet})`, this.#ptrType, this.snippet.origin);
+	}
+};
+function derefSnippet(snippet) {
+	if (!isPtr(snippet.dataType)) return snippet;
+	const innerType = snippet.dataType.inner;
+	const origin = isNaturallyEphemeral(innerType) ? "runtime" : snippet.origin;
+	if (snippet.value instanceof RefOperator) return snip(stitch`${snippet.value.snippet}`, innerType, origin);
+	return snip(stitch`(*${snippet})`, innerType, origin);
+}
+
+//#endregion
+//#region src/data/schemaCallWrapper.ts
+/**
+* A wrapper for `schema(item)` or `schema()` call on JS side.
+* If the schema is a pointer, returns the value pointed to without copying.
+* If the schema is a TgpuVertexFormatData, calls the corresponding constructible schema instead.
+* If the schema is not callable, throws an error.
+* Otherwise, returns `schema(item)` or `schema()`.
+*/
+function schemaCallWrapper(schema, item) {
+	const callSchema = schema;
+	if (hasCast(callSchema)) return callSchema[$cast](item);
+	if (typeof callSchema !== "function") return item;
+	return item === void 0 ? callSchema() : callSchema(item);
+}
+/**
+* A wrapper for `schema(item)` or `schema()` call on the GPU side.
+* If the schema is a pointer, returns the value pointed to without copying.
+* If the schema is a TgpuVertexFormatData, calls the corresponding constructible schema instead.
+* If the schema is not callable, throws an error.
+* Otherwise, returns `schema(item)` or `schema()`.
+*/
+function schemaCallWrapperGPU(ctx, schema, item) {
+	if (!isGPUCallable(schema)) return item;
+	const callSchema = schema;
+	return item === void 0 || item.value === void 0 ? callSchema[$gpuCallable].call(ctx, []) : callSchema[$gpuCallable].call(ctx, [item]);
+}
+
+//#endregion
+//#region src/shared/stringify.ts
+function safeStringify(item) {
+	const asString = String(item);
+	if (asString !== "[object Object]") return asString;
+	try {
+		return JSON.stringify(item);
+	} catch (error) {
+		console.error("Error parsing JSON:", error);
+		return "<invalid json>";
+	}
+}
+function niceStringify(item) {
+	if (isVecInstance(item) || isMatInstance(item)) return item.toString();
+	if (Array.isArray(item)) return `[${item.map(niceStringify).join(", ")}]`;
+	if (item && typeof item === "object") return `{ ${Object.entries(item).map(([key, value]) => `${key}: ${niceStringify(value)}`).join(", ")} }`;
+	return String(item);
+}
+
+//#endregion
+//#region src/shared/utilityTypes.ts
+function assertExhaustive(x, location) {
+	throw new Error(`Failed to handle ${x} at ${location}`);
+}
+
+//#endregion
+//#region src/tgsl/conversion.ts
+const INFINITE_RANK = {
+	rank: Number.POSITIVE_INFINITY,
+	action: "none"
+};
+function getAutoConversionRank(src, dest) {
+	const trueSrc = undecorate(src);
+	const trueDst = undecorate(dest);
+	if (trueSrc.type === trueDst.type) return {
+		rank: 0,
+		action: "none"
+	};
+	if (trueSrc.type === "abstractFloat") {
+		if (trueDst.type === "f32") return {
+			rank: 1,
+			action: "none"
+		};
+		if (trueDst.type === "f16") return {
+			rank: 2,
+			action: "none"
+		};
+	}
+	if (trueSrc.type === "abstractInt") {
+		if (trueDst.type === "i32") return {
+			rank: 3,
+			action: "none"
+		};
+		if (trueDst.type === "u32") return {
+			rank: 4,
+			action: "none"
+		};
+		if (trueDst.type === "abstractFloat") return {
+			rank: 5,
+			action: "none"
+		};
+		if (trueDst.type === "f32") return {
+			rank: 6,
+			action: "none"
+		};
+		if (trueDst.type === "f16") return {
+			rank: 7,
+			action: "none"
+		};
+	}
+	if (isVec(trueSrc) && isVec(trueDst) && trueSrc.type[3] === trueDst.type[3]) return getAutoConversionRank(trueSrc.primitive, trueDst.primitive);
+	if (isMat(trueSrc) && isMat(trueDst) && trueSrc.type[3] === trueDst.type[3]) return {
+		rank: 0,
+		action: "none"
+	};
+	return INFINITE_RANK;
+}
+function getImplicitConversionRank(src, dest) {
+	const trueSrc = undecorate(src);
+	const trueDst = undecorate(dest);
+	if (isPtr(trueSrc) && trueSrc.implicit && getAutoConversionRank(trueSrc.inner, trueDst).rank < Number.POSITIVE_INFINITY) return {
+		rank: 0,
+		action: "deref"
+	};
+	if (isPtr(trueDst) && getAutoConversionRank(trueSrc, trueDst.inner).rank < Number.POSITIVE_INFINITY) return {
+		rank: 1,
+		action: "ref"
+	};
+	const primitivePreference = {
+		f32: 0,
+		f16: 1,
+		i32: 2,
+		u32: 3,
+		bool: 4
+	};
+	if (trueSrc.type in primitivePreference && trueDst.type in primitivePreference) {
+		const srcType = trueSrc.type;
+		const destType = trueDst.type;
+		if (srcType !== destType) {
+			const srcPref = primitivePreference[srcType];
+			return {
+				rank: primitivePreference[destType] < srcPref ? 10 : 20,
+				action: "cast",
+				targetType: trueDst
+			};
+		}
+	}
+	if (trueSrc.type === "abstractFloat") {
+		if (trueDst.type === "u32") return {
+			rank: 2,
+			action: "cast",
+			targetType: trueDst
+		};
+		if (trueDst.type === "i32") return {
+			rank: 1,
+			action: "cast",
+			targetType: trueDst
+		};
+	}
+	return INFINITE_RANK;
+}
+function getConversionRank(src, dest, allowImplicit) {
+	const autoRank = getAutoConversionRank(src, dest);
+	if (autoRank.rank < Number.POSITIVE_INFINITY) return autoRank;
+	if (allowImplicit) return getImplicitConversionRank(src, dest);
+	return INFINITE_RANK;
+}
+function findBestType(types, uniqueTypes, allowImplicit) {
+	let bestResult;
+	for (const targetType of uniqueTypes) {
+		const details = [];
+		let sum = 0;
+		for (const sourceType of types) {
+			const conversion = getConversionRank(sourceType, targetType, allowImplicit);
+			sum += conversion.rank;
+			if (conversion.rank === Number.POSITIVE_INFINITY) break;
+			details.push(conversion);
+		}
+		if (sum < (bestResult?.sum ?? Number.POSITIVE_INFINITY)) bestResult = {
+			type: targetType,
+			details,
+			sum
+		};
+	}
+	if (!bestResult) return;
+	const actions = bestResult.details.map((detail, index) => ({
+		sourceIndex: index,
+		action: detail.action,
+		...detail.action === "cast" && { targetType: detail.targetType }
+	}));
+	return {
+		targetType: bestResult.type,
+		actions,
+		hasImplicitConversions: actions.some((action) => action.action === "cast")
+	};
+}
+function getBestConversion(types, targetTypes) {
+	if (types.length === 0) return void 0;
+	const uniqueTargetTypes = [...new Set((targetTypes || types).map(undecorate))];
+	const explicitResult = findBestType(types, uniqueTargetTypes, false);
+	if (explicitResult) return explicitResult;
+	const implicitResult = findBestType(types, uniqueTargetTypes, true);
+	if (implicitResult) return implicitResult;
+}
+function applyActionToSnippet(ctx, snippet, action, targetType) {
+	if (action.action === "none") return snip(snippet.value, targetType, snippet.origin);
+	switch (action.action) {
+		case "ref": return snip(new RefOperator(snippet, targetType), targetType, snippet.origin);
+		case "deref": return derefSnippet(snippet);
+		case "cast": return schemaCallWrapperGPU(ctx, targetType, snippet);
+		default: assertExhaustive(action.action, "applyActionToSnippet");
+	}
+}
+function unify(inTypes, restrictTo) {
+	if (inTypes.some((type) => type === UnknownData)) return;
+	const conversion = getBestConversion(inTypes, restrictTo);
+	if (!conversion) return;
+	return inTypes.map((type) => isVec(type) || isMat(type) ? type : conversion.targetType);
+}
+function convertToCommonType(ctx, values, restrictTo, verbose = true) {
+	const types = values.map((value) => value.dataType);
+	if (types.some((type) => type === UnknownData)) return;
+	if (DEV && Array.isArray(restrictTo) && restrictTo.length === 0) console.warn("convertToCommonType was called with an empty restrictTo array, which prevents any conversions from being made. If you intend to allow all conversions, pass undefined instead. If this was intended call the function conditionally since the result will always be undefined.");
+	const conversion = getBestConversion(types, restrictTo);
+	if (!conversion) return;
+	if ((TEST || DEV) && verbose && conversion.hasImplicitConversions) console.warn(`Implicit conversions from [\n${values.map((v) => `  ${v.value}: ${safeStringify(v.dataType)}`).join(",\n")}\n] to ${conversion.targetType.type} are supported, but not recommended.
+Consider using explicit conversions instead.`);
+	return values.map((value, index) => {
+		const action = conversion.actions[index];
+		invariant(action, "Action should not be undefined");
+		return applyActionToSnippet(ctx, value, action, conversion.targetType);
+	});
+}
+function tryConvertSnippet(ctx, snippet, targetDataTypes, verbose = true) {
+	const targets = Array.isArray(targetDataTypes) ? targetDataTypes : [targetDataTypes];
+	const { value, dataType, origin } = snippet;
+	if (targets.length === 1) {
+		const target = targets[0];
+		if (target === dataType) return snip(value, target, origin);
+		if (dataType === UnknownData) return snip(stitch`${snip(value, target, origin)}`, target, origin);
+	}
+	const converted = convertToCommonType(ctx, [snippet], targets, verbose);
+	if (converted) return converted[0];
+	throw new WgslTypeError(`Cannot convert value of type '${String(dataType)}' to any of the target types: [${targets.map((t) => t.type).join(", ")}]`);
+}
+function convertStructValues(ctx, structType, values) {
+	return Object.entries(structType.propTypes).map(([key, targetType]) => {
+		const val = values[key];
+		if (!val) throw new Error(`Missing property ${key}`);
+		return convertToCommonType(ctx, [val], [targetType])?.[0] ?? val;
+	});
+}
+
+//#endregion
+//#region src/core/function/createCallableSchema.ts
+function callableSchema(options) {
+	const impl = ((...args) => {
+		return options.normalImpl(...args);
+	});
+	setName(impl, options.name);
+	impl.toString = () => options.name;
+	impl[$gpuCallable] = {
+		get strictSignature() {},
+		call(ctx, args) {
+			const { argTypes, returnType } = options.signature(...args.map((s) => {
+				if (isPtr(s.dataType) && s.dataType.implicit) return s.dataType.inner;
+				return s.dataType;
+			}));
+			const converted = args.map((s, idx) => {
+				const argType = argTypes[idx];
+				if (!argType) throw new Error("Function called with invalid arguments");
+				return tryConvertSnippet(ctx, s, argType, false);
+			});
+			if (converted.every((s) => isKnownAtComptime(s))) {
+				ctx.pushMode(new NormalState());
+				try {
+					return snip(options.normalImpl(...converted.map((s) => s.value)), returnType, "constant");
+				} finally {
+					ctx.popMode("normal");
+				}
+			}
+			return snip(options.codegenImpl(ctx, converted), returnType, "runtime");
+		}
+	};
+	return impl;
+}
+
+//#endregion
+//#region src/data/numeric.ts
+const abstractInt = {
+	[$internal]: {},
+	type: "abstractInt",
+	toString() {
+		return "abstractInt";
+	}
+};
+const abstractFloat = {
+	[$internal]: {},
+	type: "abstractFloat",
+	toString() {
+		return "abstractFloat";
+	}
+};
+const boolCast = callableSchema({
+	name: "bool",
+	signature: (arg) => ({
+		argTypes: arg ? [arg] : [],
+		returnType: bool
+	}),
+	normalImpl(v) {
+		if (v === void 0) return false;
+		if (typeof v === "boolean") return v;
+		return !!v;
+	},
+	codegenImpl: (_ctx, [arg]) => arg?.dataType === bool ? stitch`${arg}` : stitch`bool(${arg})`
+});
+/**
+* A schema that represents a boolean value. (equivalent to `bool` in WGSL)
+*
+* Can also be called to cast a value to a bool in accordance with WGSL casting rules.
+*
+* @example
+* const value = bool(); // false
+* @example
+* const value = bool(0); // false
+* @example
+* const value = bool(-0); // false
+* @example
+* const value = bool(21.37); // true
+*/
+const bool = Object.assign(boolCast, {
+	[$internal]: {},
+	type: "bool"
+});
+const u32Cast = callableSchema({
+	name: "u32",
+	signature: (arg) => ({
+		argTypes: arg ? [arg] : [],
+		returnType: u32
+	}),
+	normalImpl(v) {
+		if (v === void 0) return 0;
+		if (typeof v === "boolean") return v ? 1 : 0;
+		if (!Number.isInteger(v)) {
+			const truncated = Math.trunc(v);
+			if (truncated < 0) return 0;
+			if (truncated > 4294967295) return 4294967295;
+			return truncated;
+		}
+		return (v & 4294967295) >>> 0;
+	},
+	codegenImpl: (_ctx, [arg]) => arg?.dataType === u32 ? stitch`${arg}` : stitch`u32(${arg})`
+});
+/**
+* A schema that represents an unsigned 32-bit integer value. (equivalent to `u32` in WGSL)
+*
+* Can also be called to cast a value to an u32 in accordance with WGSL casting rules.
+*
+* @example
+* const value = u32(); // 0
+* @example
+* const value = u32(7); // 7
+* @example
+* const value = u32(3.14); // 3
+* @example
+* const value = u32(-1); // 4294967295
+* @example
+* const value = u32(-3.1); // 0
+*/
+const u32 = Object.assign(u32Cast, {
+	[$internal]: {},
+	type: "u32"
+});
+const i32Cast = callableSchema({
+	name: "i32",
+	signature: (arg) => ({
+		argTypes: arg ? [arg] : [],
+		returnType: i32
+	}),
+	normalImpl(v) {
+		if (v === void 0) return 0;
+		if (typeof v === "boolean") return v ? 1 : 0;
+		return v | 0;
+	},
+	codegenImpl: (_ctx, [arg]) => arg?.dataType === i32 ? stitch`${arg}` : stitch`i32(${arg})`
+});
+const u16 = {
+	[$internal]: {},
+	type: "u16"
+};
+/**
+* A schema that represents a signed 32-bit integer value. (equivalent to `i32` in WGSL)
+*
+* Can also be called to cast a value to an i32 in accordance with WGSL casting rules.
+*
+* @example
+* const value = i32(); // 0
+* @example
+* const value = i32(3.14); // 3
+* @example
+* const value = i32(-3.9); // -3
+* @example
+* const value = i32(10000000000) // 1410065408
+*/
+const i32 = Object.assign(i32Cast, {
+	[$internal]: {},
+	type: "i32"
+});
+const f32Cast = callableSchema({
+	name: "f32",
+	signature: (arg) => ({
+		argTypes: arg ? [arg] : [],
+		returnType: f32
+	}),
+	normalImpl(v) {
+		if (v === void 0) return 0;
+		if (typeof v === "boolean") return v ? 1 : 0;
+		return Math.fround(v);
+	},
+	codegenImpl: (_ctx, [arg]) => arg?.dataType === f32 ? stitch`${arg}` : stitch`f32(${arg})`
+});
+/**
+* A schema that represents a 32-bit float value. (equivalent to `f32` in WGSL)
+*
+* Can also be called to cast a value to an f32.
+*
+* @example
+* const value = f32(); // 0
+* @example
+* const value = f32(1.23); // 1.23
+* @example
+* const value = f32(true); // 1
+*/
+const f32 = Object.assign(f32Cast, {
+	[$internal]: {},
+	type: "f32"
+});
+const buf32 = /* @__PURE__ */ new ArrayBuffer(4);
+const f32arr = new Float32Array(buf32);
+const u32arr = new Uint32Array(buf32);
+/**
+* Convert a JavaScript number (treated as float32) to **binary16** bit pattern.
+* @param x 32-bit floating-point value
+* @returns 16-bit half-precision encoding (stored in a JS number)
+*/
+function toHalfBits(x) {
+	f32arr[0] = x;
+	const bits = u32arr[0];
+	const sign = bits >>> 31 & 1;
+	let exp = bits >>> 23 & 255;
+	let mant = bits & 8388607;
+	if (exp === 255) return sign << 15 | 31744 | (mant ? 512 : 0);
+	exp = exp - 127 + 15;
+	if (exp <= 0) {
+		if (exp < -10) return sign << 15;
+		mant = (mant | 8388608) >> 1 - exp;
+		mant = mant + 4096 >> 13;
+		return sign << 15 | mant;
+	}
+	if (exp >= 31) return sign << 15 | 31744;
+	mant = mant + 4096;
+	if (mant & 8388608) {
+		mant = 0;
+		++exp;
+		if (exp >= 31) return sign << 15 | 31744;
+	}
+	return sign << 15 | exp << 10 | mant >> 13;
+}
+/**
+* Convert a **binary16** encoded bit pattern back to JavaScript number.
+* @param h 16-bit half-precision bits
+* @returns JavaScript number (64-bit float) with same numerical value
+*/
+function fromHalfBits(h) {
+	const sign = h & 32768 ? -1 : 1;
+	const exp = h >> 10 & 31;
+	const mant = h & 1023;
+	if (exp === 0) return mant ? sign * mant * 2 ** -24 : sign * 0;
+	if (exp === 31) return mant ? NaN : sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+	return sign * (1 + mant / 1024) * 2 ** (exp - 15);
+}
+function roundToF16(x) {
+	return fromHalfBits(toHalfBits(x));
+}
+const f16Cast = callableSchema({
+	name: "f16",
+	signature: (arg) => ({
+		argTypes: arg ? [arg] : [],
+		returnType: f16
+	}),
+	normalImpl(v) {
+		if (v === void 0) return 0;
+		if (typeof v === "boolean") return v ? 1 : 0;
+		return roundToF16(v);
+	},
+	codegenImpl: (_ctx, [arg]) => arg?.dataType === f16 ? stitch`${arg}` : stitch`f16(${arg})`
+});
+/**
+* A schema that represents a 16-bit float value. (equivalent to `f16` in WGSL)
+*
+* Can also be called to cast a value to an f16.
+*
+* @example
+* const value = f16(); // 0
+* @example
+* const value = f32(1.23); // 1.23
+* @example
+* const value = f16(true); // 1
+* @example
+* const value = f16(21877.5); // 21872
+*/
+const f16 = Object.assign(f16Cast, {
+	[$internal]: {},
+	type: "f16"
+});
+
+//#endregion
+//#region src/data/vectorImpl.ts
+const XYZW = [
+	"x",
+	"y",
+	"z",
+	"w"
+];
+const RGBA = [
+	"r",
+	"g",
+	"b",
+	"a"
+];
+var VecBase = class VecBase extends Array {
+	static {
+		for (let e0 = 0; e0 < 4; e0++) for (let e1 = 0; e1 < 4; e1++) for (let e2 = 0; e2 < 4; e2++) for (let e3 = 0; e3 < 4; e3++) {
+			const xyzwProp = `${XYZW[e0]}${XYZW[e1]}${XYZW[e2]}${XYZW[e3]}`;
+			const rgbaProp = `${RGBA[e0]}${RGBA[e1]}${RGBA[e2]}${RGBA[e3]}`;
+			Object.defineProperty(VecBase.prototype, xyzwProp, { get() {
+				return new this._Vec4(this[e0], this[e1], this[e2], this[e3]);
+			} });
+			Object.defineProperty(VecBase.prototype, rgbaProp, { get() {
+				return new this._Vec4(this[e0], this[e1], this[e2], this[e3]);
+			} });
+		}
+		for (let e0 = 0; e0 < 4; e0++) for (let e1 = 0; e1 < 4; e1++) for (let e2 = 0; e2 < 4; e2++) {
+			const xyzwProp = `${XYZW[e0]}${XYZW[e1]}${XYZW[e2]}`;
+			const rgbaProp = `${RGBA[e0]}${RGBA[e1]}${RGBA[e2]}`;
+			Object.defineProperty(VecBase.prototype, xyzwProp, { get() {
+				return new this._Vec3(this[e0], this[e1], this[e2]);
+			} });
+			Object.defineProperty(VecBase.prototype, rgbaProp, { get() {
+				return new this._Vec3(this[e0], this[e1], this[e2]);
+			} });
+		}
+		for (let e0 = 0; e0 < 4; e0++) for (let e1 = 0; e1 < 4; e1++) {
+			const xyzwProp = `${XYZW[e0]}${XYZW[e1]}`;
+			const rgbaProp = `${RGBA[e0]}${RGBA[e1]}`;
+			Object.defineProperty(VecBase.prototype, xyzwProp, { get() {
+				return new this._Vec2(this[e0], this[e1]);
+			} });
+			Object.defineProperty(VecBase.prototype, rgbaProp, { get() {
+				return new this._Vec2(this[e0], this[e1]);
+			} });
+		}
+	}
+	castElement() {
+		return this[$internal].elementSchema;
+	}
+	[$resolve]() {
+		const schema = this[$internal].elementSchema;
+		if (this.every((e) => !e)) return snip(`${this.kind}()`, schema, "constant");
+		if (this.every((e) => this[0] === e)) return snip(`${this.kind}(${this[0]})`, schema, "runtime");
+		return snip(`${this.kind}(${this.join(", ")})`, schema, "runtime");
+	}
+	toString() {
+		return this[$resolve]().value;
+	}
+};
+var Vec2 = class extends VecBase {
+	e0;
+	e1;
+	constructor(x, y) {
+		super(2);
+		this.e0 = this.castElement()(x);
+		this.e1 = this.castElement()(y ?? x);
+	}
+	get 0() {
+		return this.e0;
+	}
+	get 1() {
+		return this.e1;
+	}
+	set 0(value) {
+		this.e0 = this.castElement()(value);
+	}
+	set 1(value) {
+		this.e1 = this.castElement()(value);
+	}
+	get x() {
+		return this[0];
+	}
+	get y() {
+		return this[1];
+	}
+	set x(value) {
+		this[0] = this.castElement()(value);
+	}
+	set y(value) {
+		this[1] = this.castElement()(value);
+	}
+	get r() {
+		return this[0];
+	}
+	get g() {
+		return this[1];
+	}
+	set r(value) {
+		this[0] = this.castElement()(value);
+	}
+	set g(value) {
+		this[1] = this.castElement()(value);
+	}
+};
+var Vec3 = class extends VecBase {
+	e0;
+	e1;
+	e2;
+	constructor(x, y, z) {
+		super(3);
+		this.e0 = this.castElement()(x);
+		this.e1 = this.castElement()(y ?? x);
+		this.e2 = this.castElement()(z ?? x);
+	}
+	get 0() {
+		return this.e0;
+	}
+	get 1() {
+		return this.e1;
+	}
+	get 2() {
+		return this.e2;
+	}
+	set 0(value) {
+		this.e0 = this.castElement()(value);
+	}
+	set 1(value) {
+		this.e1 = this.castElement()(value);
+	}
+	set 2(value) {
+		this.e2 = this.castElement()(value);
+	}
+	get x() {
+		return this[0];
+	}
+	get y() {
+		return this[1];
+	}
+	get z() {
+		return this[2];
+	}
+	set x(value) {
+		this[0] = this.castElement()(value);
+	}
+	set y(value) {
+		this[1] = this.castElement()(value);
+	}
+	set z(value) {
+		this[2] = this.castElement()(value);
+	}
+	get r() {
+		return this[0];
+	}
+	get g() {
+		return this[1];
+	}
+	get b() {
+		return this[2];
+	}
+	set r(value) {
+		this[0] = this.castElement()(value);
+	}
+	set g(value) {
+		this[1] = this.castElement()(value);
+	}
+	set b(value) {
+		this[2] = this.castElement()(value);
+	}
+};
+var Vec4 = class extends VecBase {
+	e0;
+	e1;
+	e2;
+	e3;
+	constructor(x, y, z, w) {
+		super(4);
+		this.e0 = this.castElement()(x);
+		this.e1 = this.castElement()(y ?? x);
+		this.e2 = this.castElement()(z ?? x);
+		this.e3 = this.castElement()(w ?? x);
+	}
+	get 0() {
+		return this.e0;
+	}
+	get 1() {
+		return this.e1;
+	}
+	get 2() {
+		return this.e2;
+	}
+	get 3() {
+		return this.e3;
+	}
+	set 0(value) {
+		this.e0 = this.castElement()(value);
+	}
+	set 1(value) {
+		this.e1 = this.castElement()(value);
+	}
+	set 2(value) {
+		this.e2 = this.castElement()(value);
+	}
+	set 3(value) {
+		this.e3 = this.castElement()(value);
+	}
+	get x() {
+		return this[0];
+	}
+	get y() {
+		return this[1];
+	}
+	get r() {
+		return this[0];
+	}
+	get g() {
+		return this[1];
+	}
+	get b() {
+		return this[2];
+	}
+	get a() {
+		return this[3];
+	}
+	set r(value) {
+		this[0] = value;
+	}
+	set g(value) {
+		this[1] = value;
+	}
+	set b(value) {
+		this[2] = value;
+	}
+	set a(value) {
+		this[3] = value;
+	}
+	get z() {
+		return this[2];
+	}
+	get w() {
+		return this[3];
+	}
+	set x(value) {
+		this[0] = value;
+	}
+	set y(value) {
+		this[1] = value;
+	}
+	set z(value) {
+		this[2] = value;
+	}
+	set w(value) {
+		this[3] = value;
+	}
+};
+var Vec2fImpl = class Vec2fImpl extends Vec2 {
+	get [$internal]() {
+		return { elementSchema: f32 };
+	}
+	get kind() {
+		return "vec2f";
+	}
+	get _Vec2() {
+		return Vec2fImpl;
+	}
+	get _Vec3() {
+		return Vec3fImpl;
+	}
+	get _Vec4() {
+		return Vec4fImpl;
+	}
+};
+var Vec2hImpl = class Vec2hImpl extends Vec2 {
+	get [$internal]() {
+		return { elementSchema: f16 };
+	}
+	get kind() {
+		return "vec2h";
+	}
+	get _Vec2() {
+		return Vec2hImpl;
+	}
+	get _Vec3() {
+		return Vec3hImpl;
+	}
+	get _Vec4() {
+		return Vec4hImpl;
+	}
+};
+var Vec2iImpl = class Vec2iImpl extends Vec2 {
+	get [$internal]() {
+		return { elementSchema: i32 };
+	}
+	get kind() {
+		return "vec2i";
+	}
+	get _Vec2() {
+		return Vec2iImpl;
+	}
+	get _Vec3() {
+		return Vec3iImpl;
+	}
+	get _Vec4() {
+		return Vec4iImpl;
+	}
+};
+var Vec2uImpl = class Vec2uImpl extends Vec2 {
+	get [$internal]() {
+		return { elementSchema: u32 };
+	}
+	get kind() {
+		return "vec2u";
+	}
+	get _Vec2() {
+		return Vec2uImpl;
+	}
+	get _Vec3() {
+		return Vec3uImpl;
+	}
+	get _Vec4() {
+		return Vec4uImpl;
+	}
+};
+var Vec2bImpl = class Vec2bImpl extends Vec2 {
+	get [$internal]() {
+		return { elementSchema: bool };
+	}
+	get kind() {
+		return "vec2<bool>";
+	}
+	get _Vec2() {
+		return Vec2bImpl;
+	}
+	get _Vec3() {
+		return Vec3bImpl;
+	}
+	get _Vec4() {
+		return Vec4bImpl;
+	}
+};
+var Vec3fImpl = class Vec3fImpl extends Vec3 {
+	get [$internal]() {
+		return { elementSchema: f32 };
+	}
+	get kind() {
+		return "vec3f";
+	}
+	get _Vec2() {
+		return Vec2fImpl;
+	}
+	get _Vec3() {
+		return Vec3fImpl;
+	}
+	get _Vec4() {
+		return Vec4fImpl;
+	}
+};
+var Vec3hImpl = class Vec3hImpl extends Vec3 {
+	get [$internal]() {
+		return { elementSchema: f16 };
+	}
+	get kind() {
+		return "vec3h";
+	}
+	get _Vec2() {
+		return Vec2hImpl;
+	}
+	get _Vec3() {
+		return Vec3hImpl;
+	}
+	get _Vec4() {
+		return Vec4hImpl;
+	}
+};
+var Vec3iImpl = class Vec3iImpl extends Vec3 {
+	get [$internal]() {
+		return { elementSchema: i32 };
+	}
+	get kind() {
+		return "vec3i";
+	}
+	get _Vec2() {
+		return Vec2iImpl;
+	}
+	get _Vec3() {
+		return Vec3iImpl;
+	}
+	get _Vec4() {
+		return Vec4iImpl;
+	}
+};
+var Vec3uImpl = class Vec3uImpl extends Vec3 {
+	get [$internal]() {
+		return { elementSchema: u32 };
+	}
+	get kind() {
+		return "vec3u";
+	}
+	get _Vec2() {
+		return Vec2uImpl;
+	}
+	get _Vec3() {
+		return Vec3uImpl;
+	}
+	get _Vec4() {
+		return Vec4uImpl;
+	}
+};
+var Vec3bImpl = class Vec3bImpl extends Vec3 {
+	get [$internal]() {
+		return { elementSchema: bool };
+	}
+	get kind() {
+		return "vec3<bool>";
+	}
+	get _Vec2() {
+		return Vec2bImpl;
+	}
+	get _Vec3() {
+		return Vec3bImpl;
+	}
+	get _Vec4() {
+		return Vec4bImpl;
+	}
+};
+var Vec4fImpl = class Vec4fImpl extends Vec4 {
+	get [$internal]() {
+		return { elementSchema: f32 };
+	}
+	get kind() {
+		return "vec4f";
+	}
+	get _Vec2() {
+		return Vec2fImpl;
+	}
+	get _Vec3() {
+		return Vec3fImpl;
+	}
+	get _Vec4() {
+		return Vec4fImpl;
+	}
+};
+var Vec4hImpl = class Vec4hImpl extends Vec4 {
+	get [$internal]() {
+		return { elementSchema: f16 };
+	}
+	get kind() {
+		return "vec4h";
+	}
+	get _Vec2() {
+		return Vec2hImpl;
+	}
+	get _Vec3() {
+		return Vec3hImpl;
+	}
+	get _Vec4() {
+		return Vec4hImpl;
+	}
+};
+var Vec4iImpl = class Vec4iImpl extends Vec4 {
+	get [$internal]() {
+		return { elementSchema: i32 };
+	}
+	get kind() {
+		return "vec4i";
+	}
+	get _Vec2() {
+		return Vec2iImpl;
+	}
+	get _Vec3() {
+		return Vec3iImpl;
+	}
+	get _Vec4() {
+		return Vec4iImpl;
+	}
+};
+var Vec4uImpl = class Vec4uImpl extends Vec4 {
+	get [$internal]() {
+		return { elementSchema: u32 };
+	}
+	get kind() {
+		return "vec4u";
+	}
+	get _Vec2() {
+		return Vec2uImpl;
+	}
+	get _Vec3() {
+		return Vec3uImpl;
+	}
+	get _Vec4() {
+		return Vec4uImpl;
+	}
+};
+var Vec4bImpl = class Vec4bImpl extends Vec4 {
+	get [$internal]() {
+		return { elementSchema: bool };
+	}
+	get kind() {
+		return "vec4<bool>";
+	}
+	get _Vec2() {
+		return Vec2bImpl;
+	}
+	get _Vec3() {
+		return Vec3bImpl;
+	}
+	get _Vec4() {
+		return Vec4bImpl;
+	}
+};
+
+//#endregion
+//#region src/data/vector.ts
+/**
+* Schema representing vec2f - a vector with 2 elements of type f32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec2f(); // (0.0, 0.0)
+* const vector = d.vec2f(1); // (1.0, 1.0)
+* const vector = d.vec2f(0.5, 0.1); // (0.5, 0.1)
+*
+* @example
+* const buffer = root.createBuffer(d.vec2f, d.vec2f(0, 1)); // buffer holding a d.vec2f value, with an initial value of vec2f(0, 1);
+*/
+const vec2f$1 = makeVecSchema(Vec2fImpl, f32);
+/**
+* Schema representing vec2h - a vector with 2 elements of type f16.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec2h(); // (0.0, 0.0)
+* const vector = d.vec2h(1); // (1.0, 1.0)
+* const vector = d.vec2h(0.5, 0.1); // (0.5, 0.1)
+*
+* @example
+* const buffer = root.createBuffer(d.vec2h, d.vec2h(0, 1)); // buffer holding a d.vec2h value, with an initial value of vec2h(0, 1);
+*/
+const vec2h$1 = makeVecSchema(Vec2hImpl, f16);
+/**
+* Schema representing vec2i - a vector with 2 elements of type i32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec2i(); // (0, 0)
+* const vector = d.vec2i(1); // (1, 1)
+* const vector = d.vec2i(-1, 1); // (-1, 1)
+*
+* @example
+* const buffer = root.createBuffer(d.vec2i, d.vec2i(0, 1)); // buffer holding a d.vec2i value, with an initial value of vec2i(0, 1);
+*/
+const vec2i$1 = makeVecSchema(Vec2iImpl, i32);
+/**
+* Schema representing vec2u - a vector with 2 elements of type u32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec2u(); // (0, 0)
+* const vector = d.vec2u(1); // (1, 1)
+* const vector = d.vec2u(1, 2); // (1, 2)
+*
+* @example
+* const buffer = root.createBuffer(d.vec2u, d.vec2u(0, 1)); // buffer holding a d.vec2u value, with an initial value of vec2u(0, 1);
+*/
+const vec2u$1 = makeVecSchema(Vec2uImpl, u32);
+/**
+* Schema representing `vec2<bool>` - a vector with 2 elements of type `bool`.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec2b(); // (false, false)
+* const vector = d.vec2b(true); // (true, true)
+* const vector = d.vec2b(false, true); // (false, true)
+*/
+const vec2b$1 = makeVecSchema(Vec2bImpl, bool);
+/**
+* Schema representing vec3f - a vector with 3 elements of type f32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec3f(); // (0.0, 0.0, 0.0)
+* const vector = d.vec3f(1); // (1.0, 1.0, 1.0)
+* const vector = d.vec3f(1, 2, 3.5); // (1.0, 2.0, 3.5)
+*
+* @example
+* const buffer = root.createBuffer(d.vec3f, d.vec3f(0, 1, 2)); // buffer holding a d.vec3f value, with an initial value of vec3f(0, 1, 2);
+*/
+const vec3f$1 = makeVecSchema(Vec3fImpl, f32);
+/**
+* Schema representing vec3h - a vector with 3 elements of type f16.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec3h(); // (0.0, 0.0, 0.0)
+* const vector = d.vec3h(1); // (1.0, 1.0, 1.0)
+* const vector = d.vec3h(1, 2, 3.5); // (1.0, 2.0, 3.5)
+*
+* @example
+* const buffer = root.createBuffer(d.vec3h, d.vec3h(0, 1, 2)); // buffer holding a d.vec3h value, with an initial value of vec3h(0, 1, 2);
+*/
+const vec3h$1 = makeVecSchema(Vec3hImpl, f16);
+/**
+* Schema representing vec3i - a vector with 3 elements of type i32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec3i(); // (0, 0, 0)
+* const vector = d.vec3i(1); // (1, 1, 1)
+* const vector = d.vec3i(1, 2, -3); // (1, 2, -3)
+*
+* @example
+* const buffer = root.createBuffer(d.vec3i, d.vec3i(0, 1, 2)); // buffer holding a d.vec3i value, with an initial value of vec3i(0, 1, 2);
+*/
+const vec3i$1 = makeVecSchema(Vec3iImpl, i32);
+/**
+* Schema representing vec3u - a vector with 3 elements of type u32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec3u(); // (0, 0, 0)
+* const vector = d.vec3u(1); // (1, 1, 1)
+* const vector = d.vec3u(1, 2, 3); // (1, 2, 3)
+*
+* @example
+* const buffer = root.createBuffer(d.vec3u, d.vec3u(0, 1, 2)); // buffer holding a d.vec3u value, with an initial value of vec3u(0, 1, 2);
+*/
+const vec3u$1 = makeVecSchema(Vec3uImpl, u32);
+/**
+* Schema representing `vec3<bool>` - a vector with 3 elements of type `bool`.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec3b(); // (false, false, false)
+* const vector = d.vec3b(true); // (true, true, true)
+* const vector = d.vec3b(false, true, false); // (false, true, false)
+*/
+const vec3b$1 = makeVecSchema(Vec3bImpl, bool);
+/**
+* Schema representing vec4f - a vector with 4 elements of type f32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec4f(); // (0.0, 0.0, 0.0, 0.0)
+* const vector = d.vec4f(1); // (1.0, 1.0, 1.0, 1.0)
+* const vector = d.vec4f(1, 2, 3, 4.5); // (1.0, 2.0, 3.0, 4.5)
+*
+* @example
+* const buffer = root.createBuffer(d.vec4f, d.vec4f(0, 1, 2, 3)); // buffer holding a d.vec4f value, with an initial value of vec4f(0, 1, 2, 3);
+*/
+const vec4f$1 = makeVecSchema(Vec4fImpl, f32);
+/**
+* Schema representing vec4h - a vector with 4 elements of type f16.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec4h(); // (0.0, 0.0, 0.0, 0.0)
+* const vector = d.vec4h(1); // (1.0, 1.0, 1.0, 1.0)
+* const vector = d.vec4h(1, 2, 3, 4.5); // (1.0, 2.0, 3.0, 4.5)
+*
+* @example
+* const buffer = root.createBuffer(d.vec4h, d.vec4h(0, 1, 2, 3)); // buffer holding a d.vec4h value, with an initial value of vec4h(0, 1, 2, 3);
+*/
+const vec4h$1 = makeVecSchema(Vec4hImpl, f16);
+/**
+* Schema representing vec4i - a vector with 4 elements of type i32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec4i(); // (0, 0, 0, 0)
+* const vector = d.vec4i(1); // (1, 1, 1, 1)
+* const vector = d.vec4i(1, 2, 3, -4); // (1, 2, 3, -4)
+*
+* @example
+* const buffer = root.createBuffer(d.vec4i, d.vec4i(0, 1, 2, 3)); // buffer holding a d.vec4i value, with an initial value of vec4i(0, 1, 2, 3);
+*/
+const vec4i$1 = makeVecSchema(Vec4iImpl, i32);
+/**
+* Schema representing vec4u - a vector with 4 elements of type u32.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec4u(); // (0, 0, 0, 0)
+* const vector = d.vec4u(1); // (1, 1, 1, 1)
+* const vector = d.vec4u(1, 2, 3, 4); // (1, 2, 3, 4)
+*
+* @example
+* const buffer = root.createBuffer(d.vec4u, d.vec4u(0, 1, 2, 3)); // buffer holding a d.vec4u value, with an initial value of vec4u(0, 1, 2, 3);
+*/
+const vec4u$1 = makeVecSchema(Vec4uImpl, u32);
+/**
+* Schema representing `vec4<bool>` - a vector with 4 elements of type `bool`.
+* Also a constructor function for this vector value.
+*
+* @example
+* const vector = d.vec4b(); // (false, false, false, false)
+* const vector = d.vec4b(true); // (true, true, true, true)
+* const vector = d.vec4b(false, true, false, true); // (false, true, false, true)
+*/
+const vec4b$1 = makeVecSchema(Vec4bImpl, bool);
+const vecTypeToConstructor = {
+	vec2f: vec2f$1,
+	vec2h: vec2h$1,
+	vec2i: vec2i$1,
+	vec2u: vec2u$1,
+	"vec2<bool>": vec2b$1,
+	vec3f: vec3f$1,
+	vec3h: vec3h$1,
+	vec3i: vec3i$1,
+	vec3u: vec3u$1,
+	"vec3<bool>": vec3b$1,
+	vec4f: vec4f$1,
+	vec4h: vec4h$1,
+	vec4i: vec4i$1,
+	vec4u: vec4u$1,
+	"vec4<bool>": vec4b$1
+};
+function makeVecSchema(VecImpl, primitive) {
+	const { kind: type, length } = new VecImpl();
+	const componentCount = length;
+	const cpuConstruct = (...args) => {
+		const values = Array.from({ length: args.length });
+		let j = 0;
+		for (const arg of args) if (typeof arg === "number" || typeof arg === "boolean") values[j++] = arg;
+		else for (let c = 0; c < arg.length; ++c) values[j++] = arg[c];
+		if (values.length <= 1 || values.length === componentCount) return new VecImpl(...values);
+		throw new Error(`'${type}' constructor called with invalid number of arguments.`);
+	};
+	const construct = callableSchema({
+		name: type,
+		signature: (...args) => ({
+			argTypes: args.map((arg) => isVec(arg) ? arg : primitive),
+			returnType: schema
+		}),
+		normalImpl: cpuConstruct,
+		codegenImpl: (_ctx, args) => {
+			if (args.length === 1 && args[0]?.dataType === schema) return stitch`${args[0]}`;
+			return stitch`${type}(${args})`;
+		}
+	});
+	const schema = Object.assign(construct, {
+		[$internal]: {},
+		type,
+		primitive,
+		componentCount,
+		[$repr]: void 0
+	});
+	VecImpl.prototype.schema = schema;
+	return schema;
+}
+
+//#endregion
+//#region src/nameRegistry.ts
+const bannedTokens = new Set([
+	"alias",
+	"break",
+	"case",
+	"const",
+	"const_assert",
+	"continue",
+	"continuing",
+	"default",
+	"diagnostic",
+	"discard",
+	"else",
+	"enable",
+	"false",
+	"fn",
+	"for",
+	"if",
+	"let",
+	"loop",
+	"override",
+	"requires",
+	"return",
+	"struct",
+	"switch",
+	"true",
+	"var",
+	"while",
+	"NULL",
+	"Self",
+	"abstract",
+	"active",
+	"alignas",
+	"alignof",
+	"as",
+	"asm",
+	"asm_fragment",
+	"async",
+	"attribute",
+	"auto",
+	"await",
+	"become",
+	"cast",
+	"catch",
+	"class",
+	"co_await",
+	"co_return",
+	"co_yield",
+	"coherent",
+	"column_major",
+	"common",
+	"compile",
+	"compile_fragment",
+	"concept",
+	"const_cast",
+	"consteval",
+	"constexpr",
+	"constinit",
+	"crate",
+	"debugger",
+	"decltype",
+	"delete",
+	"demote",
+	"demote_to_helper",
+	"do",
+	"dynamic_cast",
+	"enum",
+	"explicit",
+	"export",
+	"extends",
+	"extern",
+	"external",
+	"fallthrough",
+	"filter",
+	"final",
+	"finally",
+	"friend",
+	"from",
+	"fxgroup",
+	"get",
+	"goto",
+	"groupshared",
+	"highp",
+	"impl",
+	"implements",
+	"import",
+	"inline",
+	"instanceof",
+	"interface",
+	"layout",
+	"lowp",
+	"macro",
+	"macro_rules",
+	"match",
+	"mediump",
+	"meta",
+	"mod",
+	"module",
+	"move",
+	"mut",
+	"mutable",
+	"namespace",
+	"new",
+	"nil",
+	"noexcept",
+	"noinline",
+	"nointerpolation",
+	"non_coherent",
+	"noncoherent",
+	"noperspective",
+	"null",
+	"nullptr",
+	"of",
+	"operator",
+	"package",
+	"packoffset",
+	"partition",
+	"pass",
+	"patch",
+	"pixelfragment",
+	"precise",
+	"precision",
+	"premerge",
+	"priv",
+	"protected",
+	"pub",
+	"public",
+	"readonly",
+	"ref",
+	"regardless",
+	"register",
+	"reinterpret_cast",
+	"require",
+	"resource",
+	"restrict",
+	"self",
+	"set",
+	"shared",
+	"sizeof",
+	"smooth",
+	"snorm",
+	"static",
+	"static_assert",
+	"static_cast",
+	"std",
+	"subroutine",
+	"super",
+	"target",
+	"template",
+	"this",
+	"thread_local",
+	"throw",
+	"trait",
+	"try",
+	"type",
+	"typedef",
+	"typeid",
+	"typename",
+	"typeof",
+	"union",
+	"unless",
+	"unorm",
+	"unsafe",
+	"unsized",
+	"use",
+	"using",
+	"varying",
+	"virtual",
+	"volatile",
+	"wgsl",
+	"where",
+	"with",
+	"writeonly",
+	"yield",
+	"sampler",
+	"uniform",
+	"storage"
+]);
+const builtins = new Set([
+	"array",
+	"bool",
+	"f16",
+	"f32",
+	"i32",
+	"u32",
+	"mat2x2",
+	"mat2x3",
+	"mat2x4",
+	"mat3x2",
+	"mat3x3",
+	"mat3x4",
+	"mat4x2",
+	"mat4x3",
+	"mat4x4",
+	"vec2",
+	"vec3",
+	"vec4",
+	"bitcast",
+	"all",
+	"any",
+	"select",
+	"arrayLength",
+	"abs",
+	"acos",
+	"acosh",
+	"asin",
+	"asinh",
+	"atan",
+	"atanh",
+	"atan2",
+	"ceil",
+	"clamp",
+	"cos",
+	"cosh",
+	"countLeadingZeros",
+	"countOneBits",
+	"countTrailingZeros",
+	"cross",
+	"degrees",
+	"determinant",
+	"distance",
+	"dot",
+	"dot4U8Packed",
+	"dot4I8Packed",
+	"exp",
+	"exp2",
+	"extractBits",
+	"faceForward",
+	"firstLeadingBit",
+	"firstTrailingBit",
+	"floor",
+	"fma",
+	"fract",
+	"frexp",
+	"insertBits",
+	"inverseSqrt",
+	"ldexp",
+	"length",
+	"log",
+	"log2",
+	"max",
+	"min",
+	"mix",
+	"modf",
+	"normalize",
+	"pow",
+	"quantizeToF16",
+	"radians",
+	"reflect",
+	"refract",
+	"reverseBits",
+	"round",
+	"saturate",
+	"sign",
+	"sin",
+	"sinh",
+	"smoothstep",
+	"sqrt",
+	"step",
+	"tan",
+	"tanh",
+	"transpose",
+	"trunc",
+	"dpdx",
+	"dpdxCoarse",
+	"dpdxFine",
+	"dpdy",
+	"dpdyCoarse",
+	"dpdyFine",
+	"fwidth",
+	"fwidthCoarse",
+	"fwidthFine",
+	"textureDimensions",
+	"textureGather",
+	"textureGatherCompare",
+	"textureLoad",
+	"textureNumLayers",
+	"textureNumLevels",
+	"textureNumSamples",
+	"textureSample",
+	"textureSampleBias",
+	"textureSampleCompare",
+	"textureSampleCompareLevel",
+	"textureSampleGrad",
+	"textureSampleLevel",
+	"textureSampleBaseClampToEdge",
+	"textureStore",
+	"atomicLoad",
+	"atomicStore",
+	"atomicAdd",
+	"atomicSub",
+	"atomicMax",
+	"atomicMin",
+	"atomicAnd",
+	"atomicOr",
+	"atomicXor",
+	"atomicExchange",
+	"atomicCompareExchangeWeak",
+	"pack4x8snorm",
+	"pack4x8unorm",
+	"pack4xI8",
+	"pack4xU8",
+	"pack4xI8Clamp",
+	"pack4xU8Clamp",
+	"pack2x16snorm",
+	"pack2x16unorm",
+	"pack2x16float",
+	"unpack4x8snorm",
+	"unpack4x8unorm",
+	"unpack4xI8",
+	"unpack4xU8",
+	"unpack2x16snorm",
+	"unpack2x16unorm",
+	"unpack2x16float",
+	"storageBarrier",
+	"textureBarrier",
+	"workgroupBarrier",
+	"workgroupUniformLoad",
+	"subgroupAdd",
+	"subgroupExclusiveAdd",
+	"subgroupInclusiveAdd",
+	"subgroupAll",
+	"subgroupAnd",
+	"subgroupAny",
+	"subgroupBallot",
+	"subgroupBroadcast",
+	"subgroupBroadcastFirst",
+	"subgroupElect",
+	"subgroupMax",
+	"subgroupMin",
+	"subgroupMul",
+	"subgroupExclusiveMul",
+	"subgroupInclusiveMul",
+	"subgroupOr",
+	"subgroupShuffle",
+	"subgroupShuffleDown",
+	"subgroupShuffleUp",
+	"subgroupShuffleXor",
+	"subgroupXor",
+	"quadBroadcast",
+	"quadSwapDiagonal",
+	"quadSwapX",
+	"quadSwapY"
+]);
+function sanitizePrimer(primer) {
+	if (primer) return primer.replaceAll(/\s/g, "_").replaceAll(/[^\w\d]/g, "");
+	return "item";
+}
+/**
+* A function for checking whether an identifier needs renaming.
+* Throws if provided with an invalid identifier that cannot be easily renamed.
+* @example
+* isValidIdentifier("ident"); // true
+* isValidIdentifier("struct"); // false
+* isValidIdentifier("struct_1"); // false
+* isValidIdentifier("_"); // ERROR
+* isValidIdentifier("my variable"); // ERROR
+*/
+function isValidIdentifier(ident) {
+	if (ident === "_" || ident.startsWith("__") || /\s/.test(ident)) throw new Error(`Invalid identifier '${ident}'. Choose an identifier without whitespaces or leading underscores.`);
+	const prefix = ident.split("_")[0];
+	return !bannedTokens.has(prefix) && !builtins.has(prefix);
+}
+/**
+* Same as `isValidIdentifier`, except does not check for builtin clashes.
+*/
+function isValidProp(ident) {
+	if (ident === "_" || ident.startsWith("__") || /\s/.test(ident)) throw new Error(`Invalid identifier '${ident}'. Choose an identifier without whitespaces or leading underscores.`);
+	const prefix = ident.split("_")[0];
+	return !bannedTokens.has(prefix);
+}
+var NameRegistryImpl = class {
+	#usedNames;
+	#scopeStack;
+	constructor() {
+		this.#usedNames = new Set([...bannedTokens, ...builtins]);
+		this.#scopeStack = [];
+	}
+	get #usedBlockScopeNames() {
+		return this.#scopeStack[this.#scopeStack.length - 1]?.usedBlockScopeNames;
+	}
+	makeUnique(primer, global) {
+		const sanitizedPrimer = sanitizePrimer(primer);
+		const name = this.getUniqueVariant(sanitizedPrimer);
+		if (global) this.#usedNames.add(name);
+		else this.#usedBlockScopeNames?.add(name);
+		return name;
+	}
+	#isUsedInBlocksBefore(name) {
+		const functionScopeIndex = this.#scopeStack.findLastIndex((scope) => scope.type === "functionScope");
+		return this.#scopeStack.slice(functionScopeIndex + 1).some((scope) => scope.usedBlockScopeNames.has(name));
+	}
+	makeValid(primer) {
+		if (isValidIdentifier(primer) && !this.#usedNames.has(primer) && !this.#isUsedInBlocksBefore(primer)) {
+			this.#usedBlockScopeNames?.add(primer);
+			return primer;
+		}
+		return this.makeUnique(primer, false);
+	}
+	isUsed(name) {
+		return this.#usedNames.has(name) || this.#isUsedInBlocksBefore(name);
+	}
+	pushFunctionScope() {
+		this.#scopeStack.push({ type: "functionScope" });
+		this.#scopeStack.push({
+			type: "blockScope",
+			usedBlockScopeNames: /* @__PURE__ */ new Set()
+		});
+	}
+	popFunctionScope() {
+		const functionScopeIndex = this.#scopeStack.findLastIndex((scope) => scope.type === "functionScope");
+		if (functionScopeIndex === -1) throw new Error("Tried to pop function scope when no scope was present.");
+		this.#scopeStack.splice(functionScopeIndex);
+	}
+	pushBlockScope() {
+		this.#scopeStack.push({
+			type: "blockScope",
+			usedBlockScopeNames: /* @__PURE__ */ new Set()
+		});
+	}
+	popBlockScope() {
+		invariant(this.#scopeStack[this.#scopeStack.length - 1]?.type === "blockScope", "Tried to pop block scope, but it is not present");
+		this.#scopeStack.pop();
+	}
+};
+var RandomNameRegistry = class extends NameRegistryImpl {
+	#lastUniqueId = 0;
+	getUniqueVariant(base) {
+		let name = `${base}_${this.#lastUniqueId++}`;
+		while (this.isUsed(name)) name = `${base}_${this.#lastUniqueId++}`;
+		return name;
+	}
+};
+var StrictNameRegistry = class extends NameRegistryImpl {
+	getUniqueVariant(base) {
+		let index = 0;
+		let name = base;
+		while (this.isUsed(name)) {
+			index++;
+			name = `${base}_${index}`;
+		}
+		return name;
+	}
+};
+
+//#endregion
+//#region src/data/struct.ts
+/**
+* Creates a struct schema that can be used to construct GPU buffers.
+* Ensures proper alignment and padding of properties (as opposed to a `d.unstruct` schema).
+* The order of members matches the passed in properties object.
+*
+* @example
+* const CircleStruct = d.struct({ radius: d.f32, pos: d.vec3f });
+*
+* @param props Record with `string` keys and `TgpuData` values,
+* each entry describing one struct member.
+*/
+function struct(props) {
+	return INTERNAL_createStruct(props, false);
+}
+function abstruct(props) {
+	return INTERNAL_createStruct(props, true);
+}
+function INTERNAL_createStruct(props, isAbstruct) {
+	Object.keys(props).forEach((key) => {
+		if (!isValidProp(key)) throw new Error(`Property key '${key}' is a reserved WGSL word. Choose a different name.`);
+	});
+	const structSchema = (instanceProps) => Object.fromEntries(Object.entries(props).map(([key, schema]) => [key, schemaCallWrapper(schema, instanceProps?.[key])]));
+	Object.setPrototypeOf(structSchema, WgslStructImpl);
+	structSchema.propTypes = props;
+	Object.defineProperty(structSchema, $internal, { value: { isAbstruct } });
+	return structSchema;
+}
+const WgslStructImpl = {
+	type: "struct",
+	$name(label) {
+		setName(this, label);
+		return this;
+	},
+	toString() {
+		return `struct:${getName(this) ?? "<unnamed>"}`;
+	}
+};
+
+//#endregion
+//#region src/tgsl/generationHelpers.ts
+function numericLiteralToSnippet(value) {
+	if (value >= 2 ** 63 || value < -(2 ** 63)) return snip(value, abstractFloat, "constant");
+	if (Number.isInteger(value)) {
+		if (!Number.isSafeInteger(value)) console.warn(`The integer ${value} exceeds the safe integer range and may have lost precision.`);
+		return snip(value, abstractInt, "constant");
+	}
+	return snip(value, abstractFloat, "constant");
+}
+function concretize(type) {
+	if (type.type === "abstractFloat") return f32;
+	if (type.type === "abstractInt") return i32;
+	return type;
+}
+function concretizeSnippet(snippet) {
+	return snip(snippet.value, concretize(snippet.dataType), snippet.origin);
+}
+function concretizeSnippets(args) {
+	return args.map(concretizeSnippet);
+}
+function coerceToSnippet(value) {
+	if (isSnippet(value)) return value;
+	if (isRef(value)) throw new Error("Cannot use refs (d.ref(...)) from the outer scope.");
+	const ownSnippet = getOwnSnippet(value);
+	if (ownSnippet) return ownSnippet;
+	if (isVecInstance(value) || isMatInstance(value)) return snip(value, WORKAROUND_getSchema(value), "constant");
+	if (typeof value === "string" || typeof value === "function" || typeof value === "object" || typeof value === "symbol" || typeof value === "undefined" || value === null) return snip(value, UnknownData, "constant");
+	if (typeof value === "number") return numericLiteralToSnippet(value);
+	if (typeof value === "boolean") return snip(value, bool, "constant");
+	return snip(value, UnknownData, "constant");
+}
+/**
+* Intermediate representation for WGSL array expressions.
+* Defers resolution. Stores array elements as snippets so the
+* generator can access them when needed.
+*/
+var ArrayExpression = class {
+	[$internal] = true;
+	constructor(type, elements) {
+		this.type = type;
+		this.elements = elements;
+	}
+	toString() {
+		return "ArrayExpression";
+	}
+	[$resolve](ctx) {
+		for (const elem of this.elements) if (elem.origin === "argument" && !isNaturallyEphemeral(elem.dataType) || !isEphemeralSnippet(elem)) {
+			const snippetStr = ctx.resolve(elem.value, elem.dataType).value;
+			const snippetType = ctx.resolve(concretize(elem.dataType)).value;
+			throw new WgslTypeError(`'${snippetStr}' reference cannot be used in an array constructor.\n-----\nTry '${snippetType}(${snippetStr})' or 'arrayOf(${snippetType}, count)([...])' to copy the value instead.\n-----`);
+		}
+		return snip(stitch`${`array<${ctx.resolve(this.type.elementType).value}, ${this.elements.length}>`}(${this.elements})`, this.type, "runtime");
+	}
+};
+
+//#endregion
+//#region src/core/function/dualImpl.ts
+var MissingCpuImplError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+	}
+};
+function dualImpl(options) {
+	const impl = ((...args) => {
+		if (typeof options.normalImpl === "string") throw new MissingCpuImplError(options.normalImpl);
+		return options.normalImpl(...args);
+	});
+	setName(impl, options.name);
+	impl.toString = () => options.name ?? "<unknown>";
+	impl[$gpuCallable] = {
+		get strictSignature() {
+			return typeof options.signature !== "function" ? options.signature : void 0;
+		},
+		call(ctx, args) {
+			const { argTypes, returnType } = typeof options.signature === "function" ? options.signature(...args.map((s) => {
+				if (isPtr(s.dataType) && s.dataType.implicit) return s.dataType.inner;
+				return s.dataType;
+			})) : options.signature;
+			const converted = args.map((s, idx) => {
+				const argType = argTypes[idx];
+				if (!argType) throw new Error("Function called with invalid arguments");
+				return tryConvertSnippet(ctx, s, argType, !options.ignoreImplicitCastWarning);
+			});
+			if (!options.noComptime && converted.every((s) => isKnownAtComptime(s)) && typeof options.normalImpl === "function") {
+				ctx.pushMode(new NormalState());
+				try {
+					return snip(options.normalImpl(...converted.map((s) => s.value)), returnType, "constant");
+				} catch (e) {
+					if (!(e instanceof MissingCpuImplError)) throw e;
+				} finally {
+					ctx.popMode("normal");
+				}
+			}
+			return snip(options.codegenImpl(ctx, converted), concretize(returnType), "runtime");
+		}
+	};
+	return impl;
+}
+
+//#endregion
+//#region src/core/function/comptime.ts
+/**
+* Creates a version of `func` that can called safely in a TypeGPU function to
+* precompute and inject a value into the final shader code.
+*
+* Note how the function passed into `comptime` doesn't have to be marked with
+* 'use gpu'. That's because the function doesn't execute on the GPU, it gets
+* executed before the shader code gets sent to the GPU.
+*
+* @example
+* ```ts
+* const color = tgpu.comptime((int: number) => {
+*   const r = (int >> 16) & 0xff;
+*   const g = (int >> 8) & 0xff;
+*   const b = int & 0xff;
+*   return d.vec3f(r / 255, g / 255, b / 255);
+* });
+*
+* const material = (diffuse: d.v3f): d.v3f => {
+*   'use gpu';
+*   const albedo = color(0xff00ff);
+*   return albedo.mul(diffuse);
+* };
+* ```
+*/
+function comptime(func) {
+	const impl = ((...args) => {
+		return func(...args);
+	});
+	impl.toString = () => "comptime";
+	impl[$getNameForward] = func;
+	impl[$gpuCallable] = { call(_ctx, args) {
+		if (!args.every((s) => isKnownAtComptime(s))) throw new WgslTypeError(`Called comptime function with runtime-known values: ${args.filter((s) => !isKnownAtComptime(s)).map((s) => `'${s.value}'`).join(", ")}`);
+		return coerceToSnippet(func(...args.map((s) => s.value)));
+	} };
+	impl.$name = (label) => {
+		setName(func, label);
+		return impl;
+	};
+	Object.defineProperty(impl, $internal, { value: { isComptime: true } });
+	return impl;
+}
+
+//#endregion
+//#region src/data/matrix.ts
+var MatBase = class {};
+function createMatSchema(options) {
+	const construct = callableSchema({
+		name: options.type,
+		normalImpl: (...args) => {
+			const elements = [];
+			for (const arg of args) if (typeof arg === "number") elements.push(arg);
+			else for (let i = 0; i < arg.length; ++i) elements.push(arg[i]);
+			if (elements.length !== 0 && elements.length !== options.columns * options.rows) throw new Error(`'${options.type}' constructor called with invalid number of arguments.`);
+			for (let i = elements.length; i < options.columns * options.rows; ++i) elements.push(0);
+			return new options.MatImpl(...elements);
+		},
+		signature: (...args) => ({
+			argTypes: args.map((arg) => isVec(arg) ? arg : f32),
+			returnType: schema
+		}),
+		codegenImpl: (_ctx, args) => stitch`${options.type}(${args})`
+	});
+	const schema = Object.assign(construct, {
+		[$internal]: {},
+		type: options.type,
+		primitive: f32,
+		identity: identityFunctions[options.columns],
+		translation: options.columns === 4 ? translation4 : void 0,
+		scaling: options.columns === 4 ? scaling4 : void 0,
+		rotationX: options.columns === 4 ? rotationX4 : void 0,
+		rotationY: options.columns === 4 ? rotationY4 : void 0,
+		rotationZ: options.columns === 4 ? rotationZ4 : void 0
+	});
+	options.MatImpl.prototype.schema = schema;
+	return schema;
+}
+var mat2x2Impl = class extends MatBase {
+	[$internal] = true;
+	columns;
+	length = 4;
+	constructor(...elements) {
+		super();
+		this.columns = [this.makeColumn(elements[0], elements[1]), this.makeColumn(elements[2], elements[3])];
+	}
+	get 0() {
+		return this.columns[0].x;
+	}
+	get 1() {
+		return this.columns[0].y;
+	}
+	get 2() {
+		return this.columns[1].x;
+	}
+	get 3() {
+		return this.columns[1].y;
+	}
+	set 0(value) {
+		this.columns[0].x = value;
+	}
+	set 1(value) {
+		this.columns[0].y = value;
+	}
+	set 2(value) {
+		this.columns[1].x = value;
+	}
+	set 3(value) {
+		this.columns[1].y = value;
+	}
+	*[Symbol.iterator]() {
+		yield this[0];
+		yield this[1];
+		yield this[2];
+		yield this[3];
+	}
+	[$resolve]() {
+		return snip(`${this.kind}(${Array.from({ length: this.length }).map((_, i) => this[i]).join(", ")})`, mat2x2f, "runtime");
+	}
+	toString() {
+		return this[$resolve]().value;
+	}
+};
+var mat2x2fImpl = class extends mat2x2Impl {
+	kind = "mat2x2f";
+	makeColumn(e0, e1) {
+		return vec2f$1(e0, e1);
+	}
+};
+var mat3x3Impl = class extends MatBase {
+	[$internal] = true;
+	columns;
+	length = 12;
+	constructor(...elements) {
+		super();
+		this.columns = [
+			this.makeColumn(elements[0], elements[1], elements[2]),
+			this.makeColumn(elements[3], elements[4], elements[5]),
+			this.makeColumn(elements[6], elements[7], elements[8])
+		];
+	}
+	get 0() {
+		return this.columns[0].x;
+	}
+	get 1() {
+		return this.columns[0].y;
+	}
+	get 2() {
+		return this.columns[0].z;
+	}
+	get 3() {
+		return 0;
+	}
+	get 4() {
+		return this.columns[1].x;
+	}
+	get 5() {
+		return this.columns[1].y;
+	}
+	get 6() {
+		return this.columns[1].z;
+	}
+	get 7() {
+		return 0;
+	}
+	get 8() {
+		return this.columns[2].x;
+	}
+	get 9() {
+		return this.columns[2].y;
+	}
+	get 10() {
+		return this.columns[2].z;
+	}
+	get 11() {
+		return 0;
+	}
+	set 0(value) {
+		this.columns[0].x = value;
+	}
+	set 1(value) {
+		this.columns[0].y = value;
+	}
+	set 2(value) {
+		this.columns[0].z = value;
+	}
+	set 3(_) {}
+	set 4(value) {
+		this.columns[1].x = value;
+	}
+	set 5(value) {
+		this.columns[1].y = value;
+	}
+	set 6(value) {
+		this.columns[1].z = value;
+	}
+	set 7(_) {}
+	set 8(value) {
+		this.columns[2].x = value;
+	}
+	set 9(value) {
+		this.columns[2].y = value;
+	}
+	set 10(value) {
+		this.columns[2].z = value;
+	}
+	set 11(_) {}
+	*[Symbol.iterator]() {
+		for (let i = 0; i < 12; i++) yield this[i];
+	}
+	[$resolve]() {
+		return snip(`${this.kind}(${this[0]}, ${this[1]}, ${this[2]}, ${this[4]}, ${this[5]}, ${this[6]}, ${this[8]}, ${this[9]}, ${this[10]})`, mat3x3f, "runtime");
+	}
+	toString() {
+		return this[$resolve]().value;
+	}
+};
+var mat3x3fImpl = class extends mat3x3Impl {
+	kind = "mat3x3f";
+	makeColumn(x, y, z) {
+		return vec3f$1(x, y, z);
+	}
+};
+var mat4x4Impl = class extends MatBase {
+	[$internal] = true;
+	columns;
+	constructor(...elements) {
+		super();
+		this.columns = [
+			this.makeColumn(elements[0], elements[1], elements[2], elements[3]),
+			this.makeColumn(elements[4], elements[5], elements[6], elements[7]),
+			this.makeColumn(elements[8], elements[9], elements[10], elements[11]),
+			this.makeColumn(elements[12], elements[13], elements[14], elements[15])
+		];
+	}
+	length = 16;
+	get 0() {
+		return this.columns[0].x;
+	}
+	get 1() {
+		return this.columns[0].y;
+	}
+	get 2() {
+		return this.columns[0].z;
+	}
+	get 3() {
+		return this.columns[0].w;
+	}
+	get 4() {
+		return this.columns[1].x;
+	}
+	get 5() {
+		return this.columns[1].y;
+	}
+	get 6() {
+		return this.columns[1].z;
+	}
+	get 7() {
+		return this.columns[1].w;
+	}
+	get 8() {
+		return this.columns[2].x;
+	}
+	get 9() {
+		return this.columns[2].y;
+	}
+	get 10() {
+		return this.columns[2].z;
+	}
+	get 11() {
+		return this.columns[2].w;
+	}
+	get 12() {
+		return this.columns[3].x;
+	}
+	get 13() {
+		return this.columns[3].y;
+	}
+	get 14() {
+		return this.columns[3].z;
+	}
+	get 15() {
+		return this.columns[3].w;
+	}
+	set 0(value) {
+		this.columns[0].x = value;
+	}
+	set 1(value) {
+		this.columns[0].y = value;
+	}
+	set 2(value) {
+		this.columns[0].z = value;
+	}
+	set 3(value) {
+		this.columns[0].w = value;
+	}
+	set 4(value) {
+		this.columns[1].x = value;
+	}
+	set 5(value) {
+		this.columns[1].y = value;
+	}
+	set 6(value) {
+		this.columns[1].z = value;
+	}
+	set 7(value) {
+		this.columns[1].w = value;
+	}
+	set 8(value) {
+		this.columns[2].x = value;
+	}
+	set 9(value) {
+		this.columns[2].y = value;
+	}
+	set 10(value) {
+		this.columns[2].z = value;
+	}
+	set 11(value) {
+		this.columns[2].w = value;
+	}
+	set 12(value) {
+		this.columns[3].x = value;
+	}
+	set 13(value) {
+		this.columns[3].y = value;
+	}
+	set 14(value) {
+		this.columns[3].z = value;
+	}
+	set 15(value) {
+		this.columns[3].w = value;
+	}
+	*[Symbol.iterator]() {
+		for (let i = 0; i < 16; i++) yield this[i];
+	}
+	[$resolve]() {
+		return snip(`${this.kind}(${Array.from({ length: this.length }).map((_, i) => this[i]).join(", ")})`, mat4x4f, "runtime");
+	}
+	toString() {
+		return this[$resolve]().value;
+	}
+};
+var mat4x4fImpl = class extends mat4x4Impl {
+	kind = "mat4x4f";
+	makeColumn(x, y, z, w) {
+		return vec4f$1(x, y, z, w);
+	}
+};
+/**
+* Returns a 2-by-2 identity matrix.
+* @returns {m2x2f} The result matrix.
+*/
+const identity2 = comptime(() => mat2x2f(1, 0, 0, 1)).$name("identity2");
+/**
+* Returns a 3-by-3 identity matrix.
+* @returns {m3x3f} The result matrix.
+*/
+const identity3 = comptime(() => mat3x3f(1, 0, 0, 0, 1, 0, 0, 0, 1)).$name("identity3");
+/**
+* Returns a 4-by-4 identity matrix.
+* @returns {m4x4f} The result matrix.
+*/
+const identity4 = comptime(() => mat4x4f(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)).$name("identity4");
+const identityFunctions = {
+	2: identity2,
+	3: identity3,
+	4: identity4
+};
+/**
+* Creates a 4-by-4 matrix which translates by the given vector v.
+* @param {v3f} vector - The vector by which to translate.
+* @returns {m4x4f} The translation matrix.
+*/
+const translation4 = dualImpl({
+	name: "translation4",
+	normalImpl: (vector) => mat4x4f(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, vector.x, vector.y, vector.z, 1),
+	get signature() {
+		return {
+			argTypes: [vec3f$1],
+			returnType: mat4x4f
+		};
+	},
+	codegenImpl: (_ctx, [v]) => stitch`mat4x4f(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, ${v}.x, ${v}.y, ${v}.z, 1)`
+});
+/**
+* Creates a 4-by-4 matrix which scales in each dimension by an amount given by the corresponding entry in the given vector.
+* @param {v3f} vector - A vector of three entries specifying the factor by which to scale in each dimension.
+* @returns {m4x4f} The scaling matrix.
+*/
+const scaling4 = dualImpl({
+	name: "scaling4",
+	normalImpl: (vector) => mat4x4f(vector.x, 0, 0, 0, 0, vector.y, 0, 0, 0, 0, vector.z, 0, 0, 0, 0, 1),
+	get signature() {
+		return {
+			argTypes: [vec3f$1],
+			returnType: mat4x4f
+		};
+	},
+	codegenImpl: (_ctx, [v]) => stitch`mat4x4f(${v}.x, 0, 0, 0, 0, ${v}.y, 0, 0, 0, 0, ${v}.z, 0, 0, 0, 0, 1)`
+});
+/**
+* Creates a 4-by-4 matrix which rotates around the x-axis by the given angle.
+* @param {number} angle - The angle by which to rotate (in radians).
+* @returns {m4x4f} The rotation matrix.
+*/
+const rotationX4 = dualImpl({
+	name: "rotationX4",
+	normalImpl: (a) => mat4x4f(1, 0, 0, 0, 0, Math.cos(a), Math.sin(a), 0, 0, -Math.sin(a), Math.cos(a), 0, 0, 0, 0, 1),
+	get signature() {
+		return {
+			argTypes: [f32],
+			returnType: mat4x4f
+		};
+	},
+	codegenImpl: (_ctx, [a]) => stitch`mat4x4f(1, 0, 0, 0, 0, cos(${a}), sin(${a}), 0, 0, -sin(${a}), cos(${a}), 0, 0, 0, 0, 1)`
+});
+/**
+* Creates a 4-by-4 matrix which rotates around the y-axis by the given angle.
+* @param {number} angle - The angle by which to rotate (in radians).
+* @returns {m4x4f} The rotation matrix.
+*/
+const rotationY4 = dualImpl({
+	name: "rotationY4",
+	normalImpl: (a) => mat4x4f(Math.cos(a), 0, -Math.sin(a), 0, 0, 1, 0, 0, Math.sin(a), 0, Math.cos(a), 0, 0, 0, 0, 1),
+	get signature() {
+		return {
+			argTypes: [f32],
+			returnType: mat4x4f
+		};
+	},
+	codegenImpl: (_ctx, [a]) => stitch`mat4x4f(cos(${a}), 0, -sin(${a}), 0, 0, 1, 0, 0, sin(${a}), 0, cos(${a}), 0, 0, 0, 0, 1)`
+});
+/**
+* Creates a 4-by-4 matrix which rotates around the z-axis by the given angle.
+* @param {number} angle - The angle by which to rotate (in radians).
+* @returns {m4x4f} The rotation matrix.
+*/
+const rotationZ4 = dualImpl({
+	name: "rotationZ4",
+	normalImpl: (a) => mat4x4f(Math.cos(a), Math.sin(a), 0, 0, -Math.sin(a), Math.cos(a), 0, 0, 0, 0, 1, 0, 0, 0, 0, 1),
+	get signature() {
+		return {
+			argTypes: [f32],
+			returnType: mat4x4f
+		};
+	},
+	codegenImpl: (_ctx, [a]) => stitch`mat4x4f(cos(${a}), sin(${a}), 0, 0, -sin(${a}), cos(${a}), 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)`
+});
+/**
+* Schema representing mat2x2f - a matrix with 2 rows and 2 columns, with elements of type f32.
+* Also a constructor function for this matrix type.
+*
+* @example
+* const zero2x2 = mat2x2f(); // filled with zeros
+*
+* @example
+* const mat = mat2x2f(0, 1, 2, 3);
+* mat.columns[0] // vec2f(0, 1)
+* mat.columns[1] // vec2f(2, 3)
+*
+* @example
+* const mat = mat2x2f(
+*  vec2f(0, 1), // column 0
+*  vec2f(1, 2), // column 1
+* );
+*
+* @example
+* const buffer = root.createBuffer(d.mat2x2f, d.mat2x2f(0, 1, 2, 3)); // buffer holding a d.mat2x2f value, with an initial value of ((0, 1), (2, 3))
+*/
+const mat2x2f = createMatSchema({
+	type: "mat2x2f",
+	rows: 2,
+	columns: 2,
+	MatImpl: mat2x2fImpl
+});
+/**
+* Schema representing mat3x3f - a matrix with 3 rows and 3 columns, with elements of type f32.
+* Also a constructor function for this matrix type.
+*
+* @example
+* const zero3x3 = mat3x3f(); // filled with zeros
+*
+* @example
+* const mat = mat3x3f(0, 1, 2, 3, 4, 5, 6, 7, 8);
+* mat.columns[0] // vec3f(0, 1, 2)
+* mat.columns[1] // vec3f(3, 4, 5)
+* mat.columns[2] // vec3f(6, 7, 8)
+*
+* @example
+* const mat = mat3x3f(
+*  vec3f(0, 1, 2), // column 0
+*  vec3f(2, 3, 4), // column 1
+*  vec3f(5, 6, 7), // column 2
+* );
+*
+* @example
+* const buffer = root.createBuffer(d.mat3x3f, d.mat3x3f()); // buffer holding a d.mat3x3f value, with an initial value of mat3x3f filled with zeros
+*/
+const mat3x3f = createMatSchema({
+	type: "mat3x3f",
+	rows: 3,
+	columns: 3,
+	MatImpl: mat3x3fImpl
+});
+/**
+* Schema representing mat4x4f - a matrix with 4 rows and 4 columns, with elements of type f32.
+* Also a constructor function for this matrix type.
+*
+* @example
+* const zero4x4 = mat4x4f(); // filled with zeros
+*
+* @example
+* const mat = mat4x4f(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+* mat.columns[0] // vec4f(0, 1, 2, 3)
+* mat.columns[1] // vec4f(4, 5, 6, 7)
+* mat.columns[2] // vec4f(8, 9, 10, 11)
+* mat.columns[3] // vec4f(12, 13, 14, 15)
+*
+* @example
+* const mat = mat4x4f(
+*  vec4f(0, 1, 2, 3),     // column 0
+*  vec4f(4, 5, 6, 7),     // column 1
+*  vec4f(8, 9, 10, 11),   // column 2
+*  vec4f(12, 13, 14, 15), // column 3
+* );
+*
+* @example
+* const buffer = root.createBuffer(d.mat4x4f, d.mat4x4f()); // buffer holding a d.mat4x4f value, with an initial value of mat4x4f filled with zeros
+*/
+const mat4x4f = createMatSchema({
+	type: "mat4x4f",
+	rows: 4,
+	columns: 4,
+	MatImpl: mat4x4fImpl
+});
+function matToArray(mat) {
+	if (mat.kind === "mat3x3f") return [
+		mat[0],
+		mat[1],
+		mat[2],
+		mat[4],
+		mat[5],
+		mat[6],
+		mat[8],
+		mat[9],
+		mat[10]
+	];
+	return Array.from({ length: mat.length }).map((_, idx) => mat[idx]);
+}
+
+//#endregion
+//#region src/data/numberOps.ts
+const smoothstepScalar = (edge0, edge1, x) => {
+	if (edge0 === edge1) return 0;
+	const t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
+	return t * t * (3 - 2 * t);
+};
+const clamp = (value, low, high) => Math.min(Math.max(low, value), high);
+const divInteger = (lhs, rhs) => {
+	if (rhs === 0) return lhs;
+	return Math.trunc(lhs / rhs);
+};
+function bitcastU32toF32Impl(n) {
+	const dataView = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+	dataView.setUint32(0, n, true);
+	return dataView.getFloat32(0, true);
+}
+function bitcastU32toI32Impl(n) {
+	const dataView = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+	dataView.setUint32(0, n, true);
+	return dataView.getInt32(0, true);
+}
+
+//#endregion
+//#region src/data/vectorOps.ts
+const vec2b = vec2b$1;
+const vec2f = vec2f$1;
+const vec2h = vec2h$1;
+const vec2i = vec2i$1;
+const vec2u = vec2u$1;
+const vec3b = vec3b$1;
+const vec3f = vec3f$1;
+const vec3h = vec3h$1;
+const vec3i = vec3i$1;
+const vec3u = vec3u$1;
+const vec4b = vec4b$1;
+const vec4f = vec4f$1;
+const vec4h = vec4h$1;
+const vec4i = vec4i$1;
+const vec4u = vec4u$1;
+const lengthVec2 = (v) => Math.sqrt(v.x ** 2 + v.y ** 2);
+const lengthVec3 = (v) => Math.sqrt(v.x ** 2 + v.y ** 2 + v.z ** 2);
+const lengthVec4 = (v) => Math.sqrt(v.x ** 2 + v.y ** 2 + v.z ** 2 + v.w ** 2);
+const dotVec2 = (lhs, rhs) => lhs.x * rhs.x + lhs.y * rhs.y;
+const dotVec3 = (lhs, rhs) => lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
+const dotVec4 = (lhs, rhs) => lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z + lhs.w * rhs.w;
+const unary2f = (op) => (a) => vec2f(op(a.x), op(a.y));
+const unary2h = (op) => (a) => vec2h(op(a.x), op(a.y));
+const unary2i = (op) => (a) => vec2i(op(a.x), op(a.y));
+const unary2u = (op) => (a) => vec2u(op(a.x), op(a.y));
+const unary3f = (op) => (a) => vec3f(op(a.x), op(a.y), op(a.z));
+const unary3h = (op) => (a) => vec3h(op(a.x), op(a.y), op(a.z));
+const unary3i = (op) => (a) => vec3i(op(a.x), op(a.y), op(a.z));
+const unary3u = (op) => (a) => vec3u(op(a.x), op(a.y), op(a.z));
+const unary4f = (op) => (a) => vec4f(op(a.x), op(a.y), op(a.z), op(a.w));
+const unary4h = (op) => (a) => vec4h(op(a.x), op(a.y), op(a.z), op(a.w));
+const unary4i = (op) => (a) => vec4i(op(a.x), op(a.y), op(a.z), op(a.w));
+const unary4u = (op) => (a) => vec4u(op(a.x), op(a.y), op(a.z), op(a.w));
+const unary2x2f = (op) => (a) => {
+	const a_ = a.columns;
+	return mat2x2f(unary2f(op)(a_[0]), unary2f(op)(a_[1]));
+};
+const unary3x3f = (op) => (a) => {
+	const a_ = a.columns;
+	return mat3x3f(unary3f(op)(a_[0]), unary3f(op)(a_[1]), unary3f(op)(a_[2]));
+};
+const unary4x4f = (op) => (a) => {
+	const a_ = a.columns;
+	return mat4x4f(unary4f(op)(a_[0]), unary4f(op)(a_[1]), unary4f(op)(a_[2]), unary4f(op)(a_[3]));
+};
+const binaryComponentWise2f = (op) => (a, b) => vec2f(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise2h = (op) => (a, b) => vec2h(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise2i = (op) => (a, b) => vec2i(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise2u = (op) => (a, b) => vec2u(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise3f = (op) => (a, b) => vec3f(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise3h = (op) => (a, b) => vec3h(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise3i = (op) => (a, b) => vec3i(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise3u = (op) => (a, b) => vec3u(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise4f = (op) => (a, b) => vec4f(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise4h = (op) => (a, b) => vec4h(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise4i = (op) => (a, b) => vec4i(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise4u = (op) => (a, b) => vec4u(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise2x2f = (op) => (a, b) => {
+	const a_ = a.columns;
+	const b_ = b.columns;
+	return mat2x2f(binaryComponentWise2f(op)(a_[0], b_[0]), binaryComponentWise2f(op)(a_[1], b_[1]));
+};
+const binaryComponentWise3x3f = (op) => (a, b) => {
+	const a_ = a.columns;
+	const b_ = b.columns;
+	return mat3x3f(binaryComponentWise3f(op)(a_[0], b_[0]), binaryComponentWise3f(op)(a_[1], b_[1]), binaryComponentWise3f(op)(a_[2], b_[2]));
+};
+const binaryComponentWise4x4f = (op) => (a, b) => {
+	const a_ = a.columns;
+	const b_ = b.columns;
+	return mat4x4f(binaryComponentWise4f(op)(a_[0], b_[0]), binaryComponentWise4f(op)(a_[1], b_[1]), binaryComponentWise4f(op)(a_[2], b_[2]), binaryComponentWise4f(op)(a_[3], b_[3]));
+};
+const ternaryComponentWise2f = (op) => (a, b, c) => vec2f(op(a.x, b.x, c.x), op(a.y, b.y, c.y));
+const ternaryComponentWise2h = (op) => (a, b, c) => vec2h(op(a.x, b.x, c.x), op(a.y, b.y, c.y));
+const ternaryComponentWise3f = (op) => (a, b, c) => vec3f(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z));
+const ternaryComponentWise3h = (op) => (a, b, c) => vec3h(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z));
+const ternaryComponentWise4f = (op) => (a, b, c) => vec4f(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z), op(a.w, b.w, c.w));
+const ternaryComponentWise4h = (op) => (a, b, c) => vec4h(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z), op(a.w, b.w, c.w));
+const VectorOps = {
+	eq: {
+		vec2f: (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		vec2h: (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		vec2i: (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		vec2u: (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		"vec2<bool>": (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		vec3f: (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		vec3h: (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		vec3i: (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		vec3u: (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		"vec3<bool>": (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		vec4f: (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w),
+		vec4h: (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w),
+		vec4i: (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w),
+		vec4u: (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w),
+		"vec4<bool>": (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w)
+	},
+	lt: {
+		vec2f: (e1, e2) => vec2b(e1.x < e2.x, e1.y < e2.y),
+		vec2h: (e1, e2) => vec2b(e1.x < e2.x, e1.y < e2.y),
+		vec2i: (e1, e2) => vec2b(e1.x < e2.x, e1.y < e2.y),
+		vec2u: (e1, e2) => vec2b(e1.x < e2.x, e1.y < e2.y),
+		vec3f: (e1, e2) => vec3b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z),
+		vec3h: (e1, e2) => vec3b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z),
+		vec3i: (e1, e2) => vec3b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z),
+		vec3u: (e1, e2) => vec3b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z),
+		vec4f: (e1, e2) => vec4b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z, e1.w < e2.w),
+		vec4h: (e1, e2) => vec4b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z, e1.w < e2.w),
+		vec4i: (e1, e2) => vec4b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z, e1.w < e2.w),
+		vec4u: (e1, e2) => vec4b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z, e1.w < e2.w)
+	},
+	or: {
+		"vec2<bool>": (e1, e2) => vec2b(e1.x || e2.x, e1.y || e2.y),
+		"vec3<bool>": (e1, e2) => vec3b(e1.x || e2.x, e1.y || e2.y, e1.z || e2.z),
+		"vec4<bool>": (e1, e2) => vec4b(e1.x || e2.x, e1.y || e2.y, e1.z || e2.z, e1.w || e2.w)
+	},
+	all: {
+		"vec2<bool>": (e) => e.x && e.y,
+		"vec3<bool>": (e) => e.x && e.y && e.z,
+		"vec4<bool>": (e) => e.x && e.y && e.z && e.w
+	},
+	abs: {
+		vec2f: unary2f(Math.abs),
+		vec2h: unary2h(Math.abs),
+		vec2i: unary2i(Math.abs),
+		vec2u: unary2u(Math.abs),
+		vec3f: unary3f(Math.abs),
+		vec3h: unary3h(Math.abs),
+		vec3i: unary3i(Math.abs),
+		vec3u: unary3u(Math.abs),
+		vec4f: unary4f(Math.abs),
+		vec4h: unary4h(Math.abs),
+		vec4i: unary4i(Math.abs),
+		vec4u: unary4u(Math.abs)
+	},
+	atan2: {
+		vec2f: binaryComponentWise2f(Math.atan2),
+		vec2h: binaryComponentWise2h(Math.atan2),
+		vec3f: binaryComponentWise3f(Math.atan2),
+		vec3h: binaryComponentWise3h(Math.atan2),
+		vec4f: binaryComponentWise4f(Math.atan2),
+		vec4h: binaryComponentWise4h(Math.atan2)
+	},
+	acos: {
+		vec2f: unary2f(Math.acos),
+		vec2h: unary2h(Math.acos),
+		vec2i: unary2i(Math.acos),
+		vec2u: unary2u(Math.acos),
+		vec3f: unary3f(Math.acos),
+		vec3h: unary3h(Math.acos),
+		vec3i: unary3i(Math.acos),
+		vec3u: unary3u(Math.acos),
+		vec4f: unary4f(Math.acos),
+		vec4h: unary4h(Math.acos),
+		vec4i: unary4i(Math.acos),
+		vec4u: unary4u(Math.acos)
+	},
+	acosh: {
+		vec2f: unary2f(Math.acosh),
+		vec2h: unary2h(Math.acosh),
+		vec3f: unary3f(Math.acosh),
+		vec3h: unary3h(Math.acosh),
+		vec4f: unary4f(Math.acosh),
+		vec4h: unary4h(Math.acosh)
+	},
+	asin: {
+		vec2f: unary2f(Math.asin),
+		vec2h: unary2h(Math.asin),
+		vec3f: unary3f(Math.asin),
+		vec3h: unary3h(Math.asin),
+		vec4f: unary4f(Math.asin),
+		vec4h: unary4h(Math.asin)
+	},
+	asinh: {
+		vec2f: unary2f(Math.asinh),
+		vec2h: unary2h(Math.asinh),
+		vec3f: unary3f(Math.asinh),
+		vec3h: unary3h(Math.asinh),
+		vec4f: unary4f(Math.asinh),
+		vec4h: unary4h(Math.asinh)
+	},
+	atan: {
+		vec2f: unary2f(Math.atan),
+		vec2h: unary2h(Math.atan),
+		vec3f: unary3f(Math.atan),
+		vec3h: unary3h(Math.atan),
+		vec4f: unary4f(Math.atan),
+		vec4h: unary4h(Math.atan)
+	},
+	atanh: {
+		vec2f: unary2f(Math.atanh),
+		vec2h: unary2h(Math.atanh),
+		vec3f: unary3f(Math.atanh),
+		vec3h: unary3h(Math.atanh),
+		vec4f: unary4f(Math.atanh),
+		vec4h: unary4h(Math.atanh)
+	},
+	ceil: {
+		vec2f: unary2f(Math.ceil),
+		vec2h: unary2h(Math.ceil),
+		vec3f: unary3f(Math.ceil),
+		vec3h: unary3h(Math.ceil),
+		vec4f: unary4f(Math.ceil),
+		vec4h: unary4h(Math.ceil)
+	},
+	clamp: {
+		vec2f: (v, low, high) => vec2f(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y)),
+		vec2h: (v, low, high) => vec2h(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y)),
+		vec2i: (v, low, high) => vec2i(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y)),
+		vec2u: (v, low, high) => vec2u(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y)),
+		vec3f: (v, low, high) => vec3f(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z)),
+		vec3h: (v, low, high) => vec3h(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z)),
+		vec3i: (v, low, high) => vec3i(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z)),
+		vec3u: (v, low, high) => vec3u(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z)),
+		vec4f: (v, low, high) => vec4f(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z), clamp(v.w, low.w, high.w)),
+		vec4h: (v, low, high) => vec4h(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z), clamp(v.w, low.w, high.w)),
+		vec4i: (v, low, high) => vec4i(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z), clamp(v.w, low.w, high.w)),
+		vec4u: (v, low, high) => vec4u(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z), clamp(v.w, low.w, high.w))
+	},
+	length: {
+		vec2f: lengthVec2,
+		vec2h: lengthVec2,
+		vec3f: lengthVec3,
+		vec3h: lengthVec3,
+		vec4f: lengthVec4,
+		vec4h: lengthVec4
+	},
+	add: {
+		vec2f: binaryComponentWise2f((a, b) => a + b),
+		vec2h: binaryComponentWise2h((a, b) => a + b),
+		vec2i: binaryComponentWise2i((a, b) => a + b),
+		vec2u: binaryComponentWise2u((a, b) => a + b),
+		vec3f: binaryComponentWise3f((a, b) => a + b),
+		vec3h: binaryComponentWise3h((a, b) => a + b),
+		vec3i: binaryComponentWise3i((a, b) => a + b),
+		vec3u: binaryComponentWise3u((a, b) => a + b),
+		vec4f: binaryComponentWise4f((a, b) => a + b),
+		vec4h: binaryComponentWise4h((a, b) => a + b),
+		vec4i: binaryComponentWise4i((a, b) => a + b),
+		vec4u: binaryComponentWise4u((a, b) => a + b),
+		mat2x2f: binaryComponentWise2x2f((a, b) => a + b),
+		mat3x3f: binaryComponentWise3x3f((a, b) => a + b),
+		mat4x4f: binaryComponentWise4x4f((a, b) => a + b)
+	},
+	smoothstep: {
+		vec2f: ternaryComponentWise2f(smoothstepScalar),
+		vec2h: ternaryComponentWise2h(smoothstepScalar),
+		vec3f: ternaryComponentWise3f(smoothstepScalar),
+		vec3h: ternaryComponentWise3h(smoothstepScalar),
+		vec4f: ternaryComponentWise4f(smoothstepScalar),
+		vec4h: ternaryComponentWise4h(smoothstepScalar)
+	},
+	addMixed: {
+		vec2f: (a, b) => unary2f((e) => e + b)(a),
+		vec2h: (a, b) => unary2h((e) => e + b)(a),
+		vec2i: (a, b) => unary2i((e) => e + b)(a),
+		vec2u: (a, b) => unary2u((e) => e + b)(a),
+		vec3f: (a, b) => unary3f((e) => e + b)(a),
+		vec3h: (a, b) => unary3h((e) => e + b)(a),
+		vec3i: (a, b) => unary3i((e) => e + b)(a),
+		vec3u: (a, b) => unary3u((e) => e + b)(a),
+		vec4f: (a, b) => unary4f((e) => e + b)(a),
+		vec4h: (a, b) => unary4h((e) => e + b)(a),
+		vec4i: (a, b) => unary4i((e) => e + b)(a),
+		vec4u: (a, b) => unary4u((e) => e + b)(a),
+		mat2x2f: (a, b) => unary2x2f((e) => e + b)(a),
+		mat3x3f: (a, b) => unary3x3f((e) => e + b)(a),
+		mat4x4f: (a, b) => unary4x4f((e) => e + b)(a)
+	},
+	mulSxV: {
+		vec2f: (s, v) => unary2f((e) => s * e)(v),
+		vec2h: (s, v) => unary2h((e) => s * e)(v),
+		vec2i: (s, v) => unary2i((e) => s * e)(v),
+		vec2u: (s, v) => unary2u((e) => s * e)(v),
+		vec3f: (s, v) => unary3f((e) => s * e)(v),
+		vec3h: (s, v) => unary3h((e) => s * e)(v),
+		vec3i: (s, v) => unary3i((e) => s * e)(v),
+		vec3u: (s, v) => unary3u((e) => s * e)(v),
+		vec4f: (s, v) => unary4f((e) => s * e)(v),
+		vec4h: (s, v) => unary4h((e) => s * e)(v),
+		vec4i: (s, v) => unary4i((e) => s * e)(v),
+		vec4u: (s, v) => unary4u((e) => s * e)(v),
+		mat2x2f: (s, m) => unary2x2f((e) => s * e)(m),
+		mat3x3f: (s, m) => unary3x3f((e) => s * e)(m),
+		mat4x4f: (s, m) => unary4x4f((e) => s * e)(m)
+	},
+	mulVxV: {
+		vec2f: binaryComponentWise2f((a, b) => a * b),
+		vec2h: binaryComponentWise2h((a, b) => a * b),
+		vec2i: binaryComponentWise2i((a, b) => a * b),
+		vec2u: binaryComponentWise2u((a, b) => a * b),
+		vec3f: binaryComponentWise3f((a, b) => a * b),
+		vec3h: binaryComponentWise3h((a, b) => a * b),
+		vec3i: binaryComponentWise3i((a, b) => a * b),
+		vec3u: binaryComponentWise3u((a, b) => a * b),
+		vec4f: binaryComponentWise4f((a, b) => a * b),
+		vec4h: binaryComponentWise4h((a, b) => a * b),
+		vec4i: binaryComponentWise4i((a, b) => a * b),
+		vec4u: binaryComponentWise4u((a, b) => a * b),
+		mat2x2f: (a, b) => {
+			const a_ = a.columns;
+			const b_ = b.columns;
+			return mat2x2f(a_[0].x * b_[0].x + a_[1].x * b_[0].y, a_[0].y * b_[0].x + a_[1].y * b_[0].y, a_[0].x * b_[1].x + a_[1].x * b_[1].y, a_[0].y * b_[1].x + a_[1].y * b_[1].y);
+		},
+		mat3x3f: (a, b) => {
+			const a_ = a.columns;
+			const b_ = b.columns;
+			return mat3x3f(a_[0].x * b_[0].x + a_[1].x * b_[0].y + a_[2].x * b_[0].z, a_[0].y * b_[0].x + a_[1].y * b_[0].y + a_[2].y * b_[0].z, a_[0].z * b_[0].x + a_[1].z * b_[0].y + a_[2].z * b_[0].z, a_[0].x * b_[1].x + a_[1].x * b_[1].y + a_[2].x * b_[1].z, a_[0].y * b_[1].x + a_[1].y * b_[1].y + a_[2].y * b_[1].z, a_[0].z * b_[1].x + a_[1].z * b_[1].y + a_[2].z * b_[1].z, a_[0].x * b_[2].x + a_[1].x * b_[2].y + a_[2].x * b_[2].z, a_[0].y * b_[2].x + a_[1].y * b_[2].y + a_[2].y * b_[2].z, a_[0].z * b_[2].x + a_[1].z * b_[2].y + a_[2].z * b_[2].z);
+		},
+		mat4x4f: (a, b) => {
+			const a_ = a.columns;
+			const b_ = b.columns;
+			return mat4x4f(a_[0].x * b_[0].x + a_[1].x * b_[0].y + a_[2].x * b_[0].z + a_[3].x * b_[0].w, a_[0].y * b_[0].x + a_[1].y * b_[0].y + a_[2].y * b_[0].z + a_[3].y * b_[0].w, a_[0].z * b_[0].x + a_[1].z * b_[0].y + a_[2].z * b_[0].z + a_[3].z * b_[0].w, a_[0].w * b_[0].x + a_[1].w * b_[0].y + a_[2].w * b_[0].z + a_[3].w * b_[0].w, a_[0].x * b_[1].x + a_[1].x * b_[1].y + a_[2].x * b_[1].z + a_[3].x * b_[1].w, a_[0].y * b_[1].x + a_[1].y * b_[1].y + a_[2].y * b_[1].z + a_[3].y * b_[1].w, a_[0].z * b_[1].x + a_[1].z * b_[1].y + a_[2].z * b_[1].z + a_[3].z * b_[1].w, a_[0].w * b_[1].x + a_[1].w * b_[1].y + a_[2].w * b_[1].z + a_[3].w * b_[1].w, a_[0].x * b_[2].x + a_[1].x * b_[2].y + a_[2].x * b_[2].z + a_[3].x * b_[2].w, a_[0].y * b_[2].x + a_[1].y * b_[2].y + a_[2].y * b_[2].z + a_[3].y * b_[2].w, a_[0].z * b_[2].x + a_[1].z * b_[2].y + a_[2].z * b_[2].z + a_[3].z * b_[2].w, a_[0].w * b_[2].x + a_[1].w * b_[2].y + a_[2].w * b_[2].z + a_[3].w * b_[2].w, a_[0].x * b_[3].x + a_[1].x * b_[3].y + a_[2].x * b_[3].z + a_[3].x * b_[3].w, a_[0].y * b_[3].x + a_[1].y * b_[3].y + a_[2].y * b_[3].z + a_[3].y * b_[3].w, a_[0].z * b_[3].x + a_[1].z * b_[3].y + a_[2].z * b_[3].z + a_[3].z * b_[3].w, a_[0].w * b_[3].x + a_[1].w * b_[3].y + a_[2].w * b_[3].z + a_[3].w * b_[3].w);
+		}
+	},
+	mulMxV: {
+		mat2x2f: (m, v) => {
+			const m_ = m.columns;
+			return vec2f(m_[0].x * v.x + m_[1].x * v.y, m_[0].y * v.x + m_[1].y * v.y);
+		},
+		mat3x3f: (m, v) => {
+			const m_ = m.columns;
+			return vec3f(m_[0].x * v.x + m_[1].x * v.y + m_[2].x * v.z, m_[0].y * v.x + m_[1].y * v.y + m_[2].y * v.z, m_[0].z * v.x + m_[1].z * v.y + m_[2].z * v.z);
+		},
+		mat4x4f: (m, v) => {
+			const m_ = m.columns;
+			return vec4f(m_[0].x * v.x + m_[1].x * v.y + m_[2].x * v.z + m_[3].x * v.w, m_[0].y * v.x + m_[1].y * v.y + m_[2].y * v.z + m_[3].y * v.w, m_[0].z * v.x + m_[1].z * v.y + m_[2].z * v.z + m_[3].z * v.w, m_[0].w * v.x + m_[1].w * v.y + m_[2].w * v.z + m_[3].w * v.w);
+		}
+	},
+	mulVxM: {
+		mat2x2f: (v, m) => {
+			const m_ = m.columns;
+			return vec2f(v.x * m_[0].x + v.y * m_[0].y, v.x * m_[1].x + v.y * m_[1].y);
+		},
+		mat3x3f: (v, m) => {
+			const m_ = m.columns;
+			return vec3f(v.x * m_[0].x + v.y * m_[0].y + v.z * m_[0].z, v.x * m_[1].x + v.y * m_[1].y + v.z * m_[1].z, v.x * m_[2].x + v.y * m_[2].y + v.z * m_[2].z);
+		},
+		mat4x4f: (v, m) => {
+			const m_ = m.columns;
+			return vec4f(v.x * m_[0].x + v.y * m_[0].y + v.z * m_[0].z + v.w * m_[0].w, v.x * m_[1].x + v.y * m_[1].y + v.z * m_[1].z + v.w * m_[1].w, v.x * m_[2].x + v.y * m_[2].y + v.z * m_[2].z + v.w * m_[2].w, v.x * m_[3].x + v.y * m_[3].y + v.z * m_[3].z + v.w * m_[3].w);
+		}
+	},
+	div: {
+		vec2f: binaryComponentWise2f((a, b) => a / b),
+		vec2h: binaryComponentWise2h((a, b) => a / b),
+		vec2i: binaryComponentWise2i(divInteger),
+		vec2u: binaryComponentWise2u(divInteger),
+		vec3f: binaryComponentWise3f((a, b) => a / b),
+		vec3h: binaryComponentWise3h((a, b) => a / b),
+		vec3i: binaryComponentWise3i(divInteger),
+		vec3u: binaryComponentWise3u(divInteger),
+		vec4f: binaryComponentWise4f((a, b) => a / b),
+		vec4h: binaryComponentWise4h((a, b) => a / b),
+		vec4i: binaryComponentWise4i(divInteger),
+		vec4u: binaryComponentWise4u(divInteger)
+	},
+	dot: {
+		vec2f: dotVec2,
+		vec2h: dotVec2,
+		vec2i: dotVec2,
+		vec2u: dotVec2,
+		vec3f: dotVec3,
+		vec3h: dotVec3,
+		vec3i: dotVec3,
+		vec3u: dotVec3,
+		vec4f: dotVec4,
+		vec4h: dotVec4,
+		vec4i: dotVec4,
+		vec4u: dotVec4
+	},
+	normalize: {
+		vec2f: (v) => {
+			const len = lengthVec2(v);
+			return vec2f(v.x / len, v.y / len);
+		},
+		vec2h: (v) => {
+			const len = lengthVec2(v);
+			return vec2h(v.x / len, v.y / len);
+		},
+		vec2i: (v) => {
+			const len = lengthVec2(v);
+			return vec2i(v.x / len, v.y / len);
+		},
+		vec2u: (v) => {
+			const len = lengthVec2(v);
+			return vec2u(v.x / len, v.y / len);
+		},
+		vec3f: (v) => {
+			const len = lengthVec3(v);
+			return vec3f(v.x / len, v.y / len, v.z / len);
+		},
+		vec3h: (v) => {
+			const len = lengthVec3(v);
+			return vec3h(v.x / len, v.y / len, v.z / len);
+		},
+		vec3i: (v) => {
+			const len = lengthVec3(v);
+			return vec3i(v.x / len, v.y / len, v.z / len);
+		},
+		vec3u: (v) => {
+			const len = lengthVec3(v);
+			return vec3u(v.x / len, v.y / len, v.z / len);
+		},
+		vec4f: (v) => {
+			const len = lengthVec4(v);
+			return vec4f(v.x / len, v.y / len, v.z / len, v.w / len);
+		},
+		vec4h: (v) => {
+			const len = lengthVec4(v);
+			return vec4h(v.x / len, v.y / len, v.z / len, v.w / len);
+		},
+		vec4i: (v) => {
+			const len = lengthVec4(v);
+			return vec4i(v.x / len, v.y / len, v.z / len, v.w / len);
+		},
+		vec4u: (v) => {
+			const len = lengthVec4(v);
+			return vec4u(v.x / len, v.y / len, v.z / len, v.w / len);
+		}
+	},
+	cross: {
+		vec3f: (a, b) => {
+			return vec3f(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+		},
+		vec3h: (a, b) => {
+			return vec3h(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+		}
+	},
+	mod: {
+		vec2f: binaryComponentWise2f((a, b) => a % b),
+		vec2h: binaryComponentWise2h((a, b) => a % b),
+		vec2i: binaryComponentWise2i((a, b) => a % b),
+		vec2u: binaryComponentWise2u((a, b) => a % b),
+		vec3f: binaryComponentWise3f((a, b) => a % b),
+		vec3h: binaryComponentWise3h((a, b) => a % b),
+		vec3i: binaryComponentWise3i((a, b) => a % b),
+		vec3u: binaryComponentWise3u((a, b) => a % b),
+		vec4f: binaryComponentWise4f((a, b) => a % b),
+		vec4h: binaryComponentWise4h((a, b) => a % b),
+		vec4i: binaryComponentWise4i((a, b) => a % b),
+		vec4u: binaryComponentWise4u((a, b) => a % b)
+	},
+	floor: {
+		vec2f: unary2f(Math.floor),
+		vec2h: unary2h(Math.floor),
+		vec3f: unary3f(Math.floor),
+		vec3h: unary3h(Math.floor),
+		vec4f: unary4f(Math.floor),
+		vec4h: unary4h(Math.floor)
+	},
+	max: {
+		vec2f: binaryComponentWise2f(Math.max),
+		vec2h: binaryComponentWise2h(Math.max),
+		vec2i: binaryComponentWise2i(Math.max),
+		vec2u: binaryComponentWise2u(Math.max),
+		vec3f: binaryComponentWise3f(Math.max),
+		vec3h: binaryComponentWise3h(Math.max),
+		vec3i: binaryComponentWise3i(Math.max),
+		vec3u: binaryComponentWise3u(Math.max),
+		vec4f: binaryComponentWise4f(Math.max),
+		vec4h: binaryComponentWise4h(Math.max),
+		vec4i: binaryComponentWise4i(Math.max),
+		vec4u: binaryComponentWise4u(Math.max)
+	},
+	min: {
+		vec2f: binaryComponentWise2f(Math.min),
+		vec2h: binaryComponentWise2h(Math.min),
+		vec2i: binaryComponentWise2i(Math.min),
+		vec2u: binaryComponentWise2u(Math.min),
+		vec3f: binaryComponentWise3f(Math.min),
+		vec3h: binaryComponentWise3h(Math.min),
+		vec3i: binaryComponentWise3i(Math.min),
+		vec3u: binaryComponentWise3u(Math.min),
+		vec4f: binaryComponentWise4f(Math.min),
+		vec4h: binaryComponentWise4h(Math.min),
+		vec4i: binaryComponentWise4i(Math.min),
+		vec4u: binaryComponentWise4u(Math.min)
+	},
+	pow: {
+		vec2f: (base, exponent) => vec2f(base.x ** exponent.x, base.y ** exponent.y),
+		vec2h: (base, exponent) => vec2h(base.x ** exponent.x, base.y ** exponent.y),
+		vec3f: (base, exponent) => vec3f(base.x ** exponent.x, base.y ** exponent.y, base.z ** exponent.z),
+		vec3h: (base, exponent) => vec3h(base.x ** exponent.x, base.y ** exponent.y, base.z ** exponent.z),
+		vec4f: (base, exponent) => vec4f(base.x ** exponent.x, base.y ** exponent.y, base.z ** exponent.z, base.w ** exponent.w),
+		vec4h: (base, exponent) => vec4h(base.x ** exponent.x, base.y ** exponent.y, base.z ** exponent.z, base.w ** exponent.w)
+	},
+	sign: {
+		vec2f: unary2f(Math.sign),
+		vec2h: unary2h(Math.sign),
+		vec2i: unary2i(Math.sign),
+		vec3f: unary3f(Math.sign),
+		vec3h: unary3h(Math.sign),
+		vec3i: unary3i(Math.sign),
+		vec4f: unary4f(Math.sign),
+		vec4h: unary4h(Math.sign),
+		vec4i: unary4i(Math.sign)
+	},
+	sqrt: {
+		vec2f: unary2f(Math.sqrt),
+		vec2h: unary2h(Math.sqrt),
+		vec3f: unary3f(Math.sqrt),
+		vec3h: unary3h(Math.sqrt),
+		vec4f: unary4f(Math.sqrt),
+		vec4h: unary4h(Math.sqrt)
+	},
+	mix: {
+		vec2f: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec2f(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3);
+			return vec2f(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y);
+		},
+		vec2h: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec2h(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3);
+			return vec2h(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y);
+		},
+		vec3f: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec3f(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3, e1.z * (1 - e3) + e2.z * e3);
+			return vec3f(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y, e1.z * (1 - e3.z) + e2.z * e3.z);
+		},
+		vec3h: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec3h(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3, e1.z * (1 - e3) + e2.z * e3);
+			return vec3h(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y, e1.z * (1 - e3.z) + e2.z * e3.z);
+		},
+		vec4f: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec4f(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3, e1.z * (1 - e3) + e2.z * e3, e1.w * (1 - e3) + e2.w * e3);
+			return vec4f(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y, e1.z * (1 - e3.z) + e2.z * e3.z, e1.w * (1 - e3.w) + e2.w * e3.w);
+		},
+		vec4h: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec4h(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3, e1.z * (1 - e3) + e2.z * e3, e1.w * (1 - e3) + e2.w * e3);
+			return vec4h(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y, e1.z * (1 - e3.z) + e2.z * e3.z, e1.w * (1 - e3.w) + e2.w * e3.w);
+		}
+	},
+	sin: {
+		vec2f: unary2f(Math.sin),
+		vec2h: unary2h(Math.sin),
+		vec3f: unary3f(Math.sin),
+		vec3h: unary3h(Math.sin),
+		vec4f: unary4f(Math.sin),
+		vec4h: unary4h(Math.sin)
+	},
+	cos: {
+		vec2f: unary2f(Math.cos),
+		vec2h: unary2h(Math.cos),
+		vec3f: unary3f(Math.cos),
+		vec3h: unary3h(Math.cos),
+		vec4f: unary4f(Math.cos),
+		vec4h: unary4h(Math.cos)
+	},
+	cosh: {
+		vec2f: unary2f(Math.cosh),
+		vec2h: unary2h(Math.cosh),
+		vec3f: unary3f(Math.cosh),
+		vec3h: unary3h(Math.cosh),
+		vec4f: unary4f(Math.cosh),
+		vec4h: unary4h(Math.cosh)
+	},
+	exp: {
+		vec2f: unary2f(Math.exp),
+		vec2h: unary2h(Math.exp),
+		vec3f: unary3f(Math.exp),
+		vec3h: unary3h(Math.exp),
+		vec4f: unary4f(Math.exp),
+		vec4h: unary4h(Math.exp)
+	},
+	exp2: {
+		vec2f: unary2f((val) => 2 ** val),
+		vec2h: unary2h((val) => 2 ** val),
+		vec3f: unary3f((val) => 2 ** val),
+		vec3h: unary3h((val) => 2 ** val),
+		vec4f: unary4f((val) => 2 ** val),
+		vec4h: unary4h((val) => 2 ** val)
+	},
+	log: {
+		vec2f: unary2f(Math.log),
+		vec2h: unary2h(Math.log),
+		vec3f: unary3f(Math.log),
+		vec3h: unary3h(Math.log),
+		vec4f: unary4f(Math.log),
+		vec4h: unary4h(Math.log)
+	},
+	log2: {
+		vec2f: unary2f(Math.log2),
+		vec2h: unary2h(Math.log2),
+		vec3f: unary3f(Math.log2),
+		vec3h: unary3h(Math.log2),
+		vec4f: unary4f(Math.log2),
+		vec4h: unary4h(Math.log2)
+	},
+	fract: {
+		vec2f: unary2f((value) => value - Math.floor(value)),
+		vec2h: unary2h((value) => value - Math.floor(value)),
+		vec3f: unary3f((value) => value - Math.floor(value)),
+		vec3h: unary3h((value) => value - Math.floor(value)),
+		vec4f: unary4f((value) => value - Math.floor(value)),
+		vec4h: unary4h((value) => value - Math.floor(value))
+	},
+	isCloseToZero: {
+		vec2f: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n,
+		vec2h: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n,
+		vec3f: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n && Math.abs(v.z) <= n,
+		vec3h: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n && Math.abs(v.z) <= n,
+		vec4f: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n && Math.abs(v.z) <= n && Math.abs(v.w) <= n,
+		vec4h: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n && Math.abs(v.z) <= n && Math.abs(v.w) <= n
+	},
+	neg: {
+		vec2f: unary2f((value) => -value),
+		vec2h: unary2h((value) => -value),
+		vec2i: unary2i((value) => -value),
+		vec2u: unary2u((value) => -value),
+		"vec2<bool>": (e) => vec2b(!e.x, !e.y),
+		vec3f: unary3f((value) => -value),
+		vec3h: unary3h((value) => -value),
+		vec3i: unary3i((value) => -value),
+		vec3u: unary3u((value) => -value),
+		"vec3<bool>": (e) => vec3b(!e.x, !e.y, !e.z),
+		vec4f: unary4f((value) => -value),
+		vec4h: unary4h((value) => -value),
+		vec4i: unary4i((value) => -value),
+		vec4u: unary4u((value) => -value),
+		"vec4<bool>": (e) => vec4b(!e.x, !e.y, !e.z, !e.w)
+	},
+	select: {
+		vec2f: (f, t, c) => vec2f(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		vec2h: (f, t, c) => vec2h(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		vec2i: (f, t, c) => vec2i(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		vec2u: (f, t, c) => vec2u(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		"vec2<bool>": (f, t, c) => vec2b(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		vec3f: (f, t, c) => vec3f(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		vec3h: (f, t, c) => vec3h(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		vec3i: (f, t, c) => vec3i(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		vec3u: (f, t, c) => vec3u(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		"vec3<bool>": (f, t, c) => vec3b(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		vec4f: (f, t, c) => vec4f(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w),
+		vec4h: (f, t, c) => vec4h(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w),
+		vec4i: (f, t, c) => vec4i(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w),
+		vec4u: (f, t, c) => vec4u(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w),
+		"vec4<bool>": (f, t, c) => vec4b(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w)
+	},
+	tanh: {
+		vec2f: unary2f(Math.tanh),
+		vec2h: unary2h(Math.tanh),
+		vec3f: unary3f(Math.tanh),
+		vec3h: unary3h(Math.tanh),
+		vec4f: unary4f(Math.tanh),
+		vec4h: unary4h(Math.tanh)
+	},
+	bitcastU32toF32: {
+		vec2u: (n) => vec2f(bitcastU32toF32Impl(n.x), bitcastU32toF32Impl(n.y)),
+		vec3u: (n) => vec3f(bitcastU32toF32Impl(n.x), bitcastU32toF32Impl(n.y), bitcastU32toF32Impl(n.z)),
+		vec4u: (n) => vec4f(bitcastU32toF32Impl(n.x), bitcastU32toF32Impl(n.y), bitcastU32toF32Impl(n.z), bitcastU32toF32Impl(n.w))
+	},
+	bitcastU32toI32: {
+		vec2u: (n) => vec2i(bitcastU32toI32Impl(n.x), bitcastU32toI32Impl(n.y)),
+		vec3u: (n) => vec3i(bitcastU32toI32Impl(n.x), bitcastU32toI32Impl(n.y), bitcastU32toI32Impl(n.z)),
+		vec4u: (n) => vec4i(bitcastU32toI32Impl(n.x), bitcastU32toI32Impl(n.y), bitcastU32toI32Impl(n.z), bitcastU32toI32Impl(n.w))
+	}
+};
+
+//#endregion
+//#region src/std/operators.ts
+const getPrimitive = (t) => "primitive" in t ? t.primitive : t;
+const makeBinarySignature = (opts) => (lhs, rhs) => {
+	const { restrict } = opts ?? {};
+	const fail = (msg) => {
+		if (restrict) throw new SignatureNotSupportedError([lhs, rhs], restrict);
+		throw new Error(`Cannot apply operator to ${lhs.type} and ${rhs.type}: ${msg}`);
+	};
+	if (opts?.noMat && (isMat(lhs) || isMat(rhs))) return fail("matrices not supported");
+	const lhsC = isVec(lhs) || isMat(lhs);
+	const rhsC = isVec(rhs) || isMat(rhs);
+	if (!lhsC && !rhsC) {
+		const unified = unify([lhs, rhs], restrict);
+		if (!unified) return fail("incompatible scalar types");
+		return {
+			argTypes: unified,
+			returnType: unified[0]
+		};
+	}
+	if (lhsC && rhsC) {
+		if (opts?.matVecProduct && isVec(lhs) !== isVec(rhs)) return {
+			argTypes: [lhs, rhs],
+			returnType: isVec(lhs) ? lhs : rhs
+		};
+		if (lhs.type !== rhs.type) return fail("operands must have the same type");
+		return {
+			argTypes: [lhs, rhs],
+			returnType: lhs
+		};
+	}
+	const [scalar, composite] = lhsC ? [rhs, lhs] : [lhs, rhs];
+	const unified = unify([scalar], [getPrimitive(composite)]);
+	if (!unified) return fail(`scalar not convertible to ${getPrimitive(composite).type}`);
+	return {
+		argTypes: lhsC ? [lhs, unified[0]] : [unified[0], rhs],
+		returnType: composite
+	};
+};
+const binaryArithmeticSignature = makeBinarySignature();
+const binaryMulSignature = makeBinarySignature({ matVecProduct: true });
+const binaryDivSignature = makeBinarySignature({
+	noMat: true,
+	restrict: [
+		f32,
+		f16,
+		abstractFloat
+	]
+});
+function cpuAdd(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs + rhs;
+	if (typeof lhs === "number" && isVecInstance(rhs)) return VectorOps.addMixed[rhs.kind](rhs, lhs);
+	if (isVecInstance(lhs) && typeof rhs === "number") return VectorOps.addMixed[lhs.kind](lhs, rhs);
+	if (isVecInstance(lhs) && isVecInstance(rhs) || isMatInstance(lhs) && isMatInstance(rhs)) return VectorOps.add[lhs.kind](lhs, rhs);
+	throw new Error("Add/Sub called with invalid arguments.");
+}
+const add = dualImpl({
+	name: "add",
+	signature: binaryArithmeticSignature,
+	normalImpl: cpuAdd,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} + ${rhs})`
+});
+function cpuSub(lhs, rhs) {
+	return cpuAdd(lhs, cpuMul(-1, rhs));
+}
+const sub = dualImpl({
+	name: "sub",
+	signature: binaryArithmeticSignature,
+	normalImpl: cpuSub,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} - ${rhs})`
+});
+function cpuMul(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs * rhs;
+	if (typeof lhs === "number" && (isVecInstance(rhs) || isMatInstance(rhs))) return VectorOps.mulSxV[rhs.kind](lhs, rhs);
+	if ((isVecInstance(lhs) || isMatInstance(lhs)) && typeof rhs === "number") return VectorOps.mulSxV[lhs.kind](rhs, lhs);
+	if (isVecInstance(lhs) && isVecInstance(rhs)) return VectorOps.mulVxV[lhs.kind](lhs, rhs);
+	if (isFloat32VecInstance(lhs) && isMatInstance(rhs)) return VectorOps.mulVxM[rhs.kind](lhs, rhs);
+	if (isMatInstance(lhs) && isFloat32VecInstance(rhs)) return VectorOps.mulMxV[lhs.kind](lhs, rhs);
+	if (isMatInstance(lhs) && isMatInstance(rhs)) return VectorOps.mulVxV[lhs.kind](lhs, rhs);
+	throw new Error("Mul called with invalid arguments.");
+}
+const mul = dualImpl({
+	name: "mul",
+	signature: binaryMulSignature,
+	normalImpl: cpuMul,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} * ${rhs})`
+});
+function cpuDiv(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs / rhs;
+	if (typeof lhs === "number" && isVecInstance(rhs)) {
+		const schema = vecTypeToConstructor[rhs.kind];
+		return VectorOps.div[rhs.kind](schema(lhs), rhs);
+	}
+	if (isVecInstance(lhs) && typeof rhs === "number") {
+		const schema = vecTypeToConstructor[lhs.kind];
+		return VectorOps.div[lhs.kind](lhs, schema(rhs));
+	}
+	if (isVecInstance(lhs) && isVecInstance(rhs)) return VectorOps.div[lhs.kind](lhs, rhs);
+	throw new Error("Div called with invalid arguments.");
+}
+const div = dualImpl({
+	name: "div",
+	signature: binaryDivSignature,
+	normalImpl: cpuDiv,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} / ${rhs})`,
+	ignoreImplicitCastWarning: true
+});
+/**
+* @privateRemarks
+* Both JS and WGSL implementations use truncated definition of modulo
+*/
+const mod = dualImpl({
+	name: "mod",
+	signature: binaryDivSignature,
+	normalImpl: ((a, b) => {
+		if (typeof a === "number" && typeof b === "number") return a % b;
+		if (typeof a === "number" && isVecInstance(b)) {
+			const schema = vecTypeToConstructor[b.kind];
+			return VectorOps.mod[b.kind](schema(a), b);
+		}
+		if (isVecInstance(a) && typeof b === "number") {
+			const schema = vecTypeToConstructor[a.kind];
+			return VectorOps.mod[a.kind](a, schema(b));
+		}
+		if (isVecInstance(a) && isVecInstance(b)) return VectorOps.mod[a.kind](a, b);
+		throw new Error("Mod called with invalid arguments, expected types: number or vector.");
+	}),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} % ${rhs})`
+});
+function cpuNeg(value) {
+	if (typeof value === "number") return -value;
+	return VectorOps.neg[value.kind](value);
+}
+const neg = dualImpl({
+	name: "neg",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: cpuNeg,
+	codegenImpl: (_ctx, [arg]) => stitch`-(${arg})`
+});
+
+//#endregion
+export { VecBase as $, getMetaData as $n, IllegalBufferAccessError as $t, concretizeSnippets as A, isAlignAttrib as An, stitch as At, vec2h$1 as B, isNaturallyEphemeral as Bn, SimulationState as Bt, translation4 as C, isDisarray as Cn, implicitFrom as Ct, ArrayExpression as D, undecorate as Dn, ptrStorage as Dt, dualImpl as E, isUnstruct as En, ptrPrivate as Et, RandomNameRegistry as F, isInterpolateAttrib as Fn, provideCtx as Ft, vec3h$1 as G, isVecInstance as Gn, isSelfResolvable as Gt, vec2u$1 as H, isSizeAttrib as Hn, isGPUBuffer as Ht, StrictNameRegistry as I, isLocationAttrib as In, provideInsideTgpuFn as It, vec4b$1 as J, isWgslData as Jn, isLazy as Jt, vec3i$1 as K, isVoid as Kn, isWgsl as Kt, isValidProp as L, isMat as Ln, topLevelState as Lt, INTERNAL_createStruct as M, isBuiltinAttrib as Mn, getResolutionCtx as Mt, abstruct as N, isDecorated as Nn, inCodegenMode as Nt, coerceToSnippet as O, unptr as On, ptrUniform as Ot, struct as P, isHalfPrecisionSchema as Pn, isInsideTgpuFn as Pt, vec4u$1 as Q, PERF as Qn, ExecutionError as Qt, vec2b$1 as R, isMat2x2f as Rn, CodegenState as Rt, scaling4 as S, isData as Sn, createPtrFromOrigin as St, MissingCpuImplError as T, isLooseDecorated as Tn, ptrHandle as Tt, vec3b$1 as U, isVec as Un, isGPUCallable as Ut, vec2i$1 as V, isPtr as Vn, getOwnSnippet as Vt, vec3f$1 as W, isVecBool as Wn, isKnownAtComptime as Wt, vec4h$1 as X, kindToDefaultFormatMap as Xn, isProviding as Xt, vec4f$1 as Y, isWgslStruct as Yn, isMutableAccessor as Yt, vec4i$1 as Z, vertexFormats as Zn, isSlot as Zt, mat4x4f as _, MatrixColumnsAccess as _n, schemaCallWrapperGPU as _t, neg as a, NotUniformError as an, $getNameForward as ar, i32 as at, rotationY4 as b, getCustomLocation as bn, derefSnippet as bt, bitcastU32toF32Impl as c, WgslTypeError as cn, $internal as cr, convertStructValues as ct, MatBase as d, isEphemeralSnippet as dn, $repr as dr, tryConvertSnippet as dt, IllegalVarAccessError as en, getName as er, abstractFloat as et, identity2 as f, isSnippet as fn, $resolve as fr, unify as ft, mat3x3f as g, InfixDispatch as gn, schemaCallWrapper as gt, mat2x2f as h, ConsoleLog as hn, safeStringify as ht, mul as i, MissingVertexBuffersError as in, $cast as ir, f32 as it, numericLiteralToSnippet as j, isAtomic as jn, getExecMode as jt, concretize as k, Void as kn, ptrWorkgroup as kt, bitcastU32toI32Impl as l, invariant as ln, $ownSnippet as lr, convertToCommonType as lt, identity4 as m, snip as mn, niceStringify as mt, div as n, MissingLinksError as nn, isNamable as nr, bool as nt, sub as o, ResolutionError as on, $gpuCallable as or, u16 as ot, identity3 as p, isSnippetNumeric as pn, isMarkedInternal as pr, assertExhaustive as pt, vec3u$1 as q, isWgslArray as qn, isAccessor as qt, mod as r, MissingSlotValueError as rn, setName as rr, f16 as rt, VectorOps as s, SignatureNotSupportedError as sn, $gpuValueOf as sr, u32 as st, add as t, MissingBindGroupsError as tn, hasTinyestMetadata as tr, abstractInt as tt, smoothstepScalar as u, isEphemeralOrigin as un, $providing as ur, getBestConversion as ut, matToArray as v, UnknownData as vn, RefOperator as vt, comptime as w, isLooseData as wn, ptrFn as wt, rotationZ4 as x, getCustomSize as xn, isRef as xt, rotationX4 as y, getCustomAlignment as yn, _ref as yt, vec2f$1 as z, isMat3x3f as zn, NormalState as zt };
+//# sourceMappingURL=operators-HTxa_0k9.js.map