DOMImplementation.prototype._parseLoop = function DOMImplementation__parseLoop(doc, p) {
    var iEvt, iNode, iAttr, strName;
    iNodeParent = doc;
  
    var el_close_count = 0;
  
    var entitiesList = new Array();
    var textNodesList = new Array();
  
    // if namespaceAware, add default namespace
    if (this.namespaceAware) {
      var iNS = doc.createNamespace(""); // add the default-default namespace
      iNS.setValue("http://www.w3.org/2000/xmlns/");
      doc._namespaces.setNamedItem(iNS);
    }
  
    // loop until SAX parser stops emitting events
    while(true) {
      // get next event
      iEvt = p.next();
  
      if (iEvt == XMLP._ELM_B) {                      // Begin-Element Event
        var pName = p.getName();                      // get the Element name
        pName = trim(pName, true, true);              // strip spaces from Element name
  
        if (!this.namespaceAware) {
          iNode = doc.createElement(p.getName());     // create the Element
  
          // add attributes to Element
          for(var i = 0; i < p.getAttributeCount(); i++) {
            strName = p.getAttributeName(i);          // get Attribute name
            iAttr = iNode.getAttributeNode(strName);  // if Attribute exists, use it
  
            if(!iAttr) {
              iAttr = doc.createAttribute(strName);   // otherwise create it
            }
  
            iAttr.setValue(p.getAttributeValue(i));   // set Attribute value
            iNode.setAttributeNode(iAttr);            // attach Attribute to Element
          }
        }
        else {  // Namespace Aware
          // create element (with empty namespaceURI,
          //  resolve after namespace 'attributes' have been parsed)
          iNode = doc.createElementNS("", p.getName());
  
          // duplicate ParentNode's Namespace definitions
          iNode._namespaces = iNodeParent._namespaces._cloneNodes(iNode);
  
          // add attributes to Element
          for(var i = 0; i < p.getAttributeCount(); i++) {
            strName = p.getAttributeName(i);          // get Attribute name
  
            // if attribute is a namespace declaration
            if (this._isNamespaceDeclaration(strName)) {
              // parse Namespace Declaration
              var namespaceDec = this._parseNSName(strName);
  
              if (strName != "xmlns") {
                iNS = doc.createNamespace(strName);   // define namespace
              }
              else {
                iNS = doc.createNamespace("");        // redefine default namespace
              }
              iNS.setValue(p.getAttributeValue(i));   // set value = namespaceURI
  
              iNode._namespaces.setNamedItem(iNS);    // attach namespace to namespace collection
            }
            else {  // otherwise, it is a normal attribute
              iAttr = iNode.getAttributeNode(strName);        // if Attribute exists, use it
  
              if(!iAttr) {
                iAttr = doc.createAttributeNS("", strName);   // otherwise create it
              }
  
              iAttr.setValue(p.getAttributeValue(i));         // set Attribute value
              iNode.setAttributeNodeNS(iAttr);                // attach Attribute to Element
  
              if (this._isIdDeclaration(strName)) {
                iNode.id = p.getAttributeValue(i);    // cache ID for getElementById()
              }
            }
          }
  
          // resolve namespaceURIs for this Element
          if (iNode._namespaces.getNamedItem(iNode.prefix)) {
            iNode.namespaceURI = iNode._namespaces.getNamedItem(iNode.prefix).value;
          }
  
          //  for this Element's attributes
          for (var i = 0; i < iNode.attributes.length; i++) {
            if (iNode.attributes.item(i).prefix != "") {  // attributes do not have a default namespace
              if (iNode._namespaces.getNamedItem(iNode.attributes.item(i).prefix)) {
                iNode.attributes.item(i).namespaceURI = iNode._namespaces.getNamedItem(iNode.attributes.item(i).prefix).value;
              }
            }
          }
        }
  
        // if this is the Root Element
        if (iNodeParent.nodeType == DOMNode.DOCUMENT_NODE) {
          iNodeParent.documentElement = iNode;        // register this Element as the Document.documentElement
        }
  
        iNodeParent.appendChild(iNode);               // attach Element to parentNode
        iNodeParent = iNode;                          // descend one level of the DOM Tree
      }
  
      else if(iEvt == XMLP._ELM_E) {                  // End-Element Event
        iNodeParent = iNodeParent.parentNode;         // ascend one level of the DOM Tree
      }
  
      else if(iEvt == XMLP._ELM_EMP) {                // Empty Element Event
        pName = p.getName();                          // get the Element name
        pName = trim(pName, true, true);              // strip spaces from Element name
  
        if (!this.namespaceAware) {
          iNode = doc.createElement(pName);           // create the Element
  
          // add attributes to Element
          for(var i = 0; i < p.getAttributeCount(); i++) {
            strName = p.getAttributeName(i);          // get Attribute name
            iAttr = iNode.getAttributeNode(strName);  // if Attribute exists, use it
  
            if(!iAttr) {
              iAttr = doc.createAttribute(strName);   // otherwise create it
            }
  
            iAttr.setValue(p.getAttributeValue(i));   // set Attribute value
            iNode.setAttributeNode(iAttr);            // attach Attribute to Element
          }
        }
        else {  // Namespace Aware
          // create element (with empty namespaceURI,
          //  resolve after namespace 'attributes' have been parsed)
          iNode = doc.createElementNS("", p.getName());
  
          // duplicate ParentNode's Namespace definitions
          iNode._namespaces = iNodeParent._namespaces._cloneNodes(iNode);
  
          // add attributes to Element
          for(var i = 0; i < p.getAttributeCount(); i++) {
            strName = p.getAttributeName(i);          // get Attribute name
  
            // if attribute is a namespace declaration
            if (this._isNamespaceDeclaration(strName)) {
              // parse Namespace Declaration
              var namespaceDec = this._parseNSName(strName);
  
              if (strName != "xmlns") {
                iNS = doc.createNamespace(strName);   // define namespace
              }
              else {
                iNS = doc.createNamespace("");        // redefine default namespace
              }
              iNS.setValue(p.getAttributeValue(i));   // set value = namespaceURI
  
              iNode._namespaces.setNamedItem(iNS);    // attach namespace to namespace collection
            }
            else {  // otherwise, it is a normal attribute
              iAttr = iNode.getAttributeNode(strName);        // if Attribute exists, use it
  
              if(!iAttr) {
                iAttr = doc.createAttributeNS("", strName);   // otherwise create it
              }
  
              iAttr.setValue(p.getAttributeValue(i));         // set Attribute value
              iNode.setAttributeNodeNS(iAttr);                // attach Attribute to Element
  
              if (this._isIdDeclaration(strName)) {
                iNode.id = p.getAttributeValue(i);    // cache ID for getElementById()
              }
            }
          }
  
          // resolve namespaceURIs for this Element
          if (iNode._namespaces.getNamedItem(iNode.prefix)) {
            iNode.namespaceURI = iNode._namespaces.getNamedItem(iNode.prefix).value;
          }
  
          //  for this Element's attributes
          for (var i = 0; i < iNode.attributes.length; i++) {
            if (iNode.attributes.item(i).prefix != "") {  // attributes do not have a default namespace
              if (iNode._namespaces.getNamedItem(iNode.attributes.item(i).prefix)) {
                iNode.attributes.item(i).namespaceURI = iNode._namespaces.getNamedItem(iNode.attributes.item(i).prefix).value;
              }
            }
          }
        }
  
        // if this is the Root Element
        if (iNodeParent.nodeType == DOMNode.DOCUMENT_NODE) {
          iNodeParent.documentElement = iNode;        // register this Element as the Document.documentElement
        }
  
        iNodeParent.appendChild(iNode);               // attach Element to parentNode
      }
      else if(iEvt == XMLP._TEXT || iEvt == XMLP._ENTITY) {                   // TextNode and entity Events
        // get Text content
        var pContent = p.getContent().substring(p.getContentBegin(), p.getContentEnd());
        
            if (!this.preserveWhiteSpace ) {
                  if (trim(pContent, true, true) == "") {
                          pContent = ""; //this will cause us not to create the text node below
                  }
            }
            
        if (pContent.length > 0) {                    // ignore empty TextNodes
          var textNode = doc.createTextNode(pContent);
          iNodeParent.appendChild(textNode); // attach TextNode to parentNode
  
          //the sax parser breaks up text nodes when it finds an entity. For
          //example hello&lt;there will fire a text, an entity and another text
          //this sucks for the dom parser because it looks to us in this logic
          //as three text nodes. I fix this by keeping track of the entity nodes
          //and when we're done parsing, calling normalize on their parent to
          //turn the multiple text nodes into one, which is what DOM users expect
          //the code to do this is at the bottom of this function
          if (iEvt == XMLP._ENTITY) {
              entitiesList[entitiesList.length] = textNode;
          }
                  else {
                          //I can't properly decide how to handle preserve whitespace
                          //until the siblings of the text node are built due to 
                          //the entitiy handling described above. I don't know that this
                          //will be all of the text node or not, so trimming is not appropriate
                          //at this time. Keep a list of all the text nodes for now
                          //and we'll process the preserve whitespace stuff at a later time.
                          textNodesList[textNodesList.length] = textNode;
                  }
        }
      }
      else if(iEvt == XMLP._PI) {                     // ProcessingInstruction Event
        // attach ProcessingInstruction to parentNode
        iNodeParent.appendChild(doc.createProcessingInstruction(p.getName(), p.getContent().substring(p.getContentBegin(), p.getContentEnd())));
      }
      else if(iEvt == XMLP._CDATA) {                  // CDATA Event
        // get CDATA data
        pContent = p.getContent().substring(p.getContentBegin(), p.getContentEnd());
  
        if (!this.preserveWhiteSpace) {
          pContent = trim(pContent, true, true);      // trim whitespace
          pContent.replace(/ +/g, ' ');               // collapse multiple spaces to 1 space
        }
  
        if (pContent.length > 0) {                    // ignore empty CDATANodes
          iNodeParent.appendChild(doc.createCDATASection(pContent)); // attach CDATA to parentNode
        }
      }
      else if(iEvt == XMLP._COMMENT) {                // Comment Event
        // get COMMENT data
        var pContent = p.getContent().substring(p.getContentBegin(), p.getContentEnd());
  
        if (!this.preserveWhiteSpace) {
          pContent = trim(pContent, true, true);      // trim whitespace
          pContent.replace(/ +/g, ' ');               // collapse multiple spaces to 1 space
        }
  
        if (pContent.length > 0) {                    // ignore empty CommentNodes
          iNodeParent.appendChild(doc.createComment(pContent));  // attach Comment to parentNode
        }
      }
      else if(iEvt == XMLP._DTD) {                    // ignore DTD events
      }
      else if(iEvt == XMLP._ERROR) {
        throw(new DOMException(DOMException.SYNTAX_ERR));
        // alert("Fatal Error: " + p.getContent() + "\nLine: " + p.getLineNumber() + "\nColumn: " + p.getColumnNumber() + "\n");
        // break;
      }
      else if(iEvt == XMLP._NONE) {                   // no more events
        if (iNodeParent == doc) {                     // confirm that we have recursed back up to root
          break;
        }
        else {
          throw(new DOMException(DOMException.SYNTAX_ERR));  // one or more Tags were not closed properly
        }
      }
    }
  
    //normalize any entities in the DOM to a single textNode
    var intCount = entitiesList.length;
    for (intLoop = 0; intLoop < intCount; intLoop++) {
        var entity = entitiesList[intLoop];
        //its possible (if for example two entities were in the
        //same domnode, that the normalize on the first entitiy
        //will remove the parent for the second. Only do normalize
        //if I can find a parent node
        var parentNode = entity.getParentNode();
        if (parentNode) {
            parentNode.normalize();
                    
                    //now do whitespace (if necessary)
                    //it was not done for text nodes that have entities
                    if(!this.preserveWhiteSpace) {
                                    var children = parentNode.getChildNodes();
                                  var intCount2 = children.getLength();
                                  for ( intLoop2 = 0; intLoop2 < intCount2; intLoop2++) {
                                          var child = children.item(intLoop2);
                                          if (child.getNodeType() == DOMNode.TEXT_NODE) {
                                                  var childData = child.getData();
                                                  childData = trim(childData, true, true);
                                                  childData.replace(/ +/g, ' ');
                                                  child.setData(childData);
                                          }
                                  }
                    }
        }
    }
    
    //do the preserve whitespace processing on the rest of the text nodes
    //It's possible (due to the processing above) that the node will have been
    //removed from the tree. Only do whitespace checking if parentNode is not null.
    //This may duplicate the whitespace processing for some nodes that had entities in them
    //but there's no way around that
    if (!this.preserveWhiteSpace) {
            var intCount = textNodesList.length;
          for (intLoop = 0; intLoop < intCount; intLoop++) {
                  var node = textNodesList[intLoop];
                  if (node.getParentNode() != null) {
                          var nodeData = node.getData();
                          nodeData = trim(nodeData, true, true);
                          nodeData.replace(/ +/g, ' ');
                          node.setData(nodeData);
                  }
          }
    
    }
  };