The trick given in http://wiki.processing.org/w/Rect-Rect_intersection should work in JS too.

If you have two rectangles A and B and their edges are defined by the variables topA, botA, leftA, rightA  and   topB, botB, leftB, rightB

then  if the expresseion

(botA <= topB  || botB <= topA || rightA <= leftB || rightB <= leftA)

is true they do not overlap

If the expreseeion is false then they do overlap in which case work out the position of the overlap from

leftO = (leftA < leftB) ? leftB : leftA;
rightO = (rightA > rightB) ? rightB : rightA;
botO = (botA > botB) ? botB : botA;
topO = (topA < topB) ? topB : topA;

Well its more about the physic performance. If found this awesome code from Asher Salomon on Openprocessing.
Maybe i can modify this code for my intention.
Sadly this is no real vertex detection...

1. ArrayList particles;
2. float diam = 12;
3. float k = 0.5;
4. float c = 0.1;
5. float cw = 0.09;
6. void setup(){
7.   size(400,300);
8.   fill(255);
9.   smooth();
10.   noStroke();
11.   particles = new ArrayList();
12.   for(int i=0;i<100;i++){
13.     particles.add(new particle());
14.   }
15. }
16. void draw(){
17.   if(frameCount%30==0){println(frameRate);}
18.   background(0);
19.   for(int i=1;i<particles.size();i++){
20.     particle A = (particle) particles.get(i);
21.     for(int j=0;j<i;j++){
22.       particle B = (particle) particles.get(j);
23.       PVector dx = PVector.sub(B.x,A.x);
24.       if(abs(dx.x)<diam){
25.         if(abs(dx.y)<diam){
26.           if(dx.mag()<diam){
27.             float restore = (diam - dx.mag())*k;
28.             A.sum+=restore;
29.             B.sum+=restore;
30.             dx.normalize();
31.             float dampen = dx.dot(PVector.sub(B.v,A.v))*c;
32.             PVector F = PVector.mult(dx,restore - dampen);
33.             A.f.sub(F);
34.             B.f.add(F);
35.             PVector mid = PVector.mult(PVector.add(
36.               A.x,B.x),0.5);
37.             PVector vdiff = PVector.sub(B.Vat(mid),A.Vat(mid));
38.             vdiff.sub(PVector.mult(dx,dx.dot(vdiff)));
39.             vdiff.mult(cw);
40.             B.appF(vdiff,mid);
41.             vdiff.mult(-1);
42.             A.appF(vdiff,mid);
43.           }
44.         }
45.       }
46.     }
47.   }
48.   for(int i=0;i<particles.size();i++){
49.     particle A = (particle) particles.get(i);
50.     PVector mouseV = new PVector(mouseX,mouseY);
51.     PVector pmouseV = new PVector(pmouseX,pmouseY);
52.     if(mousePressed){
53.       PVector dx = PVector.sub(A.x,mouseV);
54.       float pushrad = 12;
55.       if(abs(dx.x)<pushrad){
56.         if(abs(dx.y)<pushrad){
57.           if(dx.mag()<pushrad){
58.             A.v.add(PVector.mult(PVector.sub(
59.               PVector.sub(mouseV,pmouseV),A.v),0.5));
60.           }
61.         }
62.       }
63.     }
64.   
65.     boolean dampen = false;
66.     if(A.x.x<0){
67.       A.f.x -= A.x.x*k;
68.       dampen = true;
69.     };
70.     if(A.x.x>width){
71.       A.f.x -= (A.x.x-width)*k;
72.       dampen = true;
73.     };
74.     if(A.x.y<0){
75.       A.f.y -= A.x.y*k;
76.       dampen = true;
77.     };
78.     if(A.x.y>height){
79.       A.f.y -= (A.x.y-height)*k;
80.       dampen = true;
81.     };
82.   
83.     if(dampen){A.v.mult(0.9);}
84.   
85.     colorMode(HSB,1);
86.     //fill(color(0.67-A.sum*0.67,1,1));
87.     fill(color(1,0,1));
88.   
89.     A.update();
90.   
91.     pushMatrix();
92.       translate(A.x.x,A.x.y);
93.       rotate(-A.theta);
94.       rect(0-3,0-5,6,10);
95.     popMatrix();
96.   }
97. }
98. class particle{
99.   PVector x;
100.   PVector v;
101.   PVector f;
102.   float theta;
103.   float omega;
104.   float torque;
105.   float sum;
106.  
107.   particle(){
108.     x = new PVector(random(0,width),random(0,height));
109.     v = new PVector();
110.     f = new PVector();
111.     theta = 0;
112.     omega = 0;
113.     torque = 0;
114.     sum = 0;
115.   }
116.   PVector Vat(PVector p){
117.     PVector arm = PVector.sub(p,x);
118.     PVector omegaV = new PVector(0,0,omega);
119.     return PVector.add(arm.cross(omegaV),v);
120.   }
121.  
122.   void appF(PVector F,PVector p){
123.     PVector arm = PVector.sub(p,x);
124.     torque += arm.cross(F).z;
125.   }
126.   void update(){
127.     v.add(f);
128.     f = new PVector(0,0.02);
129.     sum=0;
130.     x.add(v);
131.     omega += torque/(pow(diam/2,2)/2);
132.     torque = 0;
133.     omega = constrain(omega,-PI/4,PI/4);
134.     theta += omega;
135.   }
136. }