@needle-tools/three 0.169.20 → 0.183.2-canary.0

package/src/nodes/math/OperatorNode.js

@@ -1,6 +1,25 @@
+import { WebGLCoordinateSystem } from '../../constants.js';
 import TempNode from '../core/TempNode.js';
-import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
+import StackTrace from '../core/StackTrace.js';
+import { addMethodChaining, Fn, int, nodeProxyIntent } from '../tsl/TSLCore.js';
+import { warn } from '../../utils.js';
+
+const _vectorOperators = {
+	'==': 'equal',
+	'!=': 'notEqual',
+	'<': 'lessThan',
+	'>': 'greaterThan',
+	'<=': 'lessThanEqual',
+	'>=': 'greaterThanEqual',
+	'%': 'mod'
+};
 
+/**
+ * This node represents basic mathematical and logical operations like addition,
+ * subtraction or comparisons (e.g. `equal()`).
+ *
+ * @augments TempNode
+ */
 class OperatorNode extends TempNode {
 
 	static get type() {
@@ -9,6 +28,14 @@ class OperatorNode extends TempNode {
 
 	}
 
+	/**
+	 * Constructs a new operator node.
+	 *
+	 * @param {string} op - The operator.
+	 * @param {Node} aNode - The first input.
+	 * @param {Node} bNode - The second input.
+	 * @param {...Node} params - Additional input parameters.
+	 */
 	constructor( op, aNode, bNode, ...params ) {
 
 		super();
@@ -28,13 +55,60 @@ class OperatorNode extends TempNode {
 
 		}
 
+		/**
+		 * The operator.
+		 *
+		 * @type {string}
+		 */
 		this.op = op;
+
+		/**
+		 * The first input.
+		 *
+		 * @type {Node}
+		 */
 		this.aNode = aNode;
+
+		/**
+		 * The second input.
+		 *
+		 * @type {Node}
+		 */
 		this.bNode = bNode;
 
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isOperatorNode = true;
+
+	}
+
+	/**
+	 * Returns the operator method name.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @param {string} output - The output type.
+	 * @returns {string} The operator method name.
+	 */
+	getOperatorMethod( builder, output ) {
+
+		return builder.getMethod( _vectorOperators[ this.op ], output );
+
 	}
 
-	getNodeType( builder, output ) {
+	/**
+	 * This method is overwritten since the node type is inferred from the operator
+	 * and the input node types.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @param {?string} [output=null] - The output type.
+	 * @return {string} The node type.
+	 */
+	getNodeType( builder, output = null ) {
 
 		const op = this.op;
 
@@ -42,11 +116,11 @@ class OperatorNode extends TempNode {
 		const bNode = this.bNode;
 
 		const typeA = aNode.getNodeType( builder );
-		const typeB = typeof bNode !== 'undefined' ? bNode.getNodeType( builder ) : null;
+		const typeB = bNode ? bNode.getNodeType( builder ) : null;
 
 		if ( typeA === 'void' || typeB === 'void' ) {
 
-			return 'void';
+			return output || 'void';
 
 		} else if ( op === '%' ) {
 
@@ -56,35 +130,53 @@ class OperatorNode extends TempNode {
 
 			return builder.getIntegerType( typeA );
 
-		} else if ( op === '!' || op === '==' || op === '&&' || op === '||' || op === '^^' ) {
+		} else if ( op === '!' || op === '&&' || op === '||' || op === '^^' ) {
 
 			return 'bool';
 
-		} else if ( op === '<' || op === '>' || op === '<=' || op === '>=' ) {
+		} else if ( op === '==' || op === '!=' || op === '<' || op === '>' || op === '<=' || op === '>=' ) {
 
-			const typeLength = output ? builder.getTypeLength( output ) : Math.max( builder.getTypeLength( typeA ), builder.getTypeLength( typeB ) );
+			const typeLength = Math.max( builder.getTypeLength( typeA ), builder.getTypeLength( typeB ) );
 
 			return typeLength > 1 ? `bvec${ typeLength }` : 'bool';
 
 		} else {
 
-			if ( typeA === 'float' && builder.isMatrix( typeB ) ) {
+			// Handle matrix operations
 
-				return typeB;
+			if ( builder.isMatrix( typeA ) ) {
+
+				if ( typeB === 'float' ) {
 
-			} else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
+					return typeA; // matrix * scalar = matrix
 
-				// matrix x vector
+				} else if ( builder.isVector( typeB ) ) {
 
-				return builder.getVectorFromMatrix( typeA );
+					return builder.getVectorFromMatrix( typeA ); // matrix * vector
 
-			} else if ( builder.isVector( typeA ) && builder.isMatrix( typeB ) ) {
+				} else if ( builder.isMatrix( typeB ) ) {
+
+					return typeA; // matrix * matrix
+
+				}
+
+			} else if ( builder.isMatrix( typeB ) ) {
+
+				if ( typeA === 'float' ) {
+
+					return typeB; // scalar * matrix = matrix
+
+				} else if ( builder.isVector( typeA ) ) {
+
+					return builder.getVectorFromMatrix( typeB ); // vector * matrix
+
+				}
 
-				// vector x matrix
+			}
 
-				return builder.getVectorFromMatrix( typeB );
+			// Handle non-matrix cases
 
-			} else if ( builder.getTypeLength( typeB ) > builder.getTypeLength( typeA ) ) {
+			if ( builder.getTypeLength( typeB ) > builder.getTypeLength( typeA ) ) {
 
 				// anytype x anytype: use the greater length vector
 
@@ -102,8 +194,7 @@ class OperatorNode extends TempNode {
 
 		const op = this.op;
 
-		const aNode = this.aNode;
-		const bNode = this.bNode;
+		const { aNode, bNode } = this;
 
 		const type = this.getNodeType( builder, output );
 
@@ -113,14 +204,18 @@ class OperatorNode extends TempNode {
 		if ( type !== 'void' ) {
 
 			typeA = aNode.getNodeType( builder );
-			typeB = typeof bNode !== 'undefined' ? bNode.getNodeType( builder ) : null;
+			typeB = bNode ? bNode.getNodeType( builder ) : null;
 
-			if ( op === '<' || op === '>' || op === '<=' || op === '>=' || op === '==' ) {
+			if ( op === '<' || op === '>' || op === '<=' || op === '>=' || op === '==' || op === '!=' ) {
 
 				if ( builder.isVector( typeA ) ) {
 
 					typeB = typeA;
 
+				} else if ( builder.isVector( typeB ) ) {
+
+					typeA = typeB;
+
 				} else if ( typeA !== typeB ) {
 
 					typeA = typeB = 'float';
@@ -132,17 +227,53 @@ class OperatorNode extends TempNode {
 				typeA = type;
 				typeB = builder.changeComponentType( typeB, 'uint' );
 
-			} else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
+			} else if ( op === '%' ) {
+
+				typeA = type;
+				typeB = builder.isInteger( typeA ) && builder.isInteger( typeB ) ? typeB : typeA;
+
+			} else if ( builder.isMatrix( typeA ) ) {
+
+				if ( typeB === 'float' ) {
+
+					// Keep matrix type for typeA, but ensure typeB stays float
+
+					typeB = 'float';
+
+				} else if ( builder.isVector( typeB ) ) {
+
+					// matrix x vector
+					typeB = builder.getVectorFromMatrix( typeA );
+
+				} else if ( builder.isMatrix( typeB ) ) {
+
+					// matrix x matrix - keep both types
+
+				} else {
+
+					typeA = typeB = type;
+
+				}
+
+			} else if ( builder.isMatrix( typeB ) ) {
+
+				if ( typeA === 'float' ) {
+
+					// Keep matrix type for typeB, but ensure typeA stays float
+
+					typeA = 'float';
+
+				} else if ( builder.isVector( typeA ) ) {
 
-				// matrix x vector
+					// vector x matrix
 
-				typeB = builder.getVectorFromMatrix( typeA );
+					typeA = builder.getVectorFromMatrix( typeB );
 
-			} else if ( builder.isVector( typeA ) && builder.isMatrix( typeB ) ) {
+				} else {
 
-				// vector x matrix
+					typeA = typeB = type;
 
-				typeA = builder.getVectorFromMatrix( typeB );
+				}
 
 			} else {
 
@@ -159,58 +290,45 @@ class OperatorNode extends TempNode {
 		}
 
 		const a = aNode.build( builder, typeA );
-		const b = typeof bNode !== 'undefined' ? bNode.build( builder, typeB ) : null;
+		const b = bNode ? bNode.build( builder, typeB ) : null;
 
-		const outputLength = builder.getTypeLength( output );
 		const fnOpSnippet = builder.getFunctionOperator( op );
 
 		if ( output !== 'void' ) {
 
-			if ( op === '<' && outputLength > 1 ) {
+			const isGLSL = builder.renderer.coordinateSystem === WebGLCoordinateSystem;
 
-				if ( builder.useComparisonMethod ) {
+			if ( op === '==' || op === '!=' || op === '<' || op === '>' || op === '<=' || op === '>=' ) {
 
-					return builder.format( `${ builder.getMethod( 'lessThan', output ) }( ${ a }, ${ b } )`, type, output );
+				if ( isGLSL ) {
 
-				} else {
+					if ( builder.isVector( typeA ) ) {
 
-					return builder.format( `( ${ a } < ${ b } )`, type, output );
-
-				}
+						return builder.format( `${ this.getOperatorMethod( builder, output ) }( ${ a }, ${ b } )`, type, output );
 
-			} else if ( op === '<=' && outputLength > 1 ) {
+					} else {
 
-				if ( builder.useComparisonMethod ) {
+						return builder.format( `( ${ a } ${ op } ${ b } )`, type, output );
 
-					return builder.format( `${ builder.getMethod( 'lessThanEqual', output ) }( ${ a }, ${ b } )`, type, output );
+					}
 
 				} else {
 
-					return builder.format( `( ${ a } <= ${ b } )`, type, output );
+					// WGSL
 
-				}
-
-			} else if ( op === '>' && outputLength > 1 ) {
-
-				if ( builder.useComparisonMethod ) {
-
-					return builder.format( `${ builder.getMethod( 'greaterThan', output ) }( ${ a }, ${ b } )`, type, output );
-
-				} else {
-
-					return builder.format( `( ${ a } > ${ b } )`, type, output );
+					return builder.format( `( ${ a } ${ op } ${ b } )`, type, output );
 
 				}
 
-			} else if ( op === '>=' && outputLength > 1 ) {
+			} else if ( op === '%' ) {
 
-				if ( builder.useComparisonMethod ) {
+				if ( builder.isInteger( typeB ) ) {
 
-					return builder.format( `${ builder.getMethod( 'greaterThanEqual', output ) }( ${ a }, ${ b } )`, type, output );
+					return builder.format( `( ${ a } % ${ b } )`, type, output );
 
 				} else {
 
-					return builder.format( `( ${ a } >= ${ b } )`, type, output );
+					return builder.format( `${ this.getOperatorMethod( builder, type ) }( ${ a }, ${ b } )`, type, output );
 
 				}
 
@@ -224,7 +342,29 @@ class OperatorNode extends TempNode {
 
 			} else {
 
-				return builder.format( `( ${ a } ${ op } ${ b } )`, type, output );
+				// Handle matrix operations
+
+				if ( builder.isMatrix( typeA ) && typeB === 'float' ) {
+
+					return builder.format( `( ${ b } ${ op } ${ a } )`, type, output );
+
+				} else if ( typeA === 'float' && builder.isMatrix( typeB ) ) {
+
+					return builder.format( `${ a } ${ op } ${ b }`, type, output );
+
+				} else {
+
+					let snippet = `( ${ a } ${ op } ${ b } )`;
+
+					if ( ! isGLSL && type === 'bool' && builder.isVector( typeA ) && builder.isVector( typeB ) ) {
+
+						snippet = `all${ snippet }`;
+
+					}
+
+					return builder.format( snippet, type, output );
+
+				}
 
 			}
 
@@ -236,7 +376,15 @@ class OperatorNode extends TempNode {
 
 			} else {
 
-				return builder.format( `${ a } ${ op } ${ b }`, type, output );
+				if ( builder.isMatrix( typeA ) && typeB === 'float' ) {
+
+					return builder.format( `${ b } ${ op } ${ a }`, type, output );
+
+				} else {
+
+					return builder.format( `${ a } ${ op } ${ b }`, type, output );
+
+				}
 
 			}
 
@@ -264,33 +412,305 @@ class OperatorNode extends TempNode {
 
 export default OperatorNode;
 
-export const add = /*@__PURE__*/ nodeProxy( OperatorNode, '+' );
-export const sub = /*@__PURE__*/ nodeProxy( OperatorNode, '-' );
-export const mul = /*@__PURE__*/ nodeProxy( OperatorNode, '*' );
-export const div = /*@__PURE__*/ nodeProxy( OperatorNode, '/' );
-export const modInt = /*@__PURE__*/ nodeProxy( OperatorNode, '%' );
-export const equal = /*@__PURE__*/ nodeProxy( OperatorNode, '==' );
-export const notEqual = /*@__PURE__*/ nodeProxy( OperatorNode, '!=' );
-export const lessThan = /*@__PURE__*/ nodeProxy( OperatorNode, '<' );
-export const greaterThan = /*@__PURE__*/ nodeProxy( OperatorNode, '>' );
-export const lessThanEqual = /*@__PURE__*/ nodeProxy( OperatorNode, '<=' );
-export const greaterThanEqual = /*@__PURE__*/ nodeProxy( OperatorNode, '>=' );
-export const and = /*@__PURE__*/ nodeProxy( OperatorNode, '&&' );
-export const or = /*@__PURE__*/ nodeProxy( OperatorNode, '||' );
-export const not = /*@__PURE__*/ nodeProxy( OperatorNode, '!' );
-export const xor = /*@__PURE__*/ nodeProxy( OperatorNode, '^^' );
-export const bitAnd = /*@__PURE__*/ nodeProxy( OperatorNode, '&' );
-export const bitNot = /*@__PURE__*/ nodeProxy( OperatorNode, '~' );
-export const bitOr = /*@__PURE__*/ nodeProxy( OperatorNode, '|' );
-export const bitXor = /*@__PURE__*/ nodeProxy( OperatorNode, '^' );
-export const shiftLeft = /*@__PURE__*/ nodeProxy( OperatorNode, '<<' );
-export const shiftRight = /*@__PURE__*/ nodeProxy( OperatorNode, '>>' );
+/**
+ * Returns the addition of two or more value.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @param {...Node} params - Additional input parameters.
+ * @returns {OperatorNode}
+ */
+export const add = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '+' ).setParameterLength( 2, Infinity ).setName( 'add' );
+
+/**
+ * Returns the subtraction of two or more value.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @param {...Node} params - Additional input parameters.
+ * @returns {OperatorNode}
+ */
+export const sub = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '-' ).setParameterLength( 2, Infinity ).setName( 'sub' );
+
+/**
+ * Returns the multiplication of two or more value.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @param {...Node} params - Additional input parameters.
+ * @returns {OperatorNode}
+ */
+export const mul = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '*' ).setParameterLength( 2, Infinity ).setName( 'mul' );
+
+/**
+ * Returns the division of two or more value.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @param {...Node} params - Additional input parameters.
+ * @returns {OperatorNode}
+ */
+export const div = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '/' ).setParameterLength( 2, Infinity ).setName( 'div' );
+
+/**
+ * Computes the remainder of dividing the first node by the second one.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const mod = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '%' ).setParameterLength( 2 ).setName( 'mod' );
+
+/**
+ * Checks if two nodes are equal.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const equal = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '==' ).setParameterLength( 2 ).setName( 'equal' );
+
+/**
+ * Checks if two nodes are not equal.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const notEqual = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '!=' ).setParameterLength( 2 ).setName( 'notEqual' );
+
+/**
+ * Checks if the first node is less than the second.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const lessThan = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '<' ).setParameterLength( 2 ).setName( 'lessThan' );
+
+/**
+ * Checks if the first node is greater than the second.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const greaterThan = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '>' ).setParameterLength( 2 ).setName( 'greaterThan' );
+
+/**
+ * Checks if the first node is less than or equal to the second.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const lessThanEqual = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '<=' ).setParameterLength( 2 ).setName( 'lessThanEqual' );
+
+/**
+ * Checks if the first node is greater than or equal to the second.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const greaterThanEqual = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '>=' ).setParameterLength( 2 ).setName( 'greaterThanEqual' );
+
+/**
+ * Performs a logical AND operation on multiple nodes.
+ *
+ * @tsl
+ * @function
+ * @param {...Node} nodes - The input nodes to be combined using AND.
+ * @returns {OperatorNode}
+ */
+export const and = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '&&' ).setParameterLength( 2, Infinity ).setName( 'and' );
+
+/**
+ * Performs a logical OR operation on multiple nodes.
+ *
+ * @tsl
+ * @function
+ * @param {...Node} nodes - The input nodes to be combined using OR.
+ * @returns {OperatorNode}
+ */
+export const or = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '||' ).setParameterLength( 2, Infinity ).setName( 'or' );
+
+/**
+ * Performs logical NOT on a node.
+ *
+ * @tsl
+ * @function
+ * @param {Node} value - The value.
+ * @returns {OperatorNode}
+ */
+export const not = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '!' ).setParameterLength( 1 ).setName( 'not' );
+
+/**
+ * Performs logical XOR on two nodes.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const xor = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '^^' ).setParameterLength( 2 ).setName( 'xor' );
+
+/**
+ * Performs bitwise AND on two nodes.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const bitAnd = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '&' ).setParameterLength( 2 ).setName( 'bitAnd' );
+
+/**
+ * Performs bitwise NOT on a node.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const bitNot = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '~' ).setParameterLength( 1 ).setName( 'bitNot' );
+
+/**
+ * Performs bitwise OR on two nodes.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const bitOr = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '|' ).setParameterLength( 2 ).setName( 'bitOr' );
+
+/**
+ * Performs bitwise XOR on two nodes.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const bitXor = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '^' ).setParameterLength( 2 ).setName( 'bitXor' );
+
+/**
+ * Shifts a node to the left.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The node to shift.
+ * @param {Node} b - The value to shift.
+ * @returns {OperatorNode}
+ */
+export const shiftLeft = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '<<' ).setParameterLength( 2 ).setName( 'shiftLeft' );
+
+/**
+ * Shifts a node to the right.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The node to shift.
+ * @param {Node} b - The value to shift.
+ * @returns {OperatorNode}
+ */
+export const shiftRight = /*@__PURE__*/ nodeProxyIntent( OperatorNode, '>>' ).setParameterLength( 2 ).setName( 'shiftRight' );
+
+/**
+ * Increments a node by 1.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The node to increment.
+ * @returns {OperatorNode}
+ */
+export const incrementBefore = Fn( ( [ a ] ) => {
+
+	a.addAssign( 1 );
+	return a;
+
+} );
+
+/**
+ * Decrements a node by 1.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The node to decrement.
+ * @returns {OperatorNode}
+ */
+export const decrementBefore = Fn( ( [ a ] ) => {
+
+	a.subAssign( 1 );
+	return a;
+
+} );
+
+/**
+ * Increments a node by 1 and returns the previous value.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The node to increment.
+ * @returns {OperatorNode}
+ */
+export const increment = /*@__PURE__*/ Fn( ( [ a ] ) => {
+
+	const temp = int( a ).toConst();
+	a.addAssign( 1 );
+	return temp;
+
+} );
+
+/**
+ * Decrements a node by 1 and returns the previous value.
+ *
+ * @tsl
+ * @function
+ * @param {Node} a - The node to decrement.
+ * @returns {OperatorNode}
+ */
+export const decrement = /*@__PURE__*/ Fn( ( [ a ] ) => {
+
+	const temp = int( a ).toConst();
+	a.subAssign( 1 );
+	return temp;
+
+} );
 
 addMethodChaining( 'add', add );
 addMethodChaining( 'sub', sub );
 addMethodChaining( 'mul', mul );
 addMethodChaining( 'div', div );
-addMethodChaining( 'modInt', modInt );
+addMethodChaining( 'mod', mod );
 addMethodChaining( 'equal', equal );
 addMethodChaining( 'notEqual', notEqual );
 addMethodChaining( 'lessThan', lessThan );
@@ -308,12 +728,25 @@ addMethodChaining( 'bitXor', bitXor );
 addMethodChaining( 'shiftLeft', shiftLeft );
 addMethodChaining( 'shiftRight', shiftRight );
 
-
-export const remainder = ( ...params ) => { // @deprecated, r168
-
-	console.warn( 'TSL.OperatorNode: .remainder() has been renamed to .modInt().' );
-	return modInt( ...params );
+addMethodChaining( 'incrementBefore', incrementBefore );
+addMethodChaining( 'decrementBefore', decrementBefore );
+addMethodChaining( 'increment', increment );
+addMethodChaining( 'decrement', decrement );
+
+/**
+ * @tsl
+ * @function
+ * @deprecated since r175. Use {@link mod} instead.
+ *
+ * @param {Node} a - The first input.
+ * @param {Node} b - The second input.
+ * @returns {OperatorNode}
+ */
+export const modInt = ( a, b ) => { // @deprecated, r175
+
+	warn( 'TSL: "modInt()" is deprecated. Use "mod( int( ... ) )" instead.', new StackTrace() );
+	return mod( int( a ), int( b ) );
 
 };
 
-addMethodChaining( 'remainder', remainder );
+addMethodChaining( 'modInt', modInt );