typegpu 0.11.9 → 0.12.1

package/std/numeric.d.ts

@@ -1,254 +1,258 @@
-import { DualFn } from "../types.js";
-import { AbstractFloat, AbstractInt, AnyFloat32VecInstance, AnyFloatVecInstance, AnyIntegerVecInstance, AnyMatInstance, AnyNumericVecInstance, AnySignedVecInstance, F16, F32, I32, Vec2f, Vec2h, Vec2i, Vec3f, Vec3h, Vec3i, Vec4f, Vec4h, Vec4i, WgslStruct, v2f, v2h, v2i, v3f, v3h, v3i, v4f, v4h, v4i } from "../data/wgslTypes.js";
-import { Infer } from "../shared/repr.js";
-
-//#region src/std/numeric.d.ts
+import { type AnyFloat32VecInstance, type AnyFloatVecInstance, type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type AnySignedVecInstance, type v2f, type v2h, type v2i, type v3f, type v3h, type v3i, type v4f, type v4h, type v4i, type Vec2f } from '../data/wgslTypes.ts';
+import type { Infer } from '../shared/repr.ts';
 type NumVec = AnyNumericVecInstance;
 declare function cpuAbs(value: number): number;
 declare function cpuAbs<T extends NumVec | number>(value: T): T;
-declare const abs: DualFn<typeof cpuAbs>;
+export declare const abs: import("../types.ts").DualFn<typeof cpuAbs>;
 declare function cpuAcos(value: number): number;
 declare function cpuAcos<T extends AnyFloatVecInstance>(value: T): T;
-declare const acos: DualFn<typeof cpuAcos>;
+export declare const acos: import("../types.ts").DualFn<typeof cpuAcos>;
 declare function cpuAcosh(value: number): number;
 declare function cpuAcosh<T extends AnyFloatVecInstance>(value: T): T;
-declare const acosh: DualFn<typeof cpuAcosh>;
+export declare const acosh: import("../types.ts").DualFn<typeof cpuAcosh>;
 declare function cpuAsin(value: number): number;
 declare function cpuAsin<T extends AnyFloatVecInstance>(value: T): T;
-declare const asin: DualFn<typeof cpuAsin>;
+export declare const asin: import("../types.ts").DualFn<typeof cpuAsin>;
 declare function cpuAsinh(value: number): number;
 declare function cpuAsinh<T extends AnyFloatVecInstance>(value: T): T;
-declare const asinh: DualFn<typeof cpuAsinh>;
+export declare const asinh: import("../types.ts").DualFn<typeof cpuAsinh>;
 declare function cpuAtan(value: number): number;
 declare function cpuAtan<T extends AnyFloatVecInstance>(value: T): T;
-declare const atan: DualFn<typeof cpuAtan>;
+export declare const atan: import("../types.ts").DualFn<typeof cpuAtan>;
 declare function cpuAtanh(value: number): number;
 declare function cpuAtanh<T extends AnyFloatVecInstance>(value: T): T;
-declare const atanh: DualFn<typeof cpuAtanh>;
+export declare const atanh: import("../types.ts").DualFn<typeof cpuAtanh>;
 declare function cpuAtan2(y: number, x: number): number;
 declare function cpuAtan2<T extends AnyFloatVecInstance>(y: T, x: T): T;
-declare const atan2: DualFn<typeof cpuAtan2>;
+export declare const atan2: import("../types.ts").DualFn<typeof cpuAtan2>;
 declare function cpuCeil(value: number): number;
 declare function cpuCeil<T extends AnyFloatVecInstance>(value: T): T;
-declare const ceil: DualFn<typeof cpuCeil>;
+export declare const ceil: import("../types.ts").DualFn<typeof cpuCeil>;
 declare function cpuClamp(value: number, low: number, high: number): number;
 declare function cpuClamp<T extends NumVec | number>(value: T, low: T, high: T): T;
-declare const clamp: DualFn<typeof cpuClamp>;
+export declare const clamp: import("../types.ts").DualFn<typeof cpuClamp>;
 declare function cpuCos(value: number): number;
 declare function cpuCos<T extends AnyFloatVecInstance>(value: T): T;
-declare const cos: DualFn<typeof cpuCos>;
+export declare const cos: import("../types.ts").DualFn<typeof cpuCos>;
 declare function cpuCosh(value: number): number;
 declare function cpuCosh<T extends AnyFloatVecInstance>(value: T): T;
-declare const cosh: DualFn<typeof cpuCosh>;
+export declare const cosh: import("../types.ts").DualFn<typeof cpuCosh>;
 declare function cpuCountLeadingZeros(value: number): number;
 declare function cpuCountLeadingZeros<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countLeadingZeros: DualFn<typeof cpuCountLeadingZeros>;
+export declare const countLeadingZeros: import("../types.ts").DualFn<typeof cpuCountLeadingZeros>;
 declare function cpuCountOneBits(value: number): number;
 declare function cpuCountOneBits<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countOneBits: DualFn<typeof cpuCountOneBits>;
+export declare const countOneBits: import("../types.ts").DualFn<typeof cpuCountOneBits>;
 declare function cpuCountTrailingZeros(value: number): number;
 declare function cpuCountTrailingZeros<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countTrailingZeros: DualFn<typeof cpuCountTrailingZeros>;
-declare const cross: DualFn<(<T extends v3f | v3h>(a: T, b: T) => T)>;
+export declare const countTrailingZeros: import("../types.ts").DualFn<typeof cpuCountTrailingZeros>;
+export declare const cross: import("../types.ts").DualFn<(<T extends v3f | v3h>(a: T, b: T) => T)>;
 declare function cpuDegrees(value: number): number;
 declare function cpuDegrees<T extends AnyFloatVecInstance>(value: T): T;
-declare const degrees: DualFn<typeof cpuDegrees>;
-declare const determinant: DualFn<(value: AnyMatInstance) => number>;
+export declare const degrees: import("../types.ts").DualFn<typeof cpuDegrees>;
+export declare const determinant: import("../types.ts").DualFn<(value: AnyMatInstance) => number>;
 declare function cpuDistance(a: number, b: number): number;
 declare function cpuDistance<T extends AnyFloatVecInstance>(a: T, b: T): number;
-declare const distance: DualFn<typeof cpuDistance>;
-declare const dot: DualFn<(<T extends NumVec>(lhs: T, rhs: T) => number)>;
-declare const dot4U8Packed: DualFn<(e1: number, e2: number) => number>;
-declare const dot4I8Packed: DualFn<(e1: number, e2: number) => number>;
+export declare const distance: import("../types.ts").DualFn<typeof cpuDistance>;
+export declare const dot: import("../types.ts").DualFn<(<T extends NumVec>(lhs: T, rhs: T) => number)>;
+export declare const dot4U8Packed: import("../types.ts").DualFn<(e1: number, e2: number) => number>;
+export declare const dot4I8Packed: import("../types.ts").DualFn<(e1: number, e2: number) => number>;
 declare function cpuExp(value: number): number;
 declare function cpuExp<T extends AnyFloatVecInstance>(value: T): T;
-declare const exp: DualFn<typeof cpuExp>;
+export declare const exp: import("../types.ts").DualFn<typeof cpuExp>;
 declare function cpuExp2(value: number): number;
 declare function cpuExp2<T extends AnyFloatVecInstance>(value: T): T;
-declare const exp2: DualFn<typeof cpuExp2>;
+export declare const exp2: import("../types.ts").DualFn<typeof cpuExp2>;
 declare function cpuExtractBits(e: number, offset: number, count: number): number;
 declare function cpuExtractBits<T extends AnyIntegerVecInstance>(e: T, offset: number, count: number): T;
-declare const extractBits: DualFn<typeof cpuExtractBits>;
-declare const faceForward: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T) => T)>;
+export declare const extractBits: import("../types.ts").DualFn<typeof cpuExtractBits>;
+export declare const faceForward: import("../types.ts").DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T) => T)>;
 declare function cpuFirstLeadingBit(value: number): number;
 declare function cpuFirstLeadingBit<T extends AnyIntegerVecInstance>(value: T): T;
-declare const firstLeadingBit: DualFn<typeof cpuFirstLeadingBit>;
+export declare const firstLeadingBit: import("../types.ts").DualFn<typeof cpuFirstLeadingBit>;
 declare function cpuFirstTrailingBit(value: number): number;
 declare function cpuFirstTrailingBit<T extends AnyIntegerVecInstance>(value: T): T;
-declare const firstTrailingBit: DualFn<typeof cpuFirstTrailingBit>;
+export declare const firstTrailingBit: import("../types.ts").DualFn<typeof cpuFirstTrailingBit>;
 declare function cpuFloor(value: number): number;
 declare function cpuFloor<T extends AnyFloatVecInstance>(value: T): T;
-declare const floor: DualFn<typeof cpuFloor>;
+export declare const floor: import("../types.ts").DualFn<typeof cpuFloor>;
 declare function cpuFma(e1: number, e2: number, e3: number): number;
 declare function cpuFma<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
-declare const fma: DualFn<typeof cpuFma>;
+export declare const fma: import("../types.ts").DualFn<typeof cpuFma>;
 declare function cpuFract(value: number): number;
 declare function cpuFract<T extends AnyFloatVecInstance>(value: T): T;
-declare const fract: DualFn<typeof cpuFract>;
+export declare const fract: import("../types.ts").DualFn<typeof cpuFract>;
 declare const FrexpResults: {
-  readonly f32: WgslStruct<{
-    fract: F32;
-    exp: I32;
-  }>;
-  readonly f16: WgslStruct<{
-    fract: F16;
-    exp: I32;
-  }>;
-  readonly abstractFloat: WgslStruct<{
-    fract: AbstractFloat;
-    exp: AbstractInt;
-  }>;
-  readonly vec2f: WgslStruct<{
-    fract: Vec2f;
-    exp: Vec2i;
-  }>;
-  readonly vec3f: WgslStruct<{
-    fract: Vec3f;
-    exp: Vec3i;
-  }>;
-  readonly vec4f: WgslStruct<{
-    fract: Vec4f;
-    exp: Vec4i;
-  }>;
-  readonly vec2h: WgslStruct<{
-    fract: Vec2h;
-    exp: Vec2i;
-  }>;
-  readonly vec3h: WgslStruct<{
-    fract: Vec3h;
-    exp: Vec3i;
-  }>;
-  readonly vec4h: WgslStruct<{
-    fract: Vec4h;
-    exp: Vec4i;
-  }>;
+    readonly f32: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").F32;
+        exp: import("../data/wgslTypes.ts").I32;
+    }>;
+    readonly f16: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").F16;
+        exp: import("../data/wgslTypes.ts").I32;
+    }>;
+    readonly abstractFloat: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").AbstractFloat;
+        exp: import("../data/wgslTypes.ts").AbstractInt;
+    }>;
+    readonly vec2f: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: Vec2f;
+        exp: import("../data/wgslTypes.ts").Vec2i;
+    }>;
+    readonly vec3f: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec3f;
+        exp: import("../data/wgslTypes.ts").Vec3i;
+    }>;
+    readonly vec4f: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec4f;
+        exp: import("../data/wgslTypes.ts").Vec4i;
+    }>;
+    readonly vec2h: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec2h;
+        exp: import("../data/wgslTypes.ts").Vec2i;
+    }>;
+    readonly vec3h: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec3h;
+        exp: import("../data/wgslTypes.ts").Vec3i;
+    }>;
+    readonly vec4h: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec4h;
+        exp: import("../data/wgslTypes.ts").Vec4i;
+    }>;
 };
 type FrexpOverload = {
-  (value: number): Infer<(typeof FrexpResults)['f32']>;
-  <T extends AnyFloatVecInstance>(value: T): Infer<(typeof FrexpResults)[T['kind']]>;
+    (value: number): Infer<(typeof FrexpResults)['f32']>;
+    <T extends AnyFloatVecInstance>(value: T): Infer<(typeof FrexpResults)[T['kind']]>;
 };
-declare const frexp: DualFn<FrexpOverload>;
+export declare const frexp: import("../types.ts").DualFn<FrexpOverload>;
 declare function cpuInsertBits(e: number, newbits: number, offset: number, count: number): number;
 declare function cpuInsertBits<T extends AnyIntegerVecInstance>(e: T, newbits: T, offset: number, count: number): T;
-declare const insertBits: DualFn<typeof cpuInsertBits>;
+export declare const insertBits: import("../types.ts").DualFn<typeof cpuInsertBits>;
 declare function cpuInverseSqrt(value: number): number;
 declare function cpuInverseSqrt<T extends AnyFloatVecInstance>(value: T): T;
-declare const inverseSqrt: DualFn<typeof cpuInverseSqrt>;
+export declare const inverseSqrt: import("../types.ts").DualFn<typeof cpuInverseSqrt>;
 declare function cpuLdexp(e1: number, e2: number): number;
 declare function cpuLdexp<T extends v2f | v2h>(e1: T, e2: v2i): T;
 declare function cpuLdexp<T extends v3f | v3h>(e1: T, e2: v3i): T;
 declare function cpuLdexp<T extends v4f | v4h>(e1: T, e2: v4i): T;
-declare const ldexp: DualFn<typeof cpuLdexp>;
+export declare const ldexp: import("../types.ts").DualFn<typeof cpuLdexp>;
 declare function cpuLength(value: number): number;
 declare function cpuLength<T extends AnyFloatVecInstance>(value: T): number;
-declare const length: DualFn<typeof cpuLength>;
+export declare const length: import("../types.ts").DualFn<typeof cpuLength>;
 declare function cpuLog(value: number): number;
 declare function cpuLog<T extends AnyFloatVecInstance>(value: T): T;
-declare const log: DualFn<typeof cpuLog>;
+export declare const log: import("../types.ts").DualFn<typeof cpuLog>;
 declare function cpuLog2(value: number): number;
 declare function cpuLog2<T extends AnyFloatVecInstance>(value: T): T;
-declare const log2: DualFn<typeof cpuLog2>;
+export declare const log2: import("../types.ts").DualFn<typeof cpuLog2>;
 type VariadicOverload = {
-  (fst: number, ...rest: number[]): number;
-  <T extends NumVec>(fst: T, ...rest: T[]): T;
+    (fst: number, ...rest: number[]): number;
+    <T extends NumVec>(fst: T, ...rest: T[]): T;
 };
-declare const max: DualFn<VariadicOverload>;
-declare const min: DualFn<VariadicOverload>;
+export declare const max: import("../types.ts").DualFn<VariadicOverload>;
+export declare const min: import("../types.ts").DualFn<VariadicOverload>;
 declare function cpuMix(e1: number, e2: number, e3: number): number;
 declare function cpuMix<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number): T;
 declare function cpuMix<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
-declare const mix: DualFn<typeof cpuMix>;
+export declare const mix: import("../types.ts").DualFn<typeof cpuMix>;
 declare const ModfResult: {
-  readonly f32: WgslStruct<{
-    fract: F32;
-    whole: F32;
-  }>;
-  readonly f16: WgslStruct<{
-    fract: F16;
-    whole: F16;
-  }>;
-  readonly abstractFloat: WgslStruct<{
-    fract: AbstractFloat;
-    whole: AbstractFloat;
-  }>;
-  readonly vec2f: WgslStruct<{
-    fract: Vec2f;
-    whole: Vec2f;
-  }>;
-  readonly vec3f: WgslStruct<{
-    fract: Vec3f;
-    whole: Vec3f;
-  }>;
-  readonly vec4f: WgslStruct<{
-    fract: Vec4f;
-    whole: Vec4f;
-  }>;
-  readonly vec2h: WgslStruct<{
-    fract: Vec2h;
-    whole: Vec2h;
-  }>;
-  readonly vec3h: WgslStruct<{
-    fract: Vec3h;
-    whole: Vec3h;
-  }>;
-  readonly vec4h: WgslStruct<{
-    fract: Vec4h;
-    whole: Vec4h;
-  }>;
+    readonly f32: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").F32;
+        whole: import("../data/wgslTypes.ts").F32;
+    }>;
+    readonly f16: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").F16;
+        whole: import("../data/wgslTypes.ts").F16;
+    }>;
+    readonly abstractFloat: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").AbstractFloat;
+        whole: import("../data/wgslTypes.ts").AbstractFloat;
+    }>;
+    readonly vec2f: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: Vec2f;
+        whole: Vec2f;
+    }>;
+    readonly vec3f: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec3f;
+        whole: import("../data/wgslTypes.ts").Vec3f;
+    }>;
+    readonly vec4f: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec4f;
+        whole: import("../data/wgslTypes.ts").Vec4f;
+    }>;
+    readonly vec2h: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec2h;
+        whole: import("../data/wgslTypes.ts").Vec2h;
+    }>;
+    readonly vec3h: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec3h;
+        whole: import("../data/wgslTypes.ts").Vec3h;
+    }>;
+    readonly vec4h: import("../data/wgslTypes.ts").WgslStruct<{
+        fract: import("../data/wgslTypes.ts").Vec4h;
+        whole: import("../data/wgslTypes.ts").Vec4h;
+    }>;
 };
 type ModfOverload = {
-  (value: number): Infer<(typeof ModfResult)['f32']>;
-  <T extends AnyFloatVecInstance>(value: T): Infer<(typeof ModfResult)[T['kind']]>;
+    (value: number): Infer<(typeof ModfResult)['f32']>;
+    <T extends AnyFloatVecInstance>(value: T): Infer<(typeof ModfResult)[T['kind']]>;
 };
-declare const modf: ModfOverload;
-declare const normalize: DualFn<(<T extends AnyFloatVecInstance>(v: T) => T)>;
+export declare const modf: ModfOverload;
+export declare const normalize: import("../types.ts").DualFn<(<T extends AnyFloatVecInstance>(v: T) => T)>;
 declare function powCpu(base: number, exponent: number): number;
 declare function powCpu<T extends AnyFloatVecInstance>(base: T, exponent: T): T;
-declare const pow: DualFn<typeof powCpu>;
+export declare const pow: import("../types.ts").DualFn<typeof powCpu>;
 declare function cpuQuantizeToF16(value: number): number;
 declare function cpuQuantizeToF16<T extends AnyFloat32VecInstance>(value: T): T;
-declare const quantizeToF16: DualFn<typeof cpuQuantizeToF16>;
+export declare const quantizeToF16: import("../types.ts").DualFn<typeof cpuQuantizeToF16>;
 declare function cpuRadians(value: number): number;
 declare function cpuRadians<T extends AnyFloatVecInstance | number>(value: T): T;
-declare const radians: DualFn<typeof cpuRadians>;
-declare const reflect: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T) => T)>;
-declare const refract: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number) => T)>;
+export declare const radians: import("../types.ts").DualFn<typeof cpuRadians>;
+export declare const reflect: import("../types.ts").DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T) => T)>;
+export declare const refract: import("../types.ts").DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number) => T)>;
 declare function cpuReverseBits(value: number): number;
 declare function cpuReverseBits<T extends AnyIntegerVecInstance>(value: T): T;
-declare const reverseBits: DualFn<typeof cpuReverseBits>;
+export declare const reverseBits: import("../types.ts").DualFn<typeof cpuReverseBits>;
 declare function cpuRound(value: number): number;
 declare function cpuRound<T extends AnyFloatVecInstance>(value: T): T;
-declare const round: DualFn<typeof cpuRound>;
+export declare const round: import("../types.ts").DualFn<typeof cpuRound>;
 declare function cpuSaturate(value: number): number;
 declare function cpuSaturate<T extends AnyFloatVecInstance>(value: T): T;
-declare const saturate: DualFn<typeof cpuSaturate>;
+export declare const saturate: import("../types.ts").DualFn<typeof cpuSaturate>;
 declare function cpuSign(e: number): number;
 declare function cpuSign<T extends AnySignedVecInstance>(e: T): T;
-declare const sign: DualFn<typeof cpuSign>;
+export declare const sign: import("../types.ts").DualFn<typeof cpuSign>;
 declare function cpuSin(value: number): number;
 declare function cpuSin<T extends AnyFloatVecInstance>(value: T): T;
-declare const sin: DualFn<typeof cpuSin>;
+export declare const sin: import("../types.ts").DualFn<typeof cpuSin>;
 declare function cpuSinh(value: number): number;
 declare function cpuSinh<T extends AnyFloatVecInstance>(value: T): T;
-declare const sinh: DualFn<typeof cpuSinh>;
+export declare const sinh: import("../types.ts").DualFn<typeof cpuSinh>;
 declare function cpuSmoothstep(edge0: number, edge1: number, x: number): number;
 declare function cpuSmoothstep<T extends AnyFloatVecInstance>(edge0: T, edge1: T, x: T): T;
-declare const smoothstep: DualFn<typeof cpuSmoothstep>;
+export declare const smoothstep: import("../types.ts").DualFn<typeof cpuSmoothstep>;
 declare function cpuSqrt(value: number): number;
 declare function cpuSqrt<T extends AnyFloatVecInstance>(value: T): T;
-declare const sqrt: DualFn<typeof cpuSqrt>;
+export declare const sqrt: import("../types.ts").DualFn<typeof cpuSqrt>;
 declare function cpuStep(edge: number, x: number): number;
 declare function cpuStep<T extends AnyFloatVecInstance | number>(edge: T, x: T): T;
-declare const step: DualFn<typeof cpuStep>;
+export declare const step: import("../types.ts").DualFn<typeof cpuStep>;
 declare function cpuTan(value: number): number;
 declare function cpuTan<T extends AnyFloatVecInstance>(value: T): T;
-declare const tan: DualFn<typeof cpuTan>;
+export declare const tan: import("../types.ts").DualFn<typeof cpuTan>;
 declare function cpuTanh(value: number): number;
 declare function cpuTanh<T extends AnyFloatVecInstance>(value: T): T;
-declare const tanh: DualFn<typeof cpuTanh>;
-declare const transpose: DualFn<(<T extends AnyMatInstance>(e: T) => T)>;
+export declare const tanh: import("../types.ts").DualFn<typeof cpuTanh>;
+declare function cpuTranspose<T extends AnyMatInstance>(value: T): T;
+export declare const transpose: import("../types.ts").DualFn<typeof cpuTranspose>;
 declare function cpuTrunc(value: number): number;
 declare function cpuTrunc<T extends AnyFloatVecInstance>(value: T): T;
-declare const trunc: DualFn<typeof cpuTrunc>;
-//#endregion
-export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, 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 };
+export declare const trunc: import("../types.ts").DualFn<typeof cpuTrunc>;
+declare function cpuIntdiv(lhs: number, rhs: number): number;
+/**
+ * Performs integer division on the passed in scalars.
+ * Equivalent to `trunc(trunc(lhs) / trunc(rhs))`. Coerces both
+ * arguments to integers if they're floating point.
+ */
+export declare const intdiv: import("../types.ts").DualFn<typeof cpuIntdiv>;
+export {};