typegpu 0.11.9 → 0.12.1

package/tgsl/forOfUtils.js

@@ -1,84 +1,99 @@
-import { $gpuCallable } from "../shared/symbols.js";
-import { isNaturallyEphemeral, isPtr, isVec, isWgslArray } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
 import { isAlias, snip } from "../data/snippet.js";
-import { WgslTypeError, invariant } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
-import { createPtrFromOrigin, implicitFrom } from "../data/ptr.js";
+import * as wgsl from "../data/wgslTypes.js";
 import { i32, u32 } from "../data/numeric.js";
-import { ArrayExpression, concretize } from "./generationHelpers.js";
-import { accessIndex } from "./accessIndex.js";
+import { invariant, WgslTypeError } from "../errors.js";
 import { arrayLength } from "../std/array.js";
+import { accessIndex } from "./accessIndex.js";
+import { createPtrFromOrigin, implicitFrom } from "../data/ptr.js";
+import { $gpuCallable } from "../shared/symbols.js";
+import { ArrayExpression, concretize } from "./generationHelpers.js";
 import { isTgpuRange } from "../std/range.js";
-
-//#region src/tgsl/forOfUtils.ts
-function getLoopVarKind(elementSnippet) {
-	return elementSnippet.origin === "constant-immutable-def" ? "const" : "let";
+export function getLoopVarKind(elementSnippet) {
+    // If it's ephemeral, it's a value that cannot change. If it's a reference, we take
+    // an implicit pointer to it
+    return elementSnippet.origin === 'constant-immutable-def' ? 'const' : 'let';
 }
-function getElementSnippet(iterableSnippet, index) {
-	const elementSnippet = accessIndex(iterableSnippet, index);
-	if (!elementSnippet) throw new WgslTypeError("`for ... of ...` loops only support array or vector iterables");
-	return elementSnippet;
+export function getElementSnippet(iterableSnippet, index) {
+    const elementSnippet = accessIndex(iterableSnippet, index);
+    if (!elementSnippet) {
+        throw new WgslTypeError('`for ... of ...` loops only support array or vector iterables');
+    }
+    return elementSnippet;
 }
 /**
-* Determines the type of the element as accessible inside of the `for .. of` loop body
-*/
-function getElementType(elementSnippet, iterableSnippet) {
-	let elementType = elementSnippet.dataType;
-	if (elementType === UnknownData) throw new WgslTypeError(stitch`The elements in iterable ${iterableSnippet} are of unknown type`);
-	if (isNaturallyEphemeral(elementSnippet.dataType) || elementSnippet.origin === "runtime" || elementSnippet.origin === "constant" || elementSnippet.origin === "constant-immutable-def" || elementSnippet.origin === "runtime-immutable-def") return elementType;
-	if (!isPtr(elementType)) {
-		const ptrType = createPtrFromOrigin(elementSnippet.origin, concretize(elementType));
-		invariant(ptrType !== void 0, `Creating pointer type from origin ${elementSnippet.origin}`);
-		elementType = ptrType;
-	}
-	return implicitFrom(elementType);
+ * Determines the type of the element as accessible inside of the `for .. of` loop body
+ */
+export function getElementType(elementSnippet, iterableSnippet) {
+    let elementType = elementSnippet.dataType;
+    if (elementType === UnknownData) {
+        throw new WgslTypeError(stitch `The elements in iterable ${iterableSnippet} are of unknown type`);
+    }
+    if (wgsl.isNaturallyEphemeral(elementSnippet.dataType) ||
+        elementSnippet.origin === 'runtime' ||
+        elementSnippet.origin === 'constant' ||
+        elementSnippet.origin === 'constant-immutable-def' ||
+        elementSnippet.origin === 'runtime-immutable-def') {
+        return elementType;
+    }
+    if (!wgsl.isPtr(elementType)) {
+        const ptrType = createPtrFromOrigin(elementSnippet.origin, concretize(elementType));
+        invariant(ptrType !== undefined, `Creating pointer type from origin ${elementSnippet.origin}`);
+        elementType = ptrType;
+    }
+    return implicitFrom(elementType);
 }
-function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
-	const { value, dataType } = iterableSnippet;
-	if (isTgpuRange(value)) {
-		const { start, end, step } = value;
-		const dataType$1 = [
-			start,
-			end,
-			step
-		].every((v) => v >= 0) ? u32 : i32;
-		return {
-			start: snip(start, dataType$1, "constant"),
-			end: snip(end, dataType$1, "constant"),
-			step: snip(step, dataType$1, "constant"),
-			comparison: step < 0 ? ">" : "<"
-		};
-	}
-	if (!unroll && !isAlias(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
+export function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
+    const { value, dataType } = iterableSnippet;
+    if (isTgpuRange(value)) {
+        const { start, end, step } = value;
+        const dataType = [start, end, step].every((v) => v >= 0) ? u32 : i32;
+        return {
+            start: snip(start, dataType, 'constant', false),
+            end: snip(end, dataType, 'constant', false),
+            step: snip(step, dataType, 'constant', false),
+            comparison: step < 0 ? '>' : '<',
+        };
+    }
+    if (!unroll && !isAlias(iterableSnippet)) {
+        throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
 -----
 You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.
 -----`);
-	const defaults = {
-		start: snip(0, u32, "constant"),
-		step: snip(1, u32, "constant"),
-		comparison: "<"
-	};
-	if (isWgslArray(dataType)) return {
-		...defaults,
-		end: dataType.elementCount > 0 ? snip(dataType.elementCount, u32, "constant") : arrayLength[$gpuCallable].call(ctx, [iterableSnippet])
-	};
-	if (isVec(dataType)) return {
-		...defaults,
-		end: snip(dataType.componentCount, u32, "constant")
-	};
-	if (unroll) {
-		if (Array.isArray(value)) return {
-			...defaults,
-			end: snip(value.length, u32, "constant")
-		};
-		if (value instanceof ArrayExpression) return {
-			...defaults,
-			end: snip(value.elements.length, u32, "constant")
-		};
-	}
-	throw new WgslTypeError("`for ... of ...` loops only support array or vector iterables");
+    }
+    const defaults = {
+        start: snip(0, u32, 'constant', false),
+        step: snip(1, u32, 'constant', false),
+        comparison: '<',
+    };
+    if (wgsl.isWgslArray(dataType)) {
+        return {
+            ...defaults,
+            end: dataType.elementCount > 0
+                ? snip(dataType.elementCount, u32, 'constant', false)
+                : arrayLength[$gpuCallable].call(ctx, [iterableSnippet]),
+        };
+    }
+    if (wgsl.isVec(dataType)) {
+        return {
+            ...defaults,
+            end: snip(dataType.componentCount, u32, 'constant', false),
+        };
+    }
+    if (unroll) {
+        if (Array.isArray(value)) {
+            return {
+                ...defaults,
+                end: snip(value.length, u32, 'constant', false),
+            };
+        }
+        if (value instanceof ArrayExpression) {
+            return {
+                ...defaults,
+                end: snip(value.elements.length, u32, 'constant', false),
+            };
+        }
+    }
+    throw new WgslTypeError('`for ... of ...` loops only support array or vector iterables');
 }
-
-//#endregion
-export { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets };

package/tgsl/generationHelpers.d.ts

@@ -1,39 +1,22 @@
-import { Snippet } from "../data/snippet.js";
-import { ShelllessRepository } from "./shellless.js";
-import { SupportedLogOp } from "./consoleLog/types.js";
-import { FunctionScopeLayer, ResolutionCtx } from "../types.js";
-import { BaseData } from "../data/wgslTypes.js";
-
-//#region src/tgsl/generationHelpers.d.ts
-
-type GenerationCtx = ResolutionCtx & {
-  readonly pre: string;
-  /**
-   * Used by `typedExpression` to signal downstream
-   * expression resolution what type is expected of them.
-   *
-   * It is used exclusively for inferring the types of structs and arrays.
-   * It is modified exclusively by `typedExpression` function.
-   */
-  expectedType: (BaseData | BaseData[]) | undefined;
-  readonly topFunctionScope: FunctionScopeLayer | undefined;
-  readonly topFunctionReturnType: BaseData | undefined;
-  indent(): string;
-  dedent(): string;
-  pushBlockScope(): void;
-  popBlockScope(): void;
-  generateLog(op: SupportedLogOp, args: Snippet[]): Snippet;
-  getById(id: string): Snippet | null;
-  defineVariable(id: string, snippet: Snippet): void;
-  setBlockExternals(externals: Record<string, Snippet>): void;
-  clearBlockExternals(): void;
-  /**
-   * Types that are used in `return` statements are
-   * reported using this function, and used to infer
-   * the return type of the owning function.
-   */
-  reportReturnType(dataType: BaseData): void;
-  readonly shelllessRepo: ShelllessRepository;
-};
-//#endregion
-export { GenerationCtx };
+import type { ResolvedSnippet, Snippet } from '../data/snippet.ts';
+import { type AnyWgslData, type BaseData, type F32, type I32, type WgslArray } from '../data/wgslTypes.ts';
+import { type ResolutionCtx, type SelfResolvable } from '../types.ts';
+import { $internal, $resolve } from '../shared/symbols.ts';
+export declare function numericLiteralToSnippet(value: number): Snippet;
+export declare function concretize<T extends BaseData>(type: T): T | F32 | I32;
+export declare function concretizeSnippet(snippet: Snippet): Snippet;
+export declare function concretizeSnippets(args: Snippet[]): Snippet[];
+export declare function coerceToSnippet(value: unknown): Snippet;
+/**
+ * Intermediate representation for WGSL array expressions.
+ * Defers resolution. Stores array elements as snippets so the
+ * generator can access them when needed.
+ */
+export declare class ArrayExpression implements SelfResolvable {
+    readonly [$internal] = true;
+    readonly type: WgslArray<AnyWgslData>;
+    readonly elements: Snippet[];
+    constructor(type: WgslArray<AnyWgslData>, elements: Snippet[]);
+    toString(): string;
+    [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
+}

package/tgsl/generationHelpers.js

@@ -1,65 +1,92 @@
-import { $internal, $resolve } from "../shared/symbols.js";
-import { WORKAROUND_getSchema, isMatInstance, isNaturallyEphemeral, isVecInstance } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
-import { isAlias, isSnippet, snip } from "../data/snippet.js";
-import { WgslTypeError } from "../errors.js";
-import { getOwnSnippet } from "../types.js";
-import { isRef } from "../data/ref.js";
 import { abstractFloat, abstractInt, bool, f32, i32 } from "../data/numeric.js";
-
-//#region src/tgsl/generationHelpers.ts
-function numericLiteralToSnippet(value) {
-	if (value >= 2 ** 63 || value < -(2 ** 63)) return snip(value, abstractFloat, "constant", false);
-	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", false);
-	}
-	return snip(value, abstractFloat, "constant", false);
+import { isRef } from "../data/ref.js";
+import { isAlias, isSnippet, snip, withDataType } from "../data/snippet.js";
+import { isMatInstance, isNaturallyEphemeral, isVecInstance, WORKAROUND_getSchema, } from "../data/wgslTypes.js";
+import { getOwnSnippet } from "../types.js";
+import { WgslTypeError } from "../errors.js";
+import { $internal, $resolve } from "../shared/symbols.js";
+import { logger } from "../tgpuLogger.js";
+export function numericLiteralToSnippet(value) {
+    if (value >= 2 ** 63 || value < -(2 ** 63)) {
+        return snip(value, abstractFloat, /* origin */ 'constant', /* possibleSideEffects */ false);
+    }
+    // WGSL AbstractInt uses 64-bit precision, but JS numbers are only safe up to 2^53 - 1.
+    // Warn when values exceed this range to prevent precision loss.
+    if (Number.isInteger(value)) {
+        if (!Number.isSafeInteger(value)) {
+            logger.warn('precision-loss', `The integer ${value} exceeds the safe integer range and may have lost precision.`);
+        }
+        return snip(value, abstractInt, /* origin */ 'constant', /* possibleSideEffects */ false);
+    }
+    return snip(value, abstractFloat, /* origin */ 'constant', /* possibleSideEffects */ false);
 }
-function concretize(type) {
-	if (type.type === "abstractFloat") return f32;
-	if (type.type === "abstractInt") return i32;
-	return type;
+export 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);
+export function concretizeSnippet(snippet) {
+    return withDataType(concretize(snippet.dataType), snippet);
 }
-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", false);
-	if (typeof value === "string" || typeof value === "function" || typeof value === "object" || typeof value === "symbol" || typeof value === "undefined" || value === null) return snip(value, UnknownData, "constant", false);
-	if (typeof value === "number") return numericLiteralToSnippet(value);
-	if (typeof value === "boolean") return snip(value, bool, "constant", false);
-	return snip(value, UnknownData, "constant", false);
+export function concretizeSnippets(args) {
+    return args.map(concretizeSnippet);
+}
+export function coerceToSnippet(value) {
+    if (isSnippet(value)) {
+        // Already a snippet
+        return value;
+    }
+    if (isRef(value)) {
+        throw new Error('Cannot use refs (d.ref(...)) from the outer scope.');
+    }
+    // Maybe the value can tell us what snippet it is
+    const ownSnippet = getOwnSnippet(value);
+    if (ownSnippet) {
+        return ownSnippet;
+    }
+    if (isVecInstance(value) || isMatInstance(value)) {
+        return snip(value, WORKAROUND_getSchema(value), 
+        /* origin */ 'constant', 
+        /* possibleSideEffects */ false);
+    }
+    if (typeof value === 'number') {
+        return numericLiteralToSnippet(value);
+    }
+    if (typeof value === 'boolean') {
+        return snip(value, bool, /* origin */ 'constant', /* possibleSideEffects */ false);
+    }
+    return snip(value, UnknownData, /* origin */ 'constant', /* possibleSideEffects */ false);
 }
 /**
-* 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;
-	type;
-	elements;
-	constructor(type, elements) {
-		this.type = type;
-		this.elements = elements;
-	}
-	toString() {
-		return "ArrayExpression";
-	}
-	[$resolve](ctx) {
-		for (const elem of this.elements) if (isAlias(elem) && !isNaturallyEphemeral(elem.dataType)) {
-			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 ctx.gen.typeInstantiation(this.type, this.elements);
-	}
-};
-
-//#endregion
-export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippet, numericLiteralToSnippet };
+ * Intermediate representation for WGSL array expressions.
+ * Defers resolution. Stores array elements as snippets so the
+ * generator can access them when needed.
+ */
+export class ArrayExpression {
+    [$internal] = true;
+    type;
+    elements;
+    constructor(type, elements) {
+        this.type = type;
+        this.elements = elements;
+    }
+    toString() {
+        return 'ArrayExpression';
+    }
+    [$resolve](ctx) {
+        for (const elem of this.elements) {
+            // We check if there are no references among the elements
+            if (isAlias(elem) && !isNaturallyEphemeral(elem.dataType)) {
+                const snippetStr = ctx.resolveSnippet(elem).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 ctx.gen.typeInstantiation(this.type, this.elements);
+    }
+}

package/tgsl/infixDispatch.d.ts

@@ -0,0 +1,70 @@
+import type { MatBase } from '../data/matrix.ts';
+import { type Snippet } from '../data/snippet.ts';
+import type { VecBase } from '../data/vectorImpl.ts';
+import type { AnyMatInstance, AnyNumericVecInstance } from '../data/wgslTypes.ts';
+export declare const infixOperators: {
+    readonly add: import("../types.ts").DualFn<{
+        (lhs: number, rhs: number): number;
+        <T extends AnyNumericVecInstance>(lhs: number, rhs: T): T;
+        <T extends AnyNumericVecInstance>(lhs: T, rhs: number): T;
+        <T extends AnyNumericVecInstance | AnyMatInstance>(lhs: T, rhs: T): T;
+        <Lhs extends number | AnyNumericVecInstance | AnyMatInstance, Rhs extends Lhs extends number ? number | AnyNumericVecInstance : Lhs extends AnyNumericVecInstance ? number | Lhs : Lhs extends AnyMatInstance ? Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+    }>;
+    readonly sub: import("../types.ts").DualFn<{
+        (lhs: number, rhs: number): number;
+        <T extends AnyNumericVecInstance>(lhs: number, rhs: T): T;
+        <T extends AnyNumericVecInstance>(lhs: T, rhs: number): T;
+        <T extends AnyNumericVecInstance | AnyMatInstance>(lhs: T, rhs: T): T;
+        <Lhs extends number | AnyNumericVecInstance | AnyMatInstance, Rhs extends Lhs extends number ? number | AnyNumericVecInstance : Lhs extends AnyNumericVecInstance ? number | Lhs : Lhs extends AnyMatInstance ? Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+    }>;
+    readonly mul: import("../types.ts").DualFn<{
+        (lhs: number, rhs: number): number;
+        <MV extends AnyNumericVecInstance | AnyMatInstance>(lhs: number, rhs: MV): MV;
+        <MV extends AnyNumericVecInstance | AnyMatInstance>(lhs: MV, rhs: number): MV;
+        <V extends AnyNumericVecInstance>(lhs: V, rhs: V): V;
+        <M extends AnyMatInstance, V extends import("../data/wgslTypes.ts").vBaseForMat<M>>(lhs: V, rhs: M): V;
+        <M extends AnyMatInstance, V extends import("../data/wgslTypes.ts").vBaseForMat<M>>(lhs: M, rhs: V): V;
+        <M extends AnyMatInstance>(lhs: M, rhs: M): M;
+        <Lhs extends number | AnyNumericVecInstance | AnyMatInstance, Rhs extends Lhs extends number ? number | AnyNumericVecInstance | AnyMatInstance : Lhs extends AnyNumericVecInstance ? number | Lhs | import("../data/wgslTypes.ts").mBaseForVec<Lhs> : Lhs extends AnyMatInstance ? number | import("../data/wgslTypes.ts").vBaseForMat<Lhs> | Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+    }>;
+    readonly div: import("../types.ts").DualFn<{
+        (lhs: number, rhs: number): number;
+        <T extends AnyNumericVecInstance>(lhs: T, rhs: T): T;
+        <T extends AnyNumericVecInstance>(lhs: number, rhs: T): T;
+        <T extends AnyNumericVecInstance>(lhs: T, rhs: number): T;
+    }>;
+    readonly mod: import("../types.ts").DualFn<{
+        (a: number, b: number): number;
+        <T extends AnyNumericVecInstance>(a: T, b: T): T;
+        <T extends AnyNumericVecInstance>(a: number, b: T): T;
+        <T extends AnyNumericVecInstance>(a: T, b: number): T;
+    }>;
+    readonly bitShiftLeft: import("../types.ts").DualFn<(<T extends import("../data/wgslTypes.ts").AnyIntegerVecInstance>(lhs: T, rhs: number | import("../data/wgslTypes.ts").vecIToVecU<T>) => T)>;
+    readonly bitShiftRight: import("../types.ts").DualFn<(<T extends import("../data/wgslTypes.ts").AnyIntegerVecInstance>(lhs: T, rhs: number | import("../data/wgslTypes.ts").vecIToVecU<T>) => T)>;
+};
+type Numeric = number | AnyNumericVecInstance | AnyMatInstance;
+export type InfixOperatorName = keyof typeof infixOperators;
+export type InfixOperator = (typeof infixOperators)[InfixOperatorName];
+/**
+ * InfixDispatch is only used in codegen mode.
+ * `lhs` may either be Numeric or Snippet.
+ * @example
+ * const external = d.vec2u(1);
+ * const fn = () => {
+ *    'use gpu';
+ *    external.mul(2); // lhs is Numeric
+ *    d.vec2u(1).mul(2) // lhs is a snippet
+ * }
+ */
+export declare class InfixDispatch {
+    readonly lhs: Snippet | Numeric;
+    readonly operator: InfixOperator;
+    constructor(lhs: Snippet | Numeric, operator: InfixOperator);
+}
+export declare function isInfixDispatch(o: unknown): o is InfixDispatch;
+/**
+ * This function is used on vec/mat prototypes.
+ * This is done in runtime in order to avoid a circular dependency.
+ */
+export declare function assignInfixOperator<T extends typeof VecBase | typeof MatBase>(base: T, operator: InfixOperatorName, operatorSymbol: symbol): void;
+export {};

package/tgsl/infixDispatch.js

@@ -1,53 +1,55 @@
+import {} from "../data/snippet.js";
 import { inCodegenMode } from "../execMode.js";
 import { add, bitShiftLeft, bitShiftRight, div, mod, mul, sub } from "../std/operators.js";
-
-//#region src/tgsl/infixDispatch.ts
-const infixOperators = {
-	add,
-	sub,
-	mul,
-	div,
-	mod,
-	bitShiftLeft,
-	bitShiftRight
+export const infixOperators = {
+    add,
+    sub,
+    mul,
+    div,
+    mod,
+    bitShiftLeft,
+    bitShiftRight,
 };
 /**
-* InfixDispatch is only used in codegen mode.
-* `lhs` may either be Numeric or Snippet.
-* @example
-* const external = d.vec2u(1);
-* const fn = () => {
-*    'use gpu';
-*    external.mul(2); // lhs is Numeric
-*    d.vec2u(1).mul(2) // lhs is a snippet
-* }
-*/
-var InfixDispatch = class {
-	lhs;
-	operator;
-	constructor(lhs, operator) {
-		this.lhs = lhs;
-		this.operator = operator;
-	}
-};
-function isInfixDispatch(o) {
-	return o instanceof InfixDispatch;
+ * InfixDispatch is only used in codegen mode.
+ * `lhs` may either be Numeric or Snippet.
+ * @example
+ * const external = d.vec2u(1);
+ * const fn = () => {
+ *    'use gpu';
+ *    external.mul(2); // lhs is Numeric
+ *    d.vec2u(1).mul(2) // lhs is a snippet
+ * }
+ */
+export class InfixDispatch {
+    lhs;
+    operator;
+    constructor(lhs, operator) {
+        this.lhs = lhs;
+        this.operator = operator;
+    }
+}
+export function isInfixDispatch(o) {
+    return o instanceof InfixDispatch;
 }
 /**
-* This function is used on vec/mat prototypes.
-* This is done in runtime in order to avoid a circular dependency.
-*/
-function assignInfixOperator(base, operator, operatorSymbol) {
-	const opImpl = infixOperators[operator];
-	Object.defineProperty(base.prototype, operatorSymbol, { value: opImpl });
-	function jsInfixDispatchFor(arg) {
-		return opImpl(this, arg);
-	}
-	Object.defineProperty(base.prototype, operator, { get() {
-		if (inCodegenMode()) return new InfixDispatch(this, opImpl);
-		return jsInfixDispatchFor;
-	} });
+ * This function is used on vec/mat prototypes.
+ * This is done in runtime in order to avoid a circular dependency.
+ */
+export function assignInfixOperator(base, operator, operatorSymbol) {
+    const opImpl = infixOperators[operator];
+    Object.defineProperty(base.prototype, operatorSymbol, { value: opImpl });
+    // Returning this from a getter will work as if this was a vector/matrix's method.
+    function jsInfixDispatchFor(arg) {
+        // operator will perform all necessary type checks
+        return opImpl(this, arg);
+    }
+    Object.defineProperty(base.prototype, operator, {
+        get() {
+            if (inCodegenMode()) {
+                return new InfixDispatch(this, opImpl);
+            }
+            return jsInfixDispatchFor;
+        },
+    });
 }
-
-//#endregion
-export { InfixDispatch, assignInfixOperator, infixOperators, isInfixDispatch };

package/tgsl/jsPolyfills.d.ts

@@ -1,25 +1,22 @@
-import "../core/function/fnTypes.js";
-import "../types.js";
-
-//#region src/tgsl/jsPolyfills.d.ts
-declare const supportedLogOps: () => readonly [{
-  (...data: any[]): void;
-  (message?: any, ...optionalParams: any[]): void;
+import type { AnyFn } from '../core/function/fnTypes.ts';
+import type { DualFn } from '../types.ts';
+export declare const mathToStd: Map<AnyFn, DualFn<AnyFn>>;
+export declare const supportedLogOps: () => readonly [{
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
 }, {
-  (...data: any[]): void;
-  (message?: any, ...optionalParams: any[]): void;
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
 }, {
-  (...data: any[]): void;
-  (message?: any, ...optionalParams: any[]): void;
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
 }, {
-  (...data: any[]): void;
-  (message?: any, ...optionalParams: any[]): void;
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
 }, {
-  (...data: any[]): void;
-  (message?: any, ...optionalParams: any[]): void;
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
 }, {
-  (): void;
-  (): void;
+    (): void;
+    (): void;
 }];
-//#endregion
-export { supportedLogOps };