How to calculate the point of intercept in 3D space

Ok, i don't see your problem... Do you want to understand how it works or how you can use it?

Just copy the code in this section:
http://www.unifycommunity.com/wiki/index.php?title=Calculating_Lead_For_Projectiles#Calculating_the_intercept_point
into a new C-sharp script that is located in Standard Assets. Then you can use the function even in JS.

 using UnityEngine;
 using System.Collections;
 
 public class Intercept
 {
 
     //first-order intercept using absolute target position
     
     public static Vector3 FirstOrderIntercept(  Vector3 shooterPosition,
                                                 Vector3 shooterVelocity,
                                                 float shotSpeed,
                                                 Vector3 targetPosition,
                                                 Vector3 targetVelocity) {
         Vector3 targetRelativeVelocity = targetVelocity - shooterVelocity;
         float t = FirstOrderInterceptTime(  shotSpeed,
                                             targetPosition - shooterPosition,
                                             targetRelativeVelocity);
         return targetPosition + t*(targetRelativeVelocity);
     }
     //first-order intercept using relative target position
     public static float FirstOrderInterceptTime(float shotSpeed,
                                                 Vector3 targetRelativePosition,
                                                 Vector3 targetRelativeVelocity) {
         float velocitySquared = targetRelativeVelocity.sqrMagnitude;
         if(velocitySquared < 0.001f)
             return 0f;
     
         float a = velocitySquared - shotSpeed*shotSpeed;
     
         //handle similar velocities
         if (Mathf.Abs(a) < 0.001f) {
             float t = -targetRelativePosition.sqrMagnitude
                         /(2f*Vector3.Dot(   targetRelativeVelocity,
                                             targetRelativePosition));
             return Mathf.Max(t, 0f); //don't shoot back in time
         }
     
         float   b = 2f*Vector3.Dot(targetRelativeVelocity, targetRelativePosition),
                 c = targetRelativePosition.sqrMagnitude,
                 determinant = b*b - 4f*a*c;
        
         if (determinant > 0f) { //determinant > 0; two intercept paths (most common)
             float   t1 = (-b + Mathf.Sqrt(determinant))/(2f*a),
                     t2 = (-b - Mathf.Sqrt(determinant))/(2f*a);
             if (t1 > 0f) {
                 if (t2 > 0f)
                     return Mathf.Min(t1, t2); //both are positive
                 else
                     return t1; //only t1 is positive
             } else
                 return Mathf.Max(t2, 0f); //don't shoot back in time
         } else if (determinant < 0f) //determinant < 0; no intercept path
             return 0f;
         else //determinant = 0; one intercept path, pretty much never happens
             return Mathf.Max(-b/(2f*a), 0f); //don't shoot back in time
     }
 }

In JS you can use it like this:

 // I'll assume that both target and shooter are rigidbodies
 var target : Transform;
 var shotSpeed : float;
 
 function Update()
 {
     var interceptionPoint = Intercept.FirstOrderIntercept(transform.position, rigidbody.velocity, shotSpeed, target.position, target.rigidbody.velocity);
     // Do what you want
 }