text: 'use strict';
  
  
  /*
  | This is an auto generated file.
  |
  | Editing this might be rather futile.
  */
  const tt_and = require( './and' );
  
  
  const tt_arrayLiteral = require( './arrayLiteral' );
  
  
  const tt_assign = require( './assign' );
  
  
  const tt_boolean = require( './boolean' );
  
  
  const tt_call = require( './call' );
  
  
  const tt_comma = require( './comma' );
  
  
  const tt_condition = require( './condition' );
  
  
  const tt_delete = require( './delete' );
  
  
  const tt_differs = require( './differs' );
  
  
  const tt_divide = require( './divide' );
  
  
  const tt_divideAssign = require( './divideAssign' );
  
  
  const tt_dot = require( './dot' );
  
  
  const tt_equals = require( './equals' );
  
  
  const tt_func = require( './func' );
  
  
  const tt_generator = require( './generator' );
  
  
  const tt_greaterOrEqual = require( './greaterOrEqual' );
  
  
  const tt_greaterThan = require( './greaterThan' );
  
  
  const tt_instanceof = require( './instanceof' );
  
  
  const tt_lessOrEqual = require( './lessOrEqual' );
  
  
  const tt_lessThan = require( './lessThan' );
  
  
  const tt_member = require( './member' );
  
  
  const tt_minus = require( './minus' );
  
  
  const tt_minusAssign = require( './minusAssign' );
  
  
  const tt_multiply = require( './multiply' );
  
  
  const tt_multiplyAssign = require( './multiplyAssign' );
  
  
  const tt_negate = require( './negate' );
  
  
  const tt_new = require( './new' );
  
  
  const tt_not = require( './not' );
  
  
  const tt_null = require( './null' );
  
  
  const tt_number = require( './number' );
  
  
  const tt_objLiteral = require( './objLiteral' );
  
  
  const tt_or = require( './or' );
  
  
  const tt_plus = require( './plus' );
  
  
  const tt_plusAssign = require( './plusAssign' );
  
  
  const tt_postDecrement = require( './postDecrement' );
  
  
  const tt_postIncrement = require( './postIncrement' );
  
  
  const tt_preDecrement = require( './preDecrement' );
  
  
  const tt_preIncrement = require( './preIncrement' );
  
  
  const tt_string = require( './string' );
  
  
  const tt_typeof = require( './typeof' );
  
  
  const tt_undefined = require( './undefined' );
  
  
  const tt_var = require( './var' );
  
  
  const tt_yield = require( './yield' );
  
  
  const tt_block = require( './block' );
  
  
  const tim_proto = tim.proto;
  
  
  /*
  | Constructor.
  */
  const Constructor =
  	function(
  		v_condition,
  		v_elsewise,
  		v_then
  	)
  {
  	this.condition = v_condition;
  
  	this.elsewise = v_elsewise;
  
  	this.then = v_then;
  
  	Object.freeze( this );
  };
  
  
  /*
  | Prototype shortcut
  */
  const prototype = Constructor.prototype;
  
  
  self.prototype = prototype;
  
  
  /*
  | Creates a new object.
  */
  self.create =
  prototype.create =
  	function(
  		// free strings
  	)
  {
  	let inherit;
  
  	let v_condition;
  
  	let v_elsewise;
  
  	let v_then;
  
  	if( this !== self )
  	{
  		inherit = this;
  
  		v_condition = this.condition;
  
  		v_elsewise = this.elsewise;
  
  		v_then = this.then;
  	}
  
  	for(
  		let a = 0, al = arguments.length;
  		a < al;
  		a += 2
  	)
  	{
  		let arg = arguments[ a + 1 ];
  
  		switch( arguments[ a ] )
  		{
  			case 'condition' :
  
  				if( arg !== pass )
  				{
  					v_condition = arg;
  				}
  
  				break;
  
  			case 'elsewise' :
  
  				if( arg !== pass )
  				{
  					v_elsewise = arg;
  				}
  
  				break;
  
  			case 'then' :
  
  				if( arg !== pass )
  				{
  					v_then = arg;
  				}
  
  				break;
  
  			default :
  
  				throw new Error( );
  		}
  	}
  
  /**/if( CHECK )
  /**/{
  /**/	if(
  /**/		v_condition.timtype !== tt_and
  /**/		&&
  /**/		v_condition.timtype !== tt_arrayLiteral
  /**/		&&
  /**/		v_condition.timtype !== tt_assign
  /**/		&&
  /**/		v_condition.timtype !== tt_boolean
  /**/		&&
  /**/		v_condition.timtype !== tt_call
  /**/		&&
  /**/		v_condition.timtype !== tt_comma
  /**/		&&
  /**/		v_condition.timtype !== tt_condition
  /**/		&&
  /**/		v_condition.timtype !== tt_delete
  /**/		&&
  /**/		v_condition.timtype !== tt_differs
  /**/		&&
  /**/		v_condition.timtype !== tt_divide
  /**/		&&
  /**/		v_condition.timtype !== tt_divideAssign
  /**/		&&
  /**/		v_condition.timtype !== tt_dot
  /**/		&&
  /**/		v_condition.timtype !== tt_equals
  /**/		&&
  /**/		v_condition.timtype !== tt_func
  /**/		&&
  /**/		v_condition.timtype !== tt_generator
  /**/		&&
  /**/		v_condition.timtype !== tt_greaterOrEqual
  /**/		&&
  /**/		v_condition.timtype !== tt_greaterThan
  /**/		&&
  /**/		v_condition.timtype !== tt_instanceof
  /**/		&&
  /**/		v_condition.timtype !== tt_lessOrEqual
  /**/		&&
  /**/		v_condition.timtype !== tt_lessThan
  /**/		&&
  /**/		v_condition.timtype !== tt_member
  /**/		&&
  /**/		v_condition.timtype !== tt_minus
  /**/		&&
  /**/		v_condition.timtype !== tt_minusAssign
  /**/		&&
  /**/		v_condition.timtype !== tt_multiply
  /**/		&&
  /**/		v_condition.timtype !== tt_multiplyAssign
  /**/		&&
  /**/		v_condition.timtype !== tt_negate
  /**/		&&
  /**/		v_condition.timtype !== tt_new
  /**/		&&
  /**/		v_condition.timtype !== tt_not
  /**/		&&
  /**/		v_condition.timtype !== tt_null
  /**/		&&
  /**/		v_condition.timtype !== tt_number
  /**/		&&
  /**/		v_condition.timtype !== tt_objLiteral
  /**/		&&
  /**/		v_condition.timtype !== tt_or
  /**/		&&
  /**/		v_condition.timtype !== tt_plus
  /**/		&&
  /**/		v_condition.timtype !== tt_plusAssign
  /**/		&&
  /**/		v_condition.timtype !== tt_postDecrement
  /**/		&&
  /**/		v_condition.timtype !== tt_postIncrement
  /**/		&&
  /**/		v_condition.timtype !== tt_preDecrement
  /**/		&&
  /**/		v_condition.timtype !== tt_preIncrement
  /**/		&&
  /**/		v_condition.timtype !== tt_string
  /**/		&&
  /**/		v_condition.timtype !== tt_typeof
  /**/		&&
  /**/		v_condition.timtype !== tt_undefined
  /**/		&&
  /**/		v_condition.timtype !== tt_var
  /**/		&&
  /**/		v_condition.timtype !== tt_yield
  /**/	)
  /**/	{
  /**/		throw new Error( );
  /**/	}
  /**/
  /**/	if( v_elsewise !== undefined && v_elsewise.timtype !== tt_block )
  /**/	{
  /**/		throw new Error( );
  /**/	}
  /**/
  /**/	if( v_then.timtype !== tt_block )
  /**/	{
  /**/		throw new Error( );
  /**/	}
  /**/}
  
  	if(
  		inherit
  		&&
  		(
  			v_condition === inherit.condition
  			||
  			v_condition.equals( inherit.condition )
  		)
  		&&
  		(
  			v_elsewise === inherit.elsewise
  			||
  			v_elsewise !== undefined && v_elsewise.timtype && v_elsewise.equals( inherit.elsewise )
  		)
  		&&
  		(
  			v_then === inherit.then
  			||
  			v_then.equals( inherit.then )
  		)
  	)
  	{
  		return inherit;
  	}
  
  	return new Constructor( v_condition, v_elsewise, v_then );
  };
  
  
  /*
  | Type reflection.
  */
  prototype.timtype = self;
  
  
  /*
  | Sets values by path.
  */
  prototype.setPath = tim_proto.setPath;
  
  
  /*
  | Gets values by path
  */
  prototype.getPath = tim_proto.getPath;
  
  
  /*
  | Tests equality of object.
  */
  prototype.equals =
  	function(
  		obj // object to compare to
  	)
  {
  	if( this === obj )
  	{
  		return true;
  	}
  
  	if( !obj )
  	{
  		return false;
  	}
  
  	if( obj.timtype !== self )
  	{
  		return false;
  	}
  
  	return (
  		(
  			this.condition === obj.condition
  			||
  			this.condition.equals( obj.condition )
  		)
  		&&
  		(
  			this.elsewise === obj.elsewise
  			||
  			this.elsewise !== undefined && this.elsewise.timtype && this.elsewise.equals( obj.elsewise )
  		)
  		&&
  		(
  			this.then === obj.then
  			||
  			this.then.equals( obj.then )
  		)
  	);
  };
  