fast-xml-parser 4.0.0-beta.2 → 4.0.0-beta.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 Note: If you find missing information about particular minor version, that version must have been changed without any functional change in this library.
 
+** 4.0.0-beta.3 / 2021-11-30**
+* support global stopNodes expression like "*.stop"
+* support self-closing and paired unpaired tags
+* fix: CDATA should not be parsed.
+* Fix typings for XMLBuilder (#396)(By [Anders Emil Salvesen](https://github.com/andersem))
+* supports XML entities, HTML entities, DOCTYPE entities
+
 **⚠️ 4.0.0-beta.2 / 2021-11-19**
 * rename `attrMap` to `attibutes` in parser output when `preserveOrder:true`
 * supports unpairedTags

package/README.md

@@ -48,6 +48,13 @@ Check the list of all known users [here](./USERs.md);
 * Faster than any pure JS implementation.
 * It can handle big files (tested up to 100mb).
 * Controlled parsing using various options
+* XML Entities, HTML entities, and DOCTYPE entites are supported.
+* unpaired tags (Eg `<br>` in HTML), stop nodes (Eg `<script>` in HTML) are supported.
+* You can restore almost same XML from JSON
+* Supports comments
+* It can preserve Order of tags in JS object
+* You can control if a single tag should be parsed into array.
+* And many more other features.
 
 ## How to use
 
@@ -98,6 +105,7 @@ In a HTML page
 2.  [XML Parser](./docs/v4/2.XMLparseOptions.md)
 3.  [XML Builder](./docs/v4/3.XMLBuilder.md)
 4.  [XML Validator](./docs/v4/4.XMLValidator.md)
+5.  [Entites](./docs/5.Entities.md)
 
 ## Performance
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-xml-parser",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.0-beta.3",
   "description": "Validate XML, Parse XML, Build XML without C/C++ based libraries",
   "main": "./src/fxp.js",
   "scripts": {

package/src/fxp.d.ts

@@ -18,6 +18,8 @@ type X2jOptions = {
   unpairedTags: string[];
   alwaysCreateTextNode: boolean;
   isArray: (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean) => boolean;
+  processEntities: boolean;
+  htmlEntities: boolean;
 };
 type strnumOptions = {
   hex: boolean;
@@ -46,6 +48,7 @@ type XmlBuilderOptions = {
   unpairedTags: string[];
   tagValueProcessor: (name: string, value: string) => string;
   attributeValueProcessor: (name: string, value: string) => string;
+  processEntities: boolean;
 };
 type XmlBuilderOptionsOptional = Partial<XmlBuilderOptions>;
 
@@ -70,5 +73,5 @@ export class XMLValidator{
 }
 export class XMLBuilder {
   constructor(options: XmlBuilderOptionsOptional);
-  parse(options: any): any;
+  build(jObj: any): any;
 }

package/src/xmlbuilder/json2xml.js

@@ -21,6 +21,13 @@ const defaultOptions = {
   preserveOrder: false,
   commentPropName: false,
   unpairedTags: [],
+  entities: {
+    ">" : { regex: new RegExp(">", "g"), val: ">" },
+    "<" : { regex: new RegExp("<", "g"), val: "&lt;" },
+    "sQuot" : { regex: new RegExp("\'", "g"), val: "&apos;" },
+    "dQuot" : { regex: new RegExp("\"", "g"), val: "&quot;" }
+  },
+  processEntities: true
 };
 
 const props = [
@@ -38,6 +45,8 @@ const props = [
   'preserveOrder',
   "commentPropName",
   "unpairedTags",
+  "entities",
+  "processEntities",
   // 'rootNodeName', //when jsObject have multiple properties on root level
 ];
 
@@ -76,6 +85,8 @@ function Builder(options) {
 
   this.buildTextValNode = buildTextValNode;
   this.buildObjectNode = buildObjectNode;
+
+  this.replaceEntitiesValue = replaceEntitiesValue;
 }
 
 Builder.prototype.build = function(jObj) {
@@ -105,11 +116,14 @@ Builder.prototype.j2x = function(jObj, level) {
       //premitive type
       const attr = this.isAttribute(key);
       if (attr) {
-        attrStr += ' ' + attr + '="' + this.options.attributeValueProcessor(attr, '' + jObj[key]) + '"';
+        let val = this.options.attributeValueProcessor(attr, '' + jObj[key]);
+        val = this.replaceEntitiesValue(val);
+        attrStr += ' ' + attr + '="' + val + '"';
       }else {
         //tag value
         if (key === this.options.textNodeName) {
-          val += this.options.tagValueProcessor(key, '' + jObj[key]);
+          let newval = this.options.tagValueProcessor(key, '' + jObj[key]);
+          val += this.replaceEntitiesValue(newval);
         } else {
           val += this.buildTextNode(jObj[key], key, '', level);
         }
@@ -135,7 +149,9 @@ Builder.prototype.j2x = function(jObj, level) {
         const Ks = Object.keys(jObj[key]);
         const L = Ks.length;
         for (let j = 0; j < L; j++) {
-          attrStr += ' ' + Ks[j] + '="' + this.options.attributeValueProcessor(Ks[j], '' + jObj[key][Ks[j]]) + '"';
+          let val = this.options.attributeValueProcessor(Ks[j], '' + jObj[key][Ks[j]]);
+          val = this.replaceEntitiesValue(val);
+          attrStr += ' ' + Ks[j] + '="' + val + '"';
         }
       } else {
         val += this.processTextOrObjNode(jObj[key], key, level)
@@ -196,19 +212,32 @@ function buildEmptyObjNode(val, key, attrStr, level) {
 }
 
 function buildTextValNode(val, key, attrStr, level) {
+  let textValue = this.options.tagValueProcessor(key, val);
+  textValue = this.replaceEntitiesValue(textValue);
+  
   return (
     this.indentate(level) +
     '<' +
     key +
     attrStr +
     '>' +
-    this.options.tagValueProcessor(key, val) +
+     textValue +
     '</' +
     key +
     this.tagEndChar
   );
 }
 
+function replaceEntitiesValue(textValue){
+  if(textValue && textValue.length > 0 && this.options.processEntities){
+    for (const entityName in this.options.entities) {
+      const entity = this.options.entities[entityName];
+      textValue = textValue.replace(entity.regex, entity.val);
+    }
+  }
+  return textValue;
+}
+
 function buildEmptyTextNode(val, key, attrStr, level) {
   if( val === '' && this.options.unpairedTags.indexOf(key) !== -1){
     return this.indentate(level) + '<' + key + attrStr + this.tagEndChar;

package/src/xmlbuilder/orderedJs2Xml.js

@@ -23,7 +23,9 @@ function arrToStr(arr, options, level){
         const tagName = propName(tagObj);
 
         if(tagName === options.textNodeName){
-            xmlStr += indentation + options.tagValueProcessor( tagName, tagObj[tagName]);
+            let tagText = options.tagValueProcessor( tagName, tagObj[tagName]);
+            tagText = replaceEntitiesValue(tagText, options);
+            xmlStr += indentation + tagText;
             continue;
         }else if( tagName === options.cdataPropName){
             xmlStr += indentation + `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
@@ -62,10 +64,21 @@ function attr_to_str(attrMap, options){
     let attrStr = "";
     if(attrMap && !options.ignoreAttributes){
         for( attr in attrMap){
-            attrStr+= ` ${attr.substr(options.attributeNamePrefix.length)}="${options.attributeValueProcessor(attr, attrMap[attr])}"`;
+            let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
+            attrVal = replaceEntitiesValue(attrVal, options);
+            attrStr+= ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
         }
     }
     return attrStr;
 }
 
+function replaceEntitiesValue(textValue, options){
+    if(textValue && textValue.length > 0 && options.processEntities){
+      for (const entityName in options.entities) {
+        const entity = options.entities[entityName];
+        textValue = textValue.replace(entity.regex, entity.val);
+      }
+    }
+    return textValue;
+  }
 module.exports = toXml;

package/src/xmlparser/DocTypeReader.js

@@ -0,0 +1,92 @@
+//TODO: handle comments
+function readDocType(xmlData, i){
+    
+    const entities = {};
+    if( xmlData[i + 3] === 'O' &&
+         xmlData[i + 4] === 'C' &&
+         xmlData[i + 5] === 'T' &&
+         xmlData[i + 6] === 'Y' &&
+         xmlData[i + 7] === 'P' &&
+         xmlData[i + 8] === 'E')
+    {    
+        i = i+9;
+        let angleBracketsCount = 1;
+        let hasBody = false, entity = false, comment = false;
+        let exp = "";
+        for(;i<xmlData.length;i++){
+            if (xmlData[i] === '<') {
+                if( hasBody && 
+                     xmlData[i+1] === '!' &&
+                     xmlData[i+2] === 'E' &&
+                     xmlData[i+3] === 'N' &&
+                     xmlData[i+4] === 'T' &&
+                     xmlData[i+5] === 'I' &&
+                     xmlData[i+6] === 'T' &&
+                     xmlData[i+7] === 'Y'
+                ){
+                    i += 7;
+                    entity = true;
+                }else if( hasBody && 
+                    xmlData[i+1] === '!' &&
+                     xmlData[i+2] === 'E' &&
+                     xmlData[i+3] === 'L' &&
+                     xmlData[i+4] === 'E' &&
+                     xmlData[i+5] === 'M' &&
+                     xmlData[i+6] === 'E' &&
+                     xmlData[i+7] === 'N' &&
+                     xmlData[i+8] === 'T'
+                ){
+                    //Not supported
+                    i += 8;
+                }else if( //comment
+                    xmlData[i+1] === '!' &&
+                    xmlData[i+2] === '-' &&
+                    xmlData[i+3] === '-'
+                ){
+                    comment = true;
+                }else{
+                    throw new Error("Invalid DOCTYPE");
+                }
+                angleBracketsCount++;
+                exp = "";
+            } else if (xmlData[i] === '>') {
+                if(comment){
+                    if( xmlData[i - 1] === "-" && xmlData[i - 2] === "-"){
+                        comment = false;
+                    }else{
+                        throw new Error(`Invalid XML comment in DOCTYPE`);
+                    }
+                }else if(entity){
+                    parseEntityExp(exp, entities);
+                    entity = false;
+                }
+                angleBracketsCount--;
+                if (angleBracketsCount === 0) {
+                  break;
+                }
+            }else if( xmlData[i] === '['){
+                hasBody = true;
+            }else{
+                exp += xmlData[i];
+            }
+        }
+        if(angleBracketsCount !== 0){
+            throw new Error(`Unclosed DOCTYPE`);
+        }
+    }else{
+        throw new Error(`Invalid Tag instead of DOCTYPE`);
+    }
+    return {entities, i};
+}
+
+const entityRegex = RegExp("^\\s([a-zA-z0-0]+)[ \t](['\"])([^&]+)\\2");
+function parseEntityExp(exp, entities){
+    const match = entityRegex.exec(exp);
+    if(match){
+        entities[ match[1] ] = {
+            regx : RegExp( `&${match[1]};`,"g"),
+            val: match[3]
+        };
+    }
+}
+module.exports = readDocType;

package/src/xmlparser/OptionsBuilder.js

@@ -27,6 +27,8 @@ const defaultOptions = {
     isArray: () => false,
     commentPropName: false,
     unpairedTags: [],
+    processEntities: true,
+    htmlEntities: false,
 };
    
 const props = [
@@ -49,6 +51,8 @@ const props = [
     'isArray',
     'commentPropName',
     'unpairedTags',
+    'processEntities',
+    'htmlEntities'
 ];
   
 const util = require('../util');

package/src/xmlparser/OrderedObjParser.js

@@ -2,6 +2,7 @@
 
 const util = require('../util');
 const xmlNode = require('./xmlNode');
+const readDocType = require("./DocTypeReader");
 const toNumber = require("strnum");
 
 const regx =
@@ -11,43 +12,75 @@ const regx =
 //const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g");
 //const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g");
 
-//polyfill
-if (!Number.parseInt && window.parseInt) {
-  Number.parseInt = window.parseInt;
-}
-if (!Number.parseFloat && window.parseFloat) {
-  Number.parseFloat = window.parseFloat;
-}
+class OrderedObjParser{
+  constructor(options){
+    this.options = options;
+    this.currentNode = null;
+    this.tagsNodeStack = [];
+    this.docTypeEntities = {};
+    this.lastEntities = {
+      "amp" : { regex: /&(amp|#38|#x26);/g, val : "&"},
+      "apos" : { regex: /&(apos|#39|#x27);/g, val : "'"},
+      "gt" : { regex: /&(gt|#62|#x3E);/g, val : ">"},
+      "lt" : { regex: /&(lt|#60|#x3C);/g, val : "<"},
+      "quot" : { regex: /&(quot|#34|#x22);/g, val : "\""},
+    };
+    this.htmlEntities = {
+      "space": { regex: /&(nbsp|#160);/g, val: " " },
+      // "lt" : { regex: /&(lt|#60);/g, val: "<" },
+      // "gt" : { regex: /&(gt|#62);/g, val: ">" },
+      // "amp" : { regex: /&(amp|#38);/g, val: "&" },
+      // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
+      // "apos" : { regex: /&(apos|#39);/g, val: "'" },
+      "cent" : { regex: /&(cent|#162);/g, val: "¢" },
+      "pound" : { regex: /&(pound|#163);/g, val: "£" },
+      "yen" : { regex: /&(yen|#165);/g, val: "¥" },
+      "euro" : { regex: /&(euro|#8364);/g, val: "€" },
+      "copyright" : { regex: /&(copy|#169);/g, val: "©" },
+      "reg" : { regex: /&(reg|#174);/g, val: "®" },
+      "inr" : { regex: /&(inr|#8377);/g, val: "₹" },
+    };
+    this.parseXml = parseXml;
+    this.parseTextData = parseTextData;
+    this.resolveNameSpace = resolveNameSpace;
+    this.buildAttributesMap = buildAttributesMap;
+    this.isItStopNode = isItStopNode;
+    this.replaceEntitiesValue = replaceEntitiesValue;
+    this.readTagExp = readTagExp;
+    this.readStopNodeData = readStopNodeData;
+  }
 
+}
 
 /**
  * @param {string} val
- * @param {object} options
  * @param {string} tagName
  * @param {string} jPath
  * @param {boolean} dontTrim
  * @param {boolean} hasAttributes
  * @param {boolean} isLeafNode
  */
-function parseValue(val, options, tagName, jPath, dontTrim, hasAttributes, isLeafNode) {
+function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode) {
   if (val !== undefined) {
-    if (options.trimValues && !dontTrim) {
+    if (this.options.trimValues && !dontTrim) {
       val = val.trim();
     }
     if(val.length > 0){
-      const newval = options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
+      val = this.replaceEntitiesValue(val);
+      
+      const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
       if(newval === null || newval === undefined){
         //don't parse
         return val;
       }else if(typeof newval !== typeof val || newval !== val){
         //overwrite
         return newval;
-      }else if(options.trimValues){
-        return _parseValue(val, options.parseTagValue, options.numberParseOptions);
+      }else if(this.options.trimValues){
+        return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
       }else{
         const trimmedVal = val.trim();
         if(trimmedVal === val){
-          return _parseValue(val, options.parseTagValue, options.numberParseOptions);
+          return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
         }else{
           return val;
         }
@@ -56,8 +89,8 @@ function parseValue(val, options, tagName, jPath, dontTrim, hasAttributes, isLea
   }
 }
 
-function resolveNameSpace(tagname, options) {
-  if (options.removeNSPrefix) {
+function resolveNameSpace(tagname) {
+  if (this.options.removeNSPrefix) {
     const tags = tagname.split(':');
     const prefix = tagname.charAt(0) === '/' ? '/' : '';
     if (tags[0] === 'xmlns') {
@@ -70,28 +103,12 @@ function resolveNameSpace(tagname, options) {
   return tagname;
 }
 
-function _parseValue(val, shouldParse, options) {
-  if (shouldParse && typeof val === 'string') {
-    //console.log(options)
-    const newval = val.trim();
-    if(newval === 'true' ) return true;
-    else if(newval === 'false' ) return false;
-    else return toNumber(val, options);
-  } else {
-    if (util.isExist(val)) {
-      return val;
-    } else {
-      return '';
-    }
-  }
-}
-
 //TODO: change regex to capture NS
 //const attrsRegx = new RegExp("([\\w\\-\\.\\:]+)\\s*=\\s*(['\"])((.|\n)*?)\\2","gm");
 const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
 
-function buildAttributesMap(attrStr, jPath, options) {
-  if (!options.ignoreAttributes && typeof attrStr === 'string') {
+function buildAttributesMap(attrStr, jPath) {
+  if (!this.options.ignoreAttributes && typeof attrStr === 'string') {
     // attrStr = attrStr.replace(/\r?\n/g, ' ');
     //attrStr = attrStr || attrStr.trim();
 
@@ -99,16 +116,16 @@ function buildAttributesMap(attrStr, jPath, options) {
     const len = matches.length; //don't make it inline
     const attrs = {};
     for (let i = 0; i < len; i++) {
-      const attrName = resolveNameSpace(matches[i][1], options);
+      const attrName = this.resolveNameSpace(matches[i][1]);
       let oldVal = matches[i][4];
-      const aName = options.attributeNamePrefix + attrName;
+      const aName = this.options.attributeNamePrefix + attrName;
       if (attrName.length) {
         if (oldVal !== undefined) {
-          if (options.trimValues) {
+          if (this.options.trimValues) {
             oldVal = oldVal.trim();
           }
-          
-          const newVal = options.attributeValueProcessor(attrName, oldVal, jPath);
+          oldVal = this.replaceEntitiesValue(oldVal);
+          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
           if(newVal === null || newVal === undefined){
             //don't parse
             attrs[aName] = oldVal;
@@ -117,13 +134,13 @@ function buildAttributesMap(attrStr, jPath, options) {
             attrs[aName] = newVal;
           }else{
             //parse
-            attrs[aName] = _parseValue(
+            attrs[aName] = parseValue(
               oldVal,
-              options.parseAttributeValue,
-              options.numberParseOptions
+              this.options.parseAttributeValue,
+              this.options.numberParseOptions
             );
           }
-        } else if (options.allowBooleanAttributes) {
+        } else if (this.options.allowBooleanAttributes) {
           attrs[aName] = true;
         }
       }
@@ -131,23 +148,21 @@ function buildAttributesMap(attrStr, jPath, options) {
     if (!Object.keys(attrs).length) {
       return;
     }
-    if (options.attributesGroupName) {
+    if (this.options.attributesGroupName) {
       const attrCollection = {};
-      attrCollection[options.attributesGroupName] = attrs;
+      attrCollection[this.options.attributesGroupName] = attrs;
       return attrCollection;
     }
     return attrs;
   }
 }
 
-const parseToOrderedJsObj = function(xmlData, options) {
+const parseXml = function(xmlData) {
   xmlData = xmlData.replace(/\r\n?/g, "\n"); //TODO: remove this line
   const xmlObj = new xmlNode('!xml');
   let currentNode = xmlObj;
   let textData = "";
-  const tagsNodeStack = [];
   let jPath = "";
-
   for(let i=0; i< xmlData.length; i++){//for each char in XML data
     const ch = xmlData[i];
     if(ch === '<'){
@@ -157,128 +172,102 @@ const parseToOrderedJsObj = function(xmlData, options) {
         const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.")
         let tagName = xmlData.substring(i+2,closeIndex).trim();
 
-        if(options.removeNSPrefix){
+        if(this.options.removeNSPrefix){
           const colonIndex = tagName.indexOf(":");
           if(colonIndex !== -1){
             tagName = tagName.substr(colonIndex+1);
           }
         }
-        
+
         if(currentNode){
-          textData = parseValue(textData
-            , options
+          textData = this.parseTextData(textData
             , currentNode.tagname
             , jPath
             ,false
             , currentNode.attributes ? Object.keys(currentNode.attributes).length !== 0 : false
             , Object.keys(currentNode.child).length === 0);
-          if(textData !== undefined &&  textData !== "") currentNode.add(options.textNodeName, textData);
+          if(textData !== undefined &&  textData !== "") currentNode.add(this.options.textNodeName, textData);
           textData = "";
         }
 
-        if (isItStopNode(options.stopNodes, tagsNodeStack, currentNode.tagname)) { //TODO: namespace
-          const top = tagsNodeStack[tagsNodeStack.length - 1];
-          const stopNode = top.child[ top.child.length -1 ];
-          stopNode[currentNode.tagname] = [ { [options.textNodeName] :xmlData.substr(currentNode.startIndex + 1, i - currentNode.startIndex - 1) }];
-        }
-        
         jPath = jPath.substr(0, jPath.lastIndexOf("."));
         
-        currentNode = tagsNodeStack.pop();//avoid recurssion, set the parent tag scope
+        currentNode = this.tagsNodeStack.pop();//avoid recurssion, set the parent tag scope
         textData = "";
         i = closeIndex;
       } else if( xmlData[i+1] === '?') {
         i = findClosingIndex(xmlData, "?>", i, "Pi Tag is not closed.")
       } else if(xmlData.substr(i + 1, 3) === '!--') {
         const endIndex = findClosingIndex(xmlData, "-->", i, "Comment is not closed.")
-        if(options.commentPropName){
+        if(this.options.commentPropName){
           const comment = xmlData.substring(i + 4, endIndex - 2);
 
           //TODO: remove repeated code
           if(textData){ //store previously collected data as textNode
-            textData = parseValue(textData
-              , options
+            textData = this.parseTextData(textData
               , currentNode.tagname
               , jPath
               ,false
               , currentNode.attributes ? Object.keys(currentNode.attributes).length !== 0 : false
               , Object.keys(currentNode.child).length === 0);
   
-            if(textData !== undefined &&  textData !== "") currentNode.add(options.textNodeName, textData);
+            if(textData !== undefined &&  textData !== "") currentNode.add(this.options.textNodeName, textData);
             textData = "";
           }
-          currentNode.add(options.commentPropName, [ { [options.textNodeName] : comment } ]);
+          currentNode.add(this.options.commentPropName, [ { [this.options.textNodeName] : comment } ]);
         }
         i = endIndex;
       } else if( xmlData.substr(i + 1, 2) === '!D') {
-        const closeIndex = findClosingIndex(xmlData, ">", i, "DOCTYPE is not closed.")
-        const tagExp = xmlData.substring(i, closeIndex);
-        if(tagExp.indexOf("[") >= 0){
-          i = xmlData.indexOf("]>", i) + 1;
-        }else{
-          i = closeIndex;
-        }
+        const result = readDocType(xmlData, i);
+        this.docTypeEntities = result.entities;
+        i = result.i;
       }else if(xmlData.substr(i + 1, 2) === '![') {
         const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
         const tagExp = xmlData.substring(i + 9,closeIndex);
 
         if(textData){ //store previously collected data as textNode
-          textData = parseValue(textData
-            , options
+          textData = this.parseTextData(textData
             , currentNode.tagname
             , jPath
             ,false
             , currentNode.attributes ? Object.keys(currentNode.attributes).length !== 0 : false
             , Object.keys(currentNode.child).length === 0);
 
-          if(textData !== undefined &&  textData !== "") currentNode.add(options.textNodeName, textData);
+          if(textData !== undefined &&  textData !== "") currentNode.add(this.options.textNodeName, textData);
           textData = "";
         }
 
         //cdata should be set even if it is 0 length string
-        if(options.cdataPropName){
-          let val = parseValue(tagExp, options, options.cdataPropName, jPath + "." + options.cdataPropName, true, false, true);
-          if(!val) val = "";
-          currentNode.add(options.cdataPropName, [ { [options.textNodeName] : val } ]);
+        if(this.options.cdataPropName){
+          // let val = this.parseTextData(tagExp, this.options.cdataPropName, jPath + "." + this.options.cdataPropName, true, false, true);
+          // if(!val) val = "";
+          currentNode.add(this.options.cdataPropName, [ { [this.options.textNodeName] : tagExp } ]);
         }else{
-          let val = parseValue(tagExp, options, currentNode.tagname, jPath, true, false, true);
+          let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true);
           if(!val) val = "";
-          currentNode.add(options.textNodeName, val);
+          currentNode.add(this.options.textNodeName, val);
         }
         
         i = closeIndex + 2;
       }else {//Opening tag
-        const result = tagExpWithClosingIndex(xmlData, i+1)
-        let tagExp = result.data;
-        const closeIndex = result.index;
-        const separatorIndex = tagExp.search(/\s/);
-        let tagName = tagExp;
-        let shouldBuildAttributesMap = true;
-        if(separatorIndex !== -1){//separate tag name and attributes expression
-          tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, '');
-          tagExp = tagExp.substr(separatorIndex + 1);
-        }
-
-        if(options.removeNSPrefix){
-          const colonIndex = tagName.indexOf(":");
-          if(colonIndex !== -1){
-            tagName = tagName.substr(colonIndex+1);
-            shouldBuildAttributesMap = tagName !== result.data.substr(colonIndex + 1);
-          }
-        }
+       
+        let result = this.readTagExp(xmlData,i);
+        let tagName= result.tagName;
+        let tagExp = result.tagExp;
+        let attrExpPresent = result.attrExpPresent;
+        let closeIndex = result.closeIndex;
         
         //save text as child node
         if (currentNode && textData) {
           if(currentNode.tagname !== '!xml'){
             //when nested tag is found
-            textData = parseValue(textData
-              , options
+            textData = this.parseTextData(textData
               , currentNode.tagname
               , jPath
               , false
               , currentNode.attributes ? Object.keys(currentNode.attributes).length !== 0 : false
               , false);
-            if(textData !== undefined &&  textData !== "") currentNode.add(options.textNodeName, textData);
+            if(textData !== undefined &&  textData !== "") currentNode.add(this.options.textNodeName, textData);
             textData = "";
           }
         }
@@ -287,52 +276,67 @@ const parseToOrderedJsObj = function(xmlData, options) {
           jPath += jPath ? "." + tagName : tagName;
         }
 
-  //selfClosing tag
-        if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){
-          
-          if(tagName[tagName.length - 1] === "/"){ //remove trailing '/'
-            tagName = tagName.substr(0, tagName.length - 1);
-            tagExp = tagName;
-          }else{
-            tagExp = tagExp.substr(0, tagExp.length - 1);
+        //check if last tag was unpaired tag
+        const lastTag = currentNode;
+        if(lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1 ){
+          currentNode = this.tagsNodeStack.pop();
+        }
+
+        if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) { //TODO: namespace
+          let tagContent = "";
+          //self-closing tag
+          if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){}
+          //boolean tag
+          else if(this.options.unpairedTags.indexOf(tagName) !== -1){}
+          //normal tag
+          else{
+            //read until closing tag is found
+            const result = this.readStopNodeData(xmlData, tagName, closeIndex + 1);
+            if(!result) throw new Error(`Unexpected end of ${tagName}`);
+            i = result.i;
+            tagContent = result.tagContent;
           }
 
           const childNode = new xmlNode(tagName);
-          if(tagName !== tagExp && shouldBuildAttributesMap){
-            childNode.attributes = buildAttributesMap(tagExp, jPath , options);
+          if(tagName !== tagExp && attrExpPresent){
+            childNode.attributes = this.buildAttributesMap(tagExp, jPath);
           }
           jPath = jPath.substr(0, jPath.lastIndexOf("."));
-          // tagsNodeStack.push(currentNode);
+          childNode.add(this.options.textNodeName, tagContent);
+          
           currentNode.addChild(childNode);
-        }
-  //boolean tags
-        else if(options.unpairedTags.indexOf(tagName) !== -1){
-            // tagExp = tagExp.substr(0, tagExp.length - 1);
+        }else{
+  //selfClosing tag
+          if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){
+            
+            if(tagName[tagName.length - 1] === "/"){ //remove trailing '/'
+              tagName = tagName.substr(0, tagName.length - 1);
+              tagExp = tagName;
+            }else{
+              tagExp = tagExp.substr(0, tagExp.length - 1);
+            }
 
-          const childNode = new xmlNode(tagName);
-          if(tagName !== tagExp && shouldBuildAttributesMap){
-            childNode.attributes = buildAttributesMap(tagExp, jPath , options);
+            const childNode = new xmlNode(tagName);
+            if(tagName !== tagExp && attrExpPresent){
+              childNode.attributes = this.buildAttributesMap(tagExp, jPath);
+            }
+            jPath = jPath.substr(0, jPath.lastIndexOf("."));
+            currentNode.addChild(childNode);
           }
-          jPath = jPath.substr(0, jPath.lastIndexOf("."));
-          // tagsNodeStack.push(currentNode);
-          currentNode.addChild(childNode);
-        }
-  //opening tag
-        else{
-          
-          const childNode = new xmlNode( tagName);
-          tagsNodeStack.push(currentNode);
-          
-          childNode.startIndex=closeIndex; //for further processing
-          
-          if(tagName !== tagExp && shouldBuildAttributesMap){
-            childNode.attributes = buildAttributesMap(tagExp, jPath, options);
+    //opening tag
+          else{
+            const childNode = new xmlNode( tagName);
+            this.tagsNodeStack.push(currentNode);
+            
+            if(tagName !== tagExp && attrExpPresent){
+              childNode.attributes = this.buildAttributesMap(tagExp, jPath);
+            }
+            currentNode.addChild(childNode);
+            currentNode = childNode;
           }
-          currentNode.addChild(childNode);
-          currentNode = childNode;
+          textData = "";
+          i = closeIndex;
         }
-        textData = "";
-        i = closeIndex;
       }
     }else{
       textData += xmlData[i];
@@ -341,31 +345,39 @@ const parseToOrderedJsObj = function(xmlData, options) {
   return xmlObj.child;
 }
 
+const replaceEntitiesValue = function(val){
+  if(this.options.processEntities){
+    for(let entityName in this.docTypeEntities){
+      const entity = this.docTypeEntities[entityName];
+      val = val.replace( entity.regx, entity.val);
+    }
+    for(let entityName in this.lastEntities){
+      const entity = this.lastEntities[entityName];
+      val = val.replace( entity.regex, entity.val);
+    }
+    if(this.options.htmlEntities){
+      for(let entityName in this.htmlEntities){
+        const entity = this.htmlEntities[entityName];
+        val = val.replace( entity.regex, entity.val);
+      }
+    }
+  }
+  return val;
+}
 //TODO: use jPath to simplify the logic
 /**
  * 
  * @param {string[]} stopNodes 
- * @param {XmlNode[]} tagsNodeStack 
+ * @param {string} jPath
+ * @param {string} currentTagName 
  */
-function isItStopNode(stopNodes, tagsNodeStack, currentTagName){
-  const matchingStopNodes = [];
-  //filter the list of stopNodes as per current tag
-  stopNodes.forEach( jPath => {
-    if( jPath.substr( jPath.length - currentTagName.length) === currentTagName) matchingStopNodes.push(jPath);
-  });
-
-  if(matchingStopNodes.length > 0){
-    let jPath = "";
-    for (let i = 1; i < tagsNodeStack.length; i++) {
-      const node = tagsNodeStack[i];
-      jPath += "." + node.tagname;
-    }
-    jPath += "." + currentTagName;
-    jPath = jPath.substr(1);
-    for (let i = 0; i < matchingStopNodes.length; i++) {
-      if(matchingStopNodes[i] === jPath) return true;
-    }
-  }else return false;
+function isItStopNode(stopNodes, jPath, currentTagName){
+  const allNodesExp = "*." + currentTagName;
+  for (const stopNodePath in stopNodes) {
+    const stopNodeExp = stopNodes[stopNodePath];
+    if( allNodesExp === stopNodeExp || jPath === stopNodeExp  ) return true;
+  }
+  return false;
 }
 
 /**
@@ -404,4 +416,71 @@ function findClosingIndex(xmlData, str, i, errMsg){
   }
 }
 
-exports.parseToOrderedJsObj = parseToOrderedJsObj;
+function readTagExp(xmlData,i){
+  const result = tagExpWithClosingIndex(xmlData, i+1);
+  let tagExp = result.data;
+  const closeIndex = result.index;
+  const separatorIndex = tagExp.search(/\s/);
+  let tagName = tagExp;
+  let attrExpPresent = true;
+  if(separatorIndex !== -1){//separate tag name and attributes expression
+    tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, '');
+    tagExp = tagExp.substr(separatorIndex + 1);
+  }
+
+  if(this. options.removeNSPrefix){
+    const colonIndex = tagName.indexOf(":");
+    if(colonIndex !== -1){
+      tagName = tagName.substr(colonIndex+1);
+      attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
+    }
+  }
+
+  return {
+    tagName: tagName,
+    tagExp: tagExp,
+    closeIndex: closeIndex,
+    attrExpPresent: attrExpPresent,
+  }
+}
+/**
+ * find paired tag for a stop node
+ * @param {string} xmlData 
+ * @param {string} tagName 
+ * @param {number} i 
+ */
+function readStopNodeData(xmlData, tagName, i){
+  const startIndex = i;
+  for (; i < xmlData.length; i++) {
+    if( xmlData[i] === "<" && xmlData[i+1] === "/"){ 
+        const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
+        let closeTagName = xmlData.substring(i+2,closeIndex).trim();
+        if(closeTagName === tagName){
+          return {
+            tagContent: xmlData.substring(startIndex, i),
+            i : closeIndex
+          }
+        }
+        i=closeIndex;
+      }
+  }//end for loop
+}
+
+function parseValue(val, shouldParse, options) {
+  if (shouldParse && typeof val === 'string') {
+    //console.log(options)
+    const newval = val.trim();
+    if(newval === 'true' ) return true;
+    else if(newval === 'false' ) return false;
+    else return toNumber(val, options);
+  } else {
+    if (util.isExist(val)) {
+      return val;
+    } else {
+      return '';
+    }
+  }
+}
+
+
+module.exports = OrderedObjParser;

package/src/xmlparser/XMLParser.js

@@ -1,5 +1,5 @@
 const { buildOptions} = require("./OptionsBuilder");
-const { parseToOrderedJsObj} = require("./OrderedObjParser");
+const OrderedObjParser = require("./OrderedObjParser");
 const { prettify} = require("./node2json");
 const validator = require('../validator');
 
@@ -27,7 +27,8 @@ class XMLParser{
               throw Error( `${result.err.msg}:${result.err.line}:${result.err.col}` )
             }
           }
-        const orderedResult = parseToOrderedJsObj(xmlData, this.options);
+        const orderedObjParser = new OrderedObjParser(this.options);
+        const orderedResult = orderedObjParser.parseXml(xmlData);
         if(this.options.preserveOrder || orderedResult === undefined) return orderedResult;
         else return prettify(orderedResult, this.options);
     }