typegpu 0.11.9 → 0.12.1

package/std/operators.d.ts

@@ -1,21 +1,18 @@
-import { DualFn } from "../types.js";
-import { AnyIntegerVecInstance, AnyMatInstance, AnyNumericVecInstance, mBaseForVec, vBaseForMat, vecIToVecU } from "../data/wgslTypes.js";
-
-//#region src/std/operators.d.ts
+import { type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type mBaseForVec, type vBaseForMat, type vecIToVecU } from '../data/wgslTypes.ts';
 type NumVec = AnyNumericVecInstance;
 type Mat = AnyMatInstance;
 declare function cpuAdd(lhs: number, rhs: number): number;
 declare function cpuAdd<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuAdd<T extends NumVec>(lhs: T, rhs: number): T;
 declare function cpuAdd<T extends NumVec | Mat>(lhs: T, rhs: T): T;
-declare function cpuAdd<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const add: DualFn<typeof cpuAdd>;
+declare function cpuAdd<Lhs extends number | NumVec | Mat, Rhs extends Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+export declare const add: import("../types.ts").DualFn<typeof cpuAdd>;
 declare function cpuSub(lhs: number, rhs: number): number;
 declare function cpuSub<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuSub<T extends NumVec>(lhs: T, rhs: number): T;
 declare function cpuSub<T extends NumVec | Mat>(lhs: T, rhs: T): T;
-declare function cpuSub<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const sub: DualFn<typeof cpuSub>;
+declare function cpuSub<Lhs extends number | NumVec | Mat, Rhs extends Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+export declare const sub: import("../types.ts").DualFn<typeof cpuSub>;
 declare function cpuMul(lhs: number, rhs: number): number;
 declare function cpuMul<MV extends NumVec | Mat>(lhs: number, rhs: MV): MV;
 declare function cpuMul<MV extends NumVec | Mat>(lhs: MV, rhs: number): MV;
@@ -23,34 +20,29 @@ declare function cpuMul<V extends NumVec>(lhs: V, rhs: V): V;
 declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: V, rhs: M): V;
 declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: M, rhs: V): V;
 declare function cpuMul<M extends Mat>(lhs: M, rhs: M): M;
-declare function cpuMul<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec | Mat : Lhs extends NumVec ? number | Lhs | mBaseForVec<Lhs> : Lhs extends Mat ? number | vBaseForMat<Lhs> | Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const mul: DualFn<typeof cpuMul>;
+declare function cpuMul<Lhs extends number | NumVec | Mat, Rhs extends Lhs extends number ? number | NumVec | Mat : Lhs extends NumVec ? number | Lhs | mBaseForVec<Lhs> : Lhs extends Mat ? number | vBaseForMat<Lhs> | Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+export declare const mul: import("../types.ts").DualFn<typeof cpuMul>;
 declare function cpuDiv(lhs: number, rhs: number): number;
 declare function cpuDiv<T extends NumVec>(lhs: T, rhs: T): T;
 declare function cpuDiv<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuDiv<T extends NumVec>(lhs: T, rhs: number): T;
-declare const div: DualFn<typeof cpuDiv>;
+export declare const div: import("../types.ts").DualFn<typeof cpuDiv>;
 type ModOverload = {
-  (a: number, b: number): number;
-  <T extends NumVec>(a: T, b: T): T;
-  <T extends NumVec>(a: number, b: T): T;
-  <T extends NumVec>(a: T, b: number): T;
+    (a: number, b: number): number;
+    <T extends NumVec>(a: T, b: T): T;
+    <T extends NumVec>(a: number, b: T): T;
+    <T extends NumVec>(a: T, b: number): T;
 };
 /**
  * @privateRemarks
  * Both JS and WGSL implementations use truncated definition of modulo
  */
-declare const mod: DualFn<ModOverload>;
+export declare const mod: import("../types.ts").DualFn<ModOverload>;
 declare function cpuNeg(value: number): number;
 declare function cpuNeg<T extends NumVec>(value: T): T;
-declare const neg: DualFn<typeof cpuNeg>;
-declare function cpuBitShiftLeft(lhs: number, rhs: number): number;
-declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: number): T;
-declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: vecIToVecU<T>): T;
-declare const bitShiftLeft: DualFn<typeof cpuBitShiftLeft>;
-declare function cpuBitShiftRight(lhs: number, rhs: number): number;
-declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: number): T;
-declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: vecIToVecU<T>): T;
-declare const bitShiftRight: DualFn<typeof cpuBitShiftRight>;
-//#endregion
-export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub };
+export declare const neg: import("../types.ts").DualFn<typeof cpuNeg>;
+declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: number | vecIToVecU<T>): T;
+export declare const bitShiftLeft: import("../types.ts").DualFn<typeof cpuBitShiftLeft>;
+declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: number | vecIToVecU<T>): T;
+export declare const bitShiftRight: import("../types.ts").DualFn<typeof cpuBitShiftRight>;
+export {};

package/std/operators.js

@@ -1,229 +1,230 @@
-import { isFloat32VecInstance, isInteger32VecInstance, isMat, isMatInstance, isUint32VecInstance, isVec, isVecInstance } from "../data/wgslTypes.js";
-import { SignatureNotSupportedError } from "../errors.js";
-import { stitch } from "../core/resolve/stitch.js";
-import { unify } from "../tgsl/conversion.js";
-import { abstractFloat, f16, f32, i32, u32 } from "../data/numeric.js";
-import { vec2i, vec2u, vec3i, vec3u, vec4i, vec4u, vecTypeToConstructor } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { abstractFloat, f16, f32, u32 } from "../data/numeric.js";
+import { vec2i, vec2u, vec3i, vec3u, vec4i, vec4u } from "../data/vector.js";
 import { VectorOps } from "../data/vectorOps.js";
-
-//#region src/std/operators.ts
-const getPrimitive = (t) => "primitive" in t ? t.primitive : t;
+import { generalizeFn, upCast } from "../data/generalizeFn.js";
+import { isFloat32VecInstance, isInteger32VecInstance, isMat, isMatInstance, isUint32VecInstance, isVec, isVecInstance, } from "../data/wgslTypes.js";
+import { SignatureNotSupportedError } from "../errors.js";
+import { unify } from "../tgsl/conversion.js";
+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$1 = unify([lhs, rhs], restrict);
-		if (!unified$1) return fail("incompatible scalar types");
-		return {
-			argTypes: unified$1,
-			returnType: unified$1[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 { 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) {
+        // scalar × scalar
+        const unified = unify([lhs, rhs], restrict);
+        if (!unified)
+            return fail('incompatible scalar types');
+        return { argTypes: unified, returnType: unified[0] };
+    }
+    if (lhsC && rhsC) {
+        // vec × mat or mat × vec
+        if (opts?.matVecProduct && isVec(lhs) !== isVec(rhs)) {
+            return { argTypes: [lhs, rhs], returnType: isVec(lhs) ? lhs : rhs };
+        }
+        // composite × composite (same kind)
+        if (lhs.type !== rhs.type)
+            return fail('operands must have the same type');
+        return { argTypes: [lhs, rhs], returnType: lhs };
+    }
+    // scalar × composite
+    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
-	]
+    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.");
+    if (typeof lhs === 'number' && typeof rhs === 'number') {
+        return lhs + rhs; // default addition
+    }
+    if (typeof lhs === 'number' && isVecInstance(rhs)) {
+        return generalizeFn((e) => lhs + e, [rhs]); // mixed addition
+    }
+    if (isVecInstance(lhs) && typeof rhs === 'number') {
+        return generalizeFn((e) => e + rhs, [lhs]); // mixed addition
+    }
+    if ((isVecInstance(lhs) && isVecInstance(rhs)) || (isMatInstance(lhs) && isMatInstance(rhs))) {
+        return generalizeFn((a, b) => a + b, [lhs, rhs]); // component-wise addition
+    }
+    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})`
+export const add = dualImpl({
+    name: 'add',
+    signature: binaryArithmeticSignature,
+    normalImpl: cpuAdd,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '+', rhs),
+    sideEffects: false,
 });
 function cpuSub(lhs, rhs) {
-	return cpuAdd(lhs, cpuMul(-1, rhs));
+    // while illegal on the wgsl side, we can do this in js
+    return cpuAdd(lhs, cpuMul(-1, rhs));
 }
-const sub = dualImpl({
-	name: "sub",
-	signature: binaryArithmeticSignature,
-	normalImpl: cpuSub,
-	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} - ${rhs})`
+export const sub = dualImpl({
+    name: 'sub',
+    signature: binaryArithmeticSignature,
+    normalImpl: cpuSub,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '-', rhs),
+    sideEffects: false,
 });
 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.");
+    if (typeof lhs === 'number' && typeof rhs === 'number') {
+        return lhs * rhs; // default multiplication
+    }
+    if (typeof lhs === 'number' && (isVecInstance(rhs) || isMatInstance(rhs))) {
+        return generalizeFn((e) => lhs * e, [rhs]); // scale
+    }
+    if ((isVecInstance(lhs) || isMatInstance(lhs)) && typeof rhs === 'number') {
+        return generalizeFn((e) => e * rhs, [lhs]); // scale
+    }
+    if (isVecInstance(lhs) && isVecInstance(rhs)) {
+        return generalizeFn((a, b) => a * b, [lhs, rhs]); // component-wise
+    }
+    if (isFloat32VecInstance(lhs) && isMatInstance(rhs)) {
+        return VectorOps.mulVxM[rhs.kind](lhs, rhs); // row-vector-matrix
+    }
+    if (isMatInstance(lhs) && isFloat32VecInstance(rhs)) {
+        return VectorOps.mulMxV[lhs.kind](lhs, rhs); // matrix-column-vector
+    }
+    if (isMatInstance(lhs) && isMatInstance(rhs)) {
+        return VectorOps.mulMxM[lhs.kind](lhs, rhs); // matrix multiplication
+    }
+    throw new Error('Mul called with invalid arguments.');
 }
-const mul = dualImpl({
-	name: "mul",
-	signature: binaryMulSignature,
-	normalImpl: cpuMul,
-	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} * ${rhs})`
+export const mul = dualImpl({
+    name: 'mul',
+    signature: binaryMulSignature,
+    normalImpl: cpuMul,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '*', rhs),
+    sideEffects: false,
 });
 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.");
+    return generalizeFn((a, b) => a / b, upCast([lhs, rhs]));
 }
-const div = dualImpl({
-	name: "div",
-	signature: binaryDivSignature,
-	normalImpl: cpuDiv,
-	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} / ${rhs})`,
-	ignoreImplicitCastWarning: true
+export const div = dualImpl({
+    name: 'div',
+    signature: binaryDivSignature,
+    normalImpl: cpuDiv,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '/', rhs),
+    ignoreImplicitCastWarning: true,
+    sideEffects: false,
 });
 /**
-* @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})`
+ * @privateRemarks
+ * Both JS and WGSL implementations use truncated definition of modulo
+ */
+export const mod = dualImpl({
+    name: 'mod',
+    signature: binaryDivSignature,
+    normalImpl: ((a, b) => {
+        return generalizeFn((a, b) => a % b, upCast([a, b]));
+    }),
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '%', rhs),
+    sideEffects: false,
 });
 function cpuNeg(value) {
-	if (typeof value === "number") return -value;
-	return VectorOps.neg[value.kind](value);
+    return generalizeFn((value) => -value, [value]);
 }
-const neg = dualImpl({
-	name: "neg",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: cpuNeg,
-	codegenImpl: (_ctx, [arg]) => stitch`-(${arg})`
+export const neg = dualImpl({
+    name: 'neg',
+    signature: (arg) => ({
+        argTypes: [arg],
+        returnType: arg,
+    }),
+    normalImpl: cpuNeg,
+    codegenImpl: (_ctx, [arg]) => stitch `-(${arg})`,
+    sideEffects: false,
 });
-const anyConcreteInteger = [
-	i32,
-	u32,
-	vec2i,
-	vec3i,
-	vec4i,
-	vec2u,
-	vec3u,
-	vec4u
-];
 const intVecToUnsignedVec = {
-	vec2i: vec2u,
-	vec2u,
-	vec3i: vec3u,
-	vec3u,
-	vec4i: vec4u,
-	vec4u
+    vec2i: vec2u,
+    vec2u: vec2u,
+    vec3i: vec3u,
+    vec3u: vec3u,
+    vec4i: vec4u,
+    vec4u: vec4u,
 };
 const bitShiftSignature = (lhs, rhs) => {
-	const lhsUnified = unify([lhs], anyConcreteInteger)?.[0];
-	if (!lhsUnified) throw new SignatureNotSupportedError([lhs], anyConcreteInteger);
-	let rhsType;
-	if (isVec(lhsUnified)) {
-		const cc = lhsUnified.componentCount;
-		const vecU = cc === 2 ? vec2u : cc === 3 ? vec3u : vec4u;
-		const rhsUnified = unify([rhs], [u32, vecU])?.[0];
-		if (!rhsUnified) throw new SignatureNotSupportedError([rhs], [u32, vecU]);
-		rhsType = rhsUnified;
-	} else rhsType = u32;
-	return {
-		argTypes: [lhsUnified, rhsType],
-		returnType: lhsUnified
-	};
+    const lhsUnified = unify([lhs], [vec2i, vec3i, vec4i, vec2u, vec3u, vec4u])?.[0];
+    if (!lhsUnified || !isVec(lhsUnified)) {
+        throw new SignatureNotSupportedError([lhs], [vec2i, vec3i, vec4i, vec2u, vec3u, vec4u]);
+    }
+    const cc = lhsUnified.componentCount;
+    const vecU = cc === 2 ? vec2u : cc === 3 ? vec3u : vec4u;
+    const rhsUnified = unify([rhs], [u32, vecU])?.[0];
+    if (!rhsUnified) {
+        throw new SignatureNotSupportedError([rhs], [u32, vecU]);
+    }
+    return {
+        argTypes: [lhsUnified, rhsUnified],
+        returnType: lhsUnified,
+    };
 };
 function cpuBitShiftLeft(lhs, rhs) {
-	if (typeof lhs === "number" && typeof rhs === "number") return lhs << rhs;
-	if (isInteger32VecInstance(lhs) && isUint32VecInstance(rhs) && lhs.length == rhs.length) return VectorOps.bitShiftLeft[lhs.kind](lhs, rhs);
-	if (isInteger32VecInstance(lhs) && typeof rhs === "number") {
-		const rhsVec = intVecToUnsignedVec[lhs.kind](rhs);
-		return VectorOps.bitShiftLeft[lhs.kind](lhs, rhsVec);
-	}
-	throw new Error("bitShiftLeft called with invalid arguments, expected types: number or integer vector (rhs must be the same arity as lhs).");
+    if (isInteger32VecInstance(lhs) && isUint32VecInstance(rhs) && lhs.length == rhs.length) {
+        return VectorOps.bitShiftLeft[lhs.kind](lhs, rhs);
+    }
+    if (isInteger32VecInstance(lhs) && typeof rhs === 'number') {
+        const rhsVec = intVecToUnsignedVec[lhs.kind](rhs);
+        return VectorOps.bitShiftLeft[lhs.kind](lhs, rhsVec);
+    }
+    throw new Error("'bitShiftLeft' called with invalid arguments, expected: left-hand side to be an integer vector, right-hand side to be a number or unsigned integer vector of the same arity as the left-hand side.");
 }
-const bitShiftLeft = dualImpl({
-	name: "bitShiftLeft",
-	signature: bitShiftSignature,
-	normalImpl: cpuBitShiftLeft,
-	codegenImpl: (_ctx, [lhs, rhs]) => {
-		if (isVec(lhs.dataType) && !isVec(rhs.dataType)) {
-			const cc = lhs.dataType.componentCount;
-			return stitch`(${lhs} << ${cc === 2 ? "vec2u" : cc === 3 ? "vec3u" : "vec4u"}(${rhs}))`;
-		}
-		return stitch`(${lhs} << ${rhs})`;
-	}
+export const bitShiftLeft = dualImpl({
+    name: 'bitShiftLeft',
+    signature: bitShiftSignature,
+    normalImpl: cpuBitShiftLeft,
+    codegenImpl: (ctx, [lhs, rhs]) => {
+        if (isVec(lhs.dataType) && !isVec(rhs.dataType)) {
+            const cc = lhs.dataType.componentCount;
+            const schema = cc === 2 ? vec2u : cc === 3 ? vec3u : vec4u;
+            return ctx.gen.emitBinaryOp(lhs, '<<', ctx.gen.typeInstantiation(schema, [rhs]));
+        }
+        return ctx.gen.emitBinaryOp(lhs, '<<', rhs);
+    },
+    sideEffects: false,
 });
 function cpuBitShiftRight(lhs, rhs) {
-	if (typeof lhs === "number" && typeof rhs === "number") return lhs >> rhs;
-	if (isInteger32VecInstance(lhs) && isUint32VecInstance(rhs) && lhs.length == rhs.length) return VectorOps.bitShiftRight[lhs.kind](lhs, rhs);
-	if (isInteger32VecInstance(lhs) && typeof rhs === "number") {
-		const rhsVec = intVecToUnsignedVec[lhs.kind](rhs);
-		return VectorOps.bitShiftRight[lhs.kind](lhs, rhsVec);
-	}
-	throw new Error("bitShiftRight called with invalid arguments, expected types: number or integer vector (rhs must be the same arity as lhs).");
+    if (isInteger32VecInstance(lhs) && isUint32VecInstance(rhs) && lhs.length == rhs.length) {
+        return VectorOps.bitShiftRight[lhs.kind](lhs, rhs);
+    }
+    if (isInteger32VecInstance(lhs) && typeof rhs === 'number') {
+        const rhsVec = intVecToUnsignedVec[lhs.kind](rhs);
+        return VectorOps.bitShiftRight[lhs.kind](lhs, rhsVec);
+    }
+    throw new Error("'bitShiftRight' called with invalid arguments, expected: left-hand side to be an integer vector, right-hand side to be a number or unsigned integer vector of the same arity as the left-hand side.");
 }
-const bitShiftRight = dualImpl({
-	name: "bitShiftRight",
-	signature: bitShiftSignature,
-	normalImpl: cpuBitShiftRight,
-	codegenImpl: (_ctx, [lhs, rhs]) => {
-		if (isVec(lhs.dataType) && !isVec(rhs.dataType)) {
-			const cc = lhs.dataType.componentCount;
-			return stitch`(${lhs} >> ${cc === 2 ? "vec2u" : cc === 3 ? "vec3u" : "vec4u"}(${rhs}))`;
-		}
-		return stitch`(${lhs} >> ${rhs})`;
-	}
+export const bitShiftRight = dualImpl({
+    name: 'bitShiftRight',
+    signature: bitShiftSignature,
+    normalImpl: cpuBitShiftRight,
+    codegenImpl: (ctx, [lhs, rhs]) => {
+        if (isVec(lhs.dataType) && !isVec(rhs.dataType)) {
+            const cc = lhs.dataType.componentCount;
+            const schema = cc === 2 ? vec2u : cc === 3 ? vec3u : vec4u;
+            return ctx.gen.emitBinaryOp(lhs, '>>', ctx.gen.typeInstantiation(schema, [rhs]));
+        }
+        return ctx.gen.emitBinaryOp(lhs, '>>', rhs);
+    },
+    sideEffects: false,
 });
-
-//#endregion
-export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub };

package/std/packing.d.ts

@@ -1,27 +1,21 @@
-import { DualFn } from "../types.js";
-import { v2f, v4f } from "../data/wgslTypes.js";
-
-//#region src/std/packing.d.ts
-
+import type { v2f, v4f } from '../data/wgslTypes.ts';
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
  */
-declare const unpack2x16float: DualFn<(e: number) => v2f>;
+export declare const unpack2x16float: import("../types.ts").DualFn<(e: number) => v2f>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
  */
-declare const pack2x16float: DualFn<(e: v2f) => number>;
+export declare const pack2x16float: import("../types.ts").DualFn<(e: v2f) => number>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
  */
-declare const unpack4x8unorm: DualFn<(e: number) => v4f>;
+export declare const unpack4x8unorm: import("../types.ts").DualFn<(e: number) => v4f>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
  */
-declare const pack4x8unorm: DualFn<(e: v4f) => number>;
-//#endregion
-export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };
+export declare const pack4x8unorm: import("../types.ts").DualFn<(e: v4f) => number>;