Need a js guru to help me out with this

function priorElement(html,cursor_pos){
 
    var re = /<\/?\w+((\s+\w+(\s*=\s*(?:".*?"|'.*?'|[^'">\s]+))?)+\s*|\s*)\/?>/gi
    var matches = html.match(re,html)
 
    var elements = [];
    var positions = [];
 
    // Run through all the matches
    for ( x in matches )
    {
        // Strip all the randon stuff so we just have the element.
        var stripped_element = matches[x].replace(/\s[^\/>]+/g,'');
 
        // If it has a trailing backslash ignore it
        if(stripped_element.match(/\w\//)) // may want to look for these instead like in your script area|base|basefont|br|hr|input|img|link|meta
            continue;
 
        // Get rid of the `>` so we can match Ex. <a href="" class=""> turns, we need to
        // matchs `<a` and not `<a>`    
        var stripped_element = stripped_element.substring(0,stripped_element.length-1)
 
        positions.push(html.search(stripped_element));
        elements.push(stripped_element);
 
    }
 
    if(positions && elements) {
       
        var element = 0;
        for(var i in positions)
        {
            if(positions[i] > cursor_pos)
            {
                // Find the element right before our cursor
                element = i - 1;
                break;
            }
        }
 
        if(elements[element] == undefined)
            return;
 
        // return just the element, a, center, div, span...
        return elements[element].replace(/[\<\/\>]/,'');
    }
    return;
}

function unclosed(html,cursor_pos){
 
   //Remove any text after the cursor
   html = html.substr(0,cursor_pos);
   var re = /<[^<]+?>/gi
   var matches = html.match(re,html)
   var openers = [];
   var closers = [];
   var unclosed = [];
   
   // Run through all the matches
   for ( x in matches )
   {
      // Strip all the random stuff so we just have the element.
      var stripped_element = matches[x].replace(/\s[^\/>]+/g,'');
     
      // If it has a trailing backslash ignore it, since it's slef-closing
      if(stripped_element.match(/\w\//))
         continue;
 
      // Get rid of the `>` so we can match, we need to match `<a` and not `<a>`  
      var stripped_element = stripped_element.substring(0,stripped_element.length-1);
      stripped_element = stripped_element.replace("<","");
     
      // now we check to see if it is a closing element or not
      if(stripped_element.match(/\//))
      {
         //if it is, stick it in the "closers" array
         closers.push(stripped_element);
      }
      else
      {
         //otherwise put it in the "openers" array
            openers.push(stripped_element);
      }
   }
   
   // if there are just as many closing tags as there are opening tags
   // than all tags are closed, so return false.
   if(openers.length == closers.length || openers.length == 0)
   {
      return false;
   }
   
   // if the closers array is empty, push the openers to the
   // "unclosed" array and return the last entry
   else if(closers.length == 0 && openers.length > 0) {
      for ( x in openers )
      {
         unclosed.push(openers[x]);
      }
      return unclosed.pop();
   }
   
   // now we check for matches between opening and closing tags.
   else
   {
      // go through each entry in the "openers" array
      for (x in openers)
      {
         hasClose = new RegExp("\/"+openers[x],"gi");
         
         // see if theres a match for it in the "closers" array
         for (i in closers)
         {
            // if there is, remove the match from both arrays
            // and constinue to the next entry.
            if(closers[i].match(hasClose))
            {
               closers.splice(i,1);
               openers.splice(x,1);
               break;
            }
           
            // if there's not, add the "openers" entry to the
            // "unclosed" array
            else
            {
               unclosed.push(openers[x]);
            }
         }
      }
   // now return the last entry in the "unclosed" array.
   return unclosed.pop();
   } 
}