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

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 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.6 / 2021-12-05**
+* Support PI Tags processing
+* Support `suppressBooleanAttributes` by XML Builder for attributes with value `true`.
+
+** 4.0.0-beta.5 / 2021-12-04**
+* fix: when a tag with name "attributes"
+
+** 4.0.0-beta.4 / 2021-12-02**
+* Support HTML document parsing
+* skip stop nodes parsing when building the XML from JS object
+* Support external entites without DOCTYPE
+* update dev dependency: strnum v1.0.5 to fix long number issue
+
+** 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

@@ -29,6 +29,7 @@ Check [ThankYouBackers](https://github.com/NaturalIntelligence/ThankYouBackers)
 <a href="http://nasa.github.io/" title="NASA" > <img src="https://avatars0.githubusercontent.com/u/848102" width="60px" ></a>
 <a href="https://github.com/prettier" title="Prettier" > <img src="https://avatars0.githubusercontent.com/u/25822731" width="60px" ></a>
 <a href="http://brain.js.org/" title="brain.js" > <img src="https://avatars2.githubusercontent.com/u/23732838" width="60px" ></a>
+<a href="https://github.com/aws" title="AWS SDK" > <img src="https://avatars.githubusercontent.com/u/2232217" width="60px" ></a>
 <a href="#" title="NHS Connect" > <img src="https://avatars3.githubusercontent.com/u/20316669" width="60px" ></a>
 <a href="http://www.fda.gov/" title="Food and Drug Administration " > <img src="https://avatars2.githubusercontent.com/u/6471964" width="60px" ></a>
 <a href="http://www.magento.com/" title="Magento" > <img src="https://avatars2.githubusercontent.com/u/168457" width="60px" ></a>
@@ -48,6 +49,14 @@ 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.
+* Supports parsing of PI (Processing Instruction) tags with XML declaration tags
+* And many more other features.
 
 ## How to use
 
@@ -98,7 +107,9 @@ 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)
+6.  [HTML Document Parsing](./docs/6.HTMLParsing.md)
+7. [PI Tag processing](./docs/7.PITags.md)
 ## Performance
 
 ### XML Parser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-xml-parser",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.0-beta.6",
   "description": "Validate XML, Parse XML, Build XML without C/C++ based libraries",
   "main": "./src/fxp.js",
   "scripts": {
@@ -47,14 +47,14 @@
     "@babel/preset-env": "^7.13.10",
     "@babel/register": "^7.13.8",
     "babel-loader": "^8.2.2",
-    "eslint": "^5.16.0",
+    "eslint": "^8.3.0",
     "he": "^1.2.0",
     "jasmine": "^3.6.4",
     "nyc": "^15.1.0",
     "prettier": "^1.19.1",
     "publish-please": "^5.5.2",
-    "webpack": "^4.46.0",
-    "webpack-cli": "^3.3.12"
+    "webpack": "^5.64.4",
+    "webpack-cli": "^4.9.1"
   },
   "typings": "src/fxp.d.ts",
   "funding": {
@@ -62,6 +62,6 @@
     "url": "https://paypal.me/naturalintelligence"
   },
   "dependencies": {
-    "strnum": "^1.0.4"
+    "strnum": "^1.0.5"
   }
 }

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;
@@ -42,10 +44,13 @@ type XmlBuilderOptions = {
   indentBy: string;
   arrayNodeName: string;
   suppressEmptyNode: boolean;
+  suppressBooleanAttributes: boolean;
   preserveOrder: boolean;
   unpairedTags: string[];
+  stopNodes: string[];
   tagValueProcessor: (name: string, value: string) => string;
   attributeValueProcessor: (name: string, value: string) => string;
+  processEntities: boolean;
 };
 type XmlBuilderOptionsOptional = Partial<XmlBuilderOptions>;
 
@@ -63,6 +68,12 @@ type ValidationError = {
 export class XMLParser {
   constructor(options?: X2jOptionsOptional);
   parse(xmlData: string | Buffer ,validationOptions?: validationOptionsOptional | boolean): any;
+  /**
+   * Add Entity which is not by default supported by this library
+   * @param entityIndentifier {string} Eg: 'ent' for &ent;
+   * @param entityValue {string} Eg: '\r'
+   */
+  addEntity(entityIndentifier: string, entityValue: string): void;
 }
 
 export class XMLValidator{
@@ -70,5 +81,5 @@ export class XMLValidator{
 }
 export class XMLBuilder {
   constructor(options: XmlBuilderOptionsOptional);
-  parse(options: any): any;
+  build(jObj: any): any;
 }

package/src/xmlbuilder/json2xml.js

@@ -12,6 +12,7 @@ const defaultOptions = {
   format: false,
   indentBy: '  ',
   suppressEmptyNode: false,
+  suppressBooleanAttributes: true,
   tagValueProcessor: function(key, a) {
     return a;
   },
@@ -21,6 +22,14 @@ 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,
+  stopNodes: []
 };
 
 const props = [
@@ -32,12 +41,16 @@ const props = [
   'format',
   'indentBy',
   'suppressEmptyNode',
+  'suppressBooleanAttributes',
   'tagValueProcessor',
   'attributeValueProcessor',
   'arrayNodeName', //when array as root
   'preserveOrder',
   "commentPropName",
   "unpairedTags",
+  "entities",
+  "processEntities",
+  "stopNodes",
   // 'rootNodeName', //when jsObject have multiple properties on root level
 ];
 
@@ -76,6 +89,8 @@ function Builder(options) {
 
   this.buildTextValNode = buildTextValNode;
   this.buildObjectNode = buildObjectNode;
+
+  this.replaceEntitiesValue = replaceEntitiesValue;
 }
 
 Builder.prototype.build = function(jObj) {
@@ -105,11 +120,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 +153,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 +216,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

@@ -7,10 +7,10 @@ const {EOL} = require('os');
  * @returns 
  */
 function toXml(jArray, options){
-    return arrToStr( jArray, options, 0);
+    return arrToStr( jArray, options, "", 0);
 }
 
-function arrToStr(arr, options, level){
+function arrToStr(arr, options, jPath, level){
     let xmlStr = "";
 
     let indentation = "";
@@ -21,9 +21,17 @@ function arrToStr(arr, options, level){
     for (let i = 0; i < arr.length; i++) {
         const tagObj = arr[i];
         const tagName = propName(tagObj);
+        let newJPath = "";
+        if(jPath.length === 0) newJPath = tagName
+        else newJPath = `${jPath}.${tagName}`;
 
         if(tagName === options.textNodeName){
-            xmlStr += indentation + options.tagValueProcessor( tagName, tagObj[tagName]);
+            let tagText = tagObj[tagName];
+            if(!isStopNode(newJPath, options)){
+                tagText = options.tagValueProcessor( tagName, tagText);
+                tagText = replaceEntitiesValue(tagText, options);
+            }
+            xmlStr += indentation + tagText;
             continue;
         }else if( tagName === options.cdataPropName){
             xmlStr += indentation + `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
@@ -31,10 +39,14 @@ function arrToStr(arr, options, level){
         }else if( tagName === options.commentPropName){
             xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
             continue;
+        }else if( tagName[0] === "?"){
+            const attStr = attr_to_str(tagObj[":@"], options);
+            xmlStr += indentation + `<${tagName} ${tagObj[tagName][0][options.textNodeName]} ${attStr}?>`;
+            continue;
         }
-        const attStr = attr_to_str(tagObj.attributes, options);
+        const attStr = attr_to_str(tagObj[":@"], options);
         let tagStart =  indentation + `<${tagName}${attStr}`;
-        let tagValue = arrToStr(tagObj[tagName], options, level + 1);
+        let tagValue = arrToStr(tagObj[tagName], options, newJPath, level + 1);
         if( (!tagValue || tagValue.length === 0) && options.suppressEmptyNode){ 
             if(options.unpairedTags.indexOf(tagName) !== -1){
                 xmlStr += tagStart + ">"; 
@@ -54,7 +66,7 @@ function propName(obj){
     const keys = Object.keys(obj);
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
-      if(key !== "attributes") return key;
+      if(key !== ":@") return key;
     }
   }
 
@@ -62,10 +74,34 @@ 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);
+            if(attrVal === true && options.suppressBooleanAttributes){
+                attrStr+= ` ${attr.substr(options.attributeNamePrefix.length)}`;
+            }else{
+                attrStr+= ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
+            }
         }
     }
     return attrStr;
 }
 
+function isStopNode(jPath, options){
+    jPath = jPath.substr(0,jPath.length - options.textNodeName.length - 1);
+    let tagName = jPath.substr(jPath.lastIndexOf(".") + 1);
+    for(let index in options.stopNodes){
+        if(options.stopNodes[index] === jPath || options.stopNodes[index] === "*."+tagName) return true;
+    }
+    return false;
+}
+
+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

@@ -1,7 +1,9 @@
 'use strict';
+///@ts-check
 
 const util = require('../util');
 const xmlNode = require('./xmlNode');
+const readDocType = require("./DocTypeReader");
 const toNumber = require("strnum");
 
 const regx =
@@ -11,43 +13,86 @@ 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.addExternalEntities = addExternalEntities;
+    this.parseXml = parseXml;
+    this.parseTextData = parseTextData;
+    this.resolveNameSpace = resolveNameSpace;
+    this.buildAttributesMap = buildAttributesMap;
+    this.isItStopNode = isItStopNode;
+    this.replaceEntitiesValue = replaceEntitiesValue;
+    this.readStopNodeData = readStopNodeData;
+  }
+
 }
 
+function addExternalEntities(externalEntities){
+  const entKeys = Object.keys(externalEntities);
+  for (let i = 0; i < entKeys.length; i++) {
+    const ent = entKeys[i];
+    this.lastEntities[ent] = {
+       regex: new RegExp("&"+ent+";","g"),
+       val : externalEntities[ent]
+    }
+  }
+}
 
 /**
  * @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 +101,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 +115,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 +128,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 +146,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 +160,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 +184,131 @@ 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
+            , currentNode[":@"] ? Object.keys(currentNode[":@"]).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.")
+        let result = readTagExp(xmlData,i, false, "?>");
+        if(!result) throw new Error("Pi Tag is not closed.");
+        
+        let tagName= result.tagName;
+        let tagExp = result.tagExp;
+        let attrExpPresent = result.attrExpPresent;
+        let closeIndex = result.closeIndex;
+
+          //TODO: remove repeated code
+          if(textData){ //store previously collected data as textNode
+            textData = this.parseTextData(textData
+              , currentNode.tagname
+              , jPath
+              ,false
+              , currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false
+              , Object.keys(currentNode.child).length === 0);
+
+            if(textData !== undefined &&  textData !== "") currentNode.add(this.options.textNodeName, textData);
+            textData = "";
+          }
+
+          const childNode = new xmlNode(tagName);
+          childNode.add(this.options.textNodeName, "");
+          
+          if(tagName !== tagExp && attrExpPresent){
+            childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+          }
+          currentNode.addChild(childNode);
+
+        i = closeIndex + 1;
       } 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
+              , currentNode[":@"] ? Object.keys(currentNode[":@"]).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
+            , currentNode[":@"] ? Object.keys(currentNode[":@"]).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 = readTagExp(xmlData,i, this. options.removeNSPrefix);
+        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
+              , currentNode[":@"] ? Object.keys(currentNode[":@"]).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 +317,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[":@"] = 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[":@"] = 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[":@"] = 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 +386,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;
 }
 
 /**
@@ -374,7 +427,7 @@ function isItStopNode(stopNodes, tagsNodeStack, currentTagName){
  * @param {number} i starting index
  * @returns 
  */
-function tagExpWithClosingIndex(xmlData, i){
+function tagExpWithClosingIndex(xmlData, i, closingChar = ">"){
   let attrBoundary;
   let tagExp = "";
   for (let index = i; index < xmlData.length; index++) {
@@ -383,11 +436,20 @@ function tagExpWithClosingIndex(xmlData, i){
         if (ch === attrBoundary) attrBoundary = "";//reset
     } else if (ch === '"' || ch === "'") {
         attrBoundary = ch;
-    } else if (ch === '>') {
+    } else if (ch === closingChar[0]) {
+      if(closingChar[1]){
+        if(xmlData[index + 1] === closingChar[1]){
+          return {
+            data: tagExp,
+            index: index
+          }
+        }
+      }else{
         return {
           data: tagExp,
           index: index
         }
+      }
     } else if (ch === '\t') {
       ch = " "
     }
@@ -404,4 +466,72 @@ function findClosingIndex(xmlData, str, i, errMsg){
   }
 }
 
-exports.parseToOrderedJsObj = parseToOrderedJsObj;
+function readTagExp(xmlData,i, removeNSPrefix, closingChar = ">"){
+  const result = tagExpWithClosingIndex(xmlData, i+1, closingChar);
+  if(!result) return;
+  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(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,11 +1,14 @@
 const { buildOptions} = require("./OptionsBuilder");
-const { parseToOrderedJsObj} = require("./OrderedObjParser");
+const OrderedObjParser = require("./OrderedObjParser");
 const { prettify} = require("./node2json");
 const validator = require('../validator');
 
 class XMLParser{
+    
     constructor(options){
+        this.externalEntities = {};
         this.options = buildOptions(options);
+        
     }
     /**
      * Parse XML dats to JS object 
@@ -27,10 +30,27 @@ 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);
+        orderedObjParser.addExternalEntities(this.externalEntities);
+        const orderedResult = orderedObjParser.parseXml(xmlData);
         if(this.options.preserveOrder || orderedResult === undefined) return orderedResult;
         else return prettify(orderedResult, this.options);
     }
+
+    /**
+     * Add Entity which is not by default supported by this library
+     * @param {string} key 
+     * @param {string} value 
+     */
+    addEntity(key, value){
+        if(value.indexOf("&") !== -1){
+            throw new Error("Entity value can't have '&'")
+        }else if(key.indexOf("&") !== -1 || key.indexOf(";") !== -1){
+            throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '
'")
+        }else{
+            this.externalEntities[key] = value;
+        }
+    }
 }
 
 module.exports = XMLParser;

package/src/xmlparser/node2json.js

@@ -37,8 +37,8 @@ function compress(arr, options, jPath){
       let val = compress(tagObj[property], options, newJpath);
       const isLeaf = isLeafTag(val, options);
 
-      if(tagObj.attributes){
-        assignAttributes( val, tagObj.attributes, newJpath, options);
+      if(tagObj[":@"]){
+        assignAttributes( val, tagObj[":@"], newJpath, options);
       }else if(Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode){
         val = val[options.textNodeName];
       }else if(Object.keys(val).length === 0){
@@ -74,7 +74,7 @@ function propName(obj){
   const keys = Object.keys(obj);
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
-    if(key !== "attributes") return key;
+    if(key !== ":@") return key;
   }
 }
 

package/src/xmlparser/xmlNode.js

@@ -4,15 +4,15 @@ class XmlNode{
   constructor(tagname) {
     this.tagname = tagname;
     this.child = []; //nested tags, text, cdata, comments in order
-    this.attributes = {}; //attributes map
+    this[":@"] = {}; //attributes map
   }
   add(key,val){
     // this.child.push( {name : key, val: val, isCdata: isCdata });
     this.child.push( {[key]: val });
   }
   addChild(node) {
-    if(node.attributes && Object.keys(node.attributes).length > 0){
-      this.child.push( { [node.tagname]: node.child, attributes: node.attributes });
+    if(node[":@"] && Object.keys(node[":@"]).length > 0){
+      this.child.push( { [node.tagname]: node.child, [":@"]: node[":@"] });
     }else{
       this.child.push( { [node.tagname]: node.child });
     }