fast-xml-parser 3.19.0 → 3.21.1

package/README.md

@@ -21,9 +21,10 @@ To cover expenses, we're planning to launch [FXP Enterprise](https://github.com/
 <a href="https://opencollective.com/fast-xml-parser/donate" target="_blank">
   <img src="https://opencollective.com/fast-xml-parser/donate/button@2x.png?color=blue" width=200 />
 </a>
-<a href="https://www.patreon.com/bePatron?u=9531404" data-patreon-widget-type="become-patron-button"><img src="https://c5.patreon.com/external/logo/become_a_patron_button.png" alt="Become a Patron!" width="200" /></a>
 <a href="https://paypal.me/naturalintelligence"> <img src="static/img/support_paypal.svg" alt="Stubmatic donate button" width="200"/></a>
 
+Check [ThankYouBackers](https://github.com/NaturalIntelligence/ThankYouBackers) for our contributors
+
 ## Users
 List of some applications/projects using Fast XML Parser. (Raise an issue to submit yours)
 
@@ -104,13 +105,19 @@ The list of users is collected either from the list published by Github, cummuni
 
 ## How to use
 
-To use it in **NPM package**  install it first
+### Installation
+
+To use it as an **NPM package**:
+
+`npm install fast-xml-parser`
 
-`$npm install fast-xml-parser` or using [yarn](https://yarnpkg.com/) `$yarn add fast-xml-parser`
+Or using [yarn](https://yarnpkg.com/):
+
+`yarn add fast-xml-parser`
 
 To use it from a **CLI** install it globally with the `-g` option.
 
-`$npm install fast-xml-parser -g`
+`npm install fast-xml-parser -g`
 
 To use it on a **webpage** include it from a [CDN](https://cdnjs.com/libraries/fast-xml-parser)
 
@@ -118,14 +125,14 @@ To use it on a **webpage** include it from a [CDN](https://cdnjs.com/libraries/f
 
 
 ```js
-var jsonObj = parser.parse(xmlData [,options] );
+const jsonObj = parser.parse(xmlData [,options] );
 ```
 
 ```js
-var parser = require('fast-xml-parser');
-var he = require('he');
+const parser = require('fast-xml-parser');
+const he = require('he');
 
-var options = {
+const options = {
     attributeNamePrefix : "@_",
     attrNodeName: "attr", //default is 'false'
     textNodeName : "#text",
@@ -138,26 +145,32 @@ var options = {
     cdataTagName: "__cdata", //default is 'false'
     cdataPositionChar: "\\c",
     parseTrueNumberOnly: false,
+    numParseOptions:{
+      hex: true,
+      leadingZeros: true,
+      //skipLike: /\+[0-9]{10}/
+    },
     arrayMode: false, //"strict"
     attrValueProcessor: (val, attrName) => he.decode(val, {isAttributeValue: true}),//default is a=>a
     tagValueProcessor : (val, tagName) => he.decode(val), //default is a=>a
-    stopNodes: ["parse-me-as-string"]
+    stopNodes: ["parse-me-as-string"],
+    alwaysCreateTextNode: false
 };
 
 if( parser.validate(xmlData) === true) { //optional (it'll return an object in case it's not valid)
-    var jsonObj = parser.parse(xmlData,options);
+    let jsonObj = parser.parse(xmlData,options);
 }
 
 // Intermediate obj
-var tObj = parser.getTraversalObj(xmlData,options);
-var jsonObj = parser.convertToJson(tObj,options);
+const tObj = parser.getTraversalObj(xmlData,options);
+let jsonObj = parser.convertToJson(tObj,options);
 
 ```
 As you can notice in the above code, validator is not embedded with in the parser and expected to be called separately. However, you can pass `true` or validation options as 3rd parameter to the parser to trigger validator internally. It is same as above example.
 
 ```js
 try{
-  var jsonObj = parser.parse(xmlData,options, true);
+  let jsonObj = parser.parse(xmlData,options, true);
 }catch(error){
   console.log(error.message)
 }
@@ -196,7 +209,7 @@ Validator returns the following object in case of error;
 * **tagValueProcessor** : Process tag value during transformation. Like HTML decoding, word capitalization, etc. Applicable in case of string only.
 * **attrValueProcessor** : Process attribute value during transformation. Like HTML decoding, word capitalization, etc. Applicable in case of string only.
 * **stopNodes** : an array of tag names which are not required to be parsed. Instead their values are parsed as string.
-
+* **alwaysCreateTextNode** : When `true`, forces the parser always return a property for the `textNodeName` even if there are no attributes or node children.
 </details>
 
 <details>
@@ -219,18 +232,18 @@ $cat xmlfile.xml | xml2js [-ns|-a|-c|-v|-V] [-o outputfile.json]
 	<summary>To use it <b>on webpage</b></summary>
 
 ```js
-var result = parser.validate(xmlData);
+const result = parser.validate(xmlData);
 if (result !== true) console.log(result.err);
-var jsonObj = parser.parse(xmlData);
+const jsonObj = parser.parse(xmlData);
 ```
 </details>
 
 ### JSON / JS Object to XML
 
 ```js
-var Parser = require("fast-xml-parser").j2xParser;
+const Parser = require("fast-xml-parser").j2xParser;
 //default options need not to set
-var defaultOptions = {
+const defaultOptions = {
     attributeNamePrefix : "@_",
     attrNodeName: "@", //default is false
     textNodeName : "#text",
@@ -241,10 +254,11 @@ var defaultOptions = {
     indentBy: "  ",
     supressEmptyNode: false,
     tagValueProcessor: a=> he.encode(a, { useNamedReferences: true}),// default is a=>a
-    attrValueProcessor: a=> he.encode(a, {isAttributeValue: isAttribute, useNamedReferences: true})// default is a=>a
+    attrValueProcessor: a=> he.encode(a, {isAttributeValue: isAttribute, useNamedReferences: true}),// default is a=>a
+    rootNodeName: "element"
 };
-var parser = new Parser(defaultOptions);
-var xml = parser.parse(json_or_js_obj);
+const parser = new Parser(defaultOptions);
+const xml = parser.parse(json_or_js_obj);
 ```
 
 <details>
@@ -263,6 +277,7 @@ With the correct options, you can get the almost original XML without losing any
 * **supressEmptyNode** : If set to `true`, tags with no value (text or nested tags) are written as self closing tags.
 * **tagValueProcessor** : Process tag value during transformation. Like HTML encoding, word capitalization, etc. Applicable in case of string only.
 * **attrValueProcessor** : Process attribute value during transformation. Like HTML encoding, word capitalization, etc. Applicable in case of string only.
+* **rootNodeName** : When input js object is array, parser uses array index by default as tag name. You can set this property for proper response.
 </details>
 
 ## Benchmark

package/package.json

@@ -1,19 +1,18 @@
 {
   "name": "fast-xml-parser",
-  "version": "3.19.0",
+  "version": "3.21.1",
   "description": "Validate XML or Parse XML to JS/JSON very fast without C/C++ based libraries",
   "main": "./src/parser.js",
   "scripts": {
-    "test": "jasmine spec/*spec.js",
+    "test": "nyc --reporter=lcov --reporter=text jasmine spec/*spec.js",
     "unit": "jasmine",
+    "coverage": "nyc report --reporter html --reporter text -t .nyc_output --report-dir .nyc_output/summary",
     "perf": "node ./benchmark/perfTest3.js",
     "lint": "eslint src/*.js spec/*.js",
     "bundle": "webpack && webpack --config webpack-prod.config.js",
-    "coverage": "istanbul cover -x \"cli.js\" -x \"spec/*spec.js\" jasmine spec/*spec.js;",
-    "coverage:check": "istanbul check-coverage --branch 90 --statement 90",
     "prettier": "prettier --write src/**/*.js",
     "publish-please": "publish-please",
-    "prepublishOnly": "publish-please guard"
+    "checkReadiness": "publish-please --dry-run"
   },
   "bin": {
     "xml2js": "./cli.js"
@@ -76,10 +75,9 @@
     "babel-loader": "^8.2.2",
     "eslint": "^5.16.0",
     "he": "^1.2.0",
-    "http-server": "^0.12.3",
-    "istanbul": "^0.4.5",
     "jasmine": "^3.6.4",
     "nimnjs": "^1.3.2",
+    "nyc": "^15.1.0",
     "prettier": "^1.19.1",
     "publish-please": "^5.5.2",
     "webpack": "^4.46.0",
@@ -89,5 +87,8 @@
   "funding": {
     "type": "paypal",
     "url": "https://paypal.me/naturalintelligence"
+  },
+  "dependencies": {
+    "strnum": "^1.0.4"
   }
 }

package/src/json2xml.js

@@ -32,6 +32,7 @@ const props = [
   'supressEmptyNode',
   'tagValueProcessor',
   'attrValueProcessor',
+  'rootNodeName', //when array as root
 ];
 
 function Parser(options) {
@@ -54,6 +55,8 @@ function Parser(options) {
   this.replaceCDATAstr = replaceCDATAstr;
   this.replaceCDATAarr = replaceCDATAarr;
 
+  this.processTextOrObjNode = processTextOrObjNode
+
   if (this.options.format) {
     this.indentate = indentate;
     this.tagEndChar = '>\n';
@@ -79,16 +82,18 @@ function Parser(options) {
 }
 
 Parser.prototype.parse = function(jObj) {
+  if(Array.isArray(jObj) && this.options.rootNodeName && this.options.rootNodeName.length > 1){
+    jObj = {
+      [this.options.rootNodeName] : jObj
+    }
+  }
   return this.j2x(jObj, 0).val;
 };
 
 Parser.prototype.j2x = function(jObj, level) {
   let attrStr = '';
   let val = '';
-  const keys = Object.keys(jObj);
-  const len = keys.length;
-  for (let i = 0; i < len; i++) {
-    const key = keys[i];
+  for (let key in jObj) {
     if (typeof jObj[key] === 'undefined') {
       // supress undefined node
     } else if (jObj[key] === null) {
@@ -137,8 +142,7 @@ Parser.prototype.j2x = function(jObj, level) {
           } else if (item === null) {
             val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
           } else if (typeof item === 'object') {
-            const result = this.j2x(item, level + 1);
-            val += this.buildObjNode(result.val, key, result.attrStr, level);
+            val += this.processTextOrObjNode(item, key, level)
           } else {
             val += this.buildTextNode(item, key, '', level);
           }
@@ -153,14 +157,22 @@ Parser.prototype.j2x = function(jObj, level) {
           attrStr += ' ' + Ks[j] + '="' + this.options.attrValueProcessor('' + jObj[key][Ks[j]]) + '"';
         }
       } else {
-        const result = this.j2x(jObj[key], level + 1);
-        val += this.buildObjNode(result.val, key, result.attrStr, level);
+        val += this.processTextOrObjNode(jObj[key], key, level)
       }
     }
   }
   return {attrStr: attrStr, val: val};
 };
 
+function processTextOrObjNode (object, key, level) {
+  const result = this.j2x(object, level + 1);
+  if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {
+    return this.buildTextNode(result.val, key, result.attrStr, level);
+  } else {
+    return this.buildObjNode(result.val, key, result.attrStr, level);
+  }
+}
+
 function replaceCDATAstr(str, cdata) {
   str = this.options.tagValueProcessor('' + str);
   if (this.options.cdataPositionChar === '' || str === '') {
@@ -183,7 +195,7 @@ function replaceCDATAarr(str, cdata) {
 }
 
 function buildObjectNode(val, key, attrStr, level) {
-  if (attrStr && !val.includes('<')) {
+  if (attrStr && val.indexOf('<') === -1) {
     return (
       this.indentate(level) +
       '<' +

package/src/nimndata.js

@@ -48,7 +48,7 @@ const _e = function(node, e_schema, options) {
         //attributes can't be repeated. hence check in children tags only
         str += chars.arrStart;
         const itemSchema = e_schema[0];
-        //var itemSchemaType = itemSchema;
+        //const itemSchemaType = itemSchema;
         const arr_len = node.length;
 
         if (typeof itemSchema === 'string') {

package/src/node2json.js

@@ -6,7 +6,7 @@ const convertToJson = function(node, options, parentTagName) {
   const jObj = {};
 
   // when no child node or attr is present
-  if ((!node.child || util.isEmptyObject(node.child)) && (!node.attrsMap || util.isEmptyObject(node.attrsMap))) {
+  if (!options.alwaysCreateTextNode && (!node.child || util.isEmptyObject(node.child)) && (!node.attrsMap || util.isEmptyObject(node.attrsMap))) {
     return util.isExist(node.val) ? node.val : '';
   }
 

package/src/node2json_str.js

@@ -19,10 +19,10 @@ const _cToJsonStr = function(node, options, level) {
   const keys = Object.keys(node.child);
 
   for (let index = 0; index < keys.length; index++) {
-    var tagname = keys[index];
+    const tagname = keys[index];
     if (node.child[tagname] && node.child[tagname].length > 1) {
       jObj += '"' + tagname + '" : [ ';
-      for (var tag in node.child[tagname]) {
+      for (let tag in node.child[tagname]) {
         jObj += _cToJsonStr(node.child[tagname][tag], options) + ' , ';
       }
       jObj = jObj.substr(0, jObj.length - 1) + ' ] '; //remove extra comma in last

package/src/parser.d.ts

@@ -12,10 +12,17 @@ type X2jOptions = {
   cdataTagName: false | string;
   cdataPositionChar: string;
   parseTrueNumberOnly: boolean;
+  numParseOptions: strnumOptions;
   tagValueProcessor: (tagValue: string, tagName: string) => string;
   attrValueProcessor: (attrValue: string, attrName: string) => string;
   stopNodes: string[];
+  alwaysCreateTextNode: boolean;
 };
+type strnumOptions = {
+  hex: boolean;
+  leadingZeros: boolean,
+  skipLike?: RegExp
+}
 type X2jOptionsOptional = Partial<X2jOptions>;
 type validationOptions = {
   allowBooleanAttributes: boolean;
@@ -39,7 +46,7 @@ type J2xOptionsOptional = Partial<J2xOptions>;
 type ESchema = string | object | Array<string|object>;
 
 type ValidationError = {
-  err: { code: string; msg: string, line: number };
+  err: { code: string; msg: string, line: number, col: number };
 };
 
 export function parse(xmlData: string, options?: X2jOptionsOptional, validationOptions?: validationOptionsOptional | boolean): any;

package/src/parser.js

@@ -6,7 +6,7 @@ const x2xmlnode = require('./xmlstr2xmlnode');
 const buildOptions = require('./util').buildOptions;
 const validator = require('./validator');
 
-exports.parse = function(xmlData, options, validationOption) {
+exports.parse = function(xmlData, givenOptions = {}, validationOption) {
   if( validationOption){
     if(validationOption === true) validationOption = {}
     
@@ -15,7 +15,16 @@ exports.parse = function(xmlData, options, validationOption) {
       throw Error( result.err.msg)
     }
   }
-  options = buildOptions(options, x2xmlnode.defaultOptions, x2xmlnode.props);
+  if(givenOptions.parseTrueNumberOnly 
+    && givenOptions.parseNodeValue !== false
+    && !givenOptions.numParseOptions){
+    
+      givenOptions.numParseOptions = {
+        leadingZeros: false,
+      }
+  }
+  let options = buildOptions(givenOptions, x2xmlnode.defaultOptions, x2xmlnode.props);
+
   const traversableObj = xmlToNodeobj.getTraversalObj(xmlData, options)
   //print(traversableObj, "  ");
   return nodeToJson.convertToJson(traversableObj, options);

package/src/util.js

@@ -10,6 +10,7 @@ const getAllMatches = function(string, regex) {
   let match = regex.exec(string);
   while (match) {
     const allmatches = [];
+    allmatches.startIndex = regex.lastIndex - match[0].length;
     const len = match.length;
     for (let index = 0; index < len; index++) {
       allmatches.push(match[index]);
@@ -67,7 +68,7 @@ exports.getValue = function(v) {
 // const fakeCallNoReturn = function() {};
 
 exports.buildOptions = function(options, defaultOptions, props) {
-  var newOptions = {};
+  let newOptions = {};
   if (!options) {
     return defaultOptions; //if there are not options
   }

package/src/validator.js

@@ -35,7 +35,7 @@ exports.validate = function (xmlData, options) {
     }else if (xmlData[i] === '<') {
       //starting of tag
       //read until you reach to '>' avoiding any '>' in attribute value
-
+      let tagStartPos = i;
       i++;
       
       if (xmlData[i] === '!') {
@@ -71,7 +71,7 @@ exports.validate = function (xmlData, options) {
         if (!validateTagName(tagName)) {
           let msg;
           if (tagName.trim().length === 0) {
-            msg = "There is an unnecessary space between tag name and backward slash '</ ..'.";
+            msg = "Invalid space after '<'.";
           } else {
             msg = "Tag '"+tagName+"' is an invalid name.";
           }
@@ -87,6 +87,7 @@ exports.validate = function (xmlData, options) {
 
         if (attrStr[attrStr.length - 1] === '/') {
           //self closing tag
+          const attrStrStart = i - attrStr.length;
           attrStr = attrStr.substring(0, attrStr.length - 1);
           const isValid = validateAttributeString(attrStr, options);
           if (isValid === true) {
@@ -96,17 +97,20 @@ exports.validate = function (xmlData, options) {
             //the result from the nested function returns the position of the error within the attribute
             //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
             //this gives us the absolute index in the entire xml, which we can use to find the line at last
-            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
+            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
           }
         } else if (closingTag) {
           if (!result.tagClosed) {
             return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
           } else if (attrStr.trim().length > 0) {
-            return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, i));
+            return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
           } else {
             const otg = tags.pop();
-            if (tagName !== otg) {
-              return getErrorObject('InvalidTag', "Closing tag '"+otg+"' is expected inplace of '"+tagName+"'.", getLineNumberForPosition(xmlData, i));
+            if (tagName !== otg.tagName) {
+              let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
+              return getErrorObject('InvalidTag',
+                "Expected closing tag '"+otg.tagName+"' (opened in line "+openPos.line+", col "+openPos.col+") instead of closing tag '"+tagName+"'.",
+                getLineNumberForPosition(xmlData, tagStartPos));
             }
 
             //when there are no more tags, we reached the root level.
@@ -127,7 +131,7 @@ exports.validate = function (xmlData, options) {
           if (reachedRoot === true) {
             return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));
           } else {
-            tags.push(tagName);
+            tags.push({tagName, tagStartPos});
           }
           tagFound = true;
         }
@@ -168,8 +172,12 @@ exports.validate = function (xmlData, options) {
 
   if (!tagFound) {
     return getErrorObject('InvalidXml', 'Start tag expected.', 1);
-  } else if (tags.length > 0) {
-    return getErrorObject('InvalidXml', "Invalid '"+JSON.stringify(tags, null, 4).replace(/\r?\n/g, '')+"' found.", 1);
+  }else if (tags.length == 1) {
+      return getErrorObject('InvalidTag', "Unclosed tag '"+tags[0].tagName+"'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
+  }else if (tags.length > 0) {
+      return getErrorObject('InvalidXml', "Invalid '"+
+          JSON.stringify(tags.map(t => t.tagName), null, 4).replace(/\r?\n/g, '')+
+          "' found.", {line: 1, col: 1});
   }
 
   return true;
@@ -181,11 +189,11 @@ exports.validate = function (xmlData, options) {
  * @param {*} i
  */
 function readPI(xmlData, i) {
-  var start = i;
+  const start = i;
   for (; i < xmlData.length; i++) {
     if (xmlData[i] == '?' || xmlData[i] == ' ') {
       //tagname
-      var tagname = xmlData.substr(start, i - start);
+      const tagname = xmlData.substr(start, i - start);
       if (i > 5 && tagname === 'xml') {
         return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i));
       } else if (xmlData[i] == '?' && xmlData[i + 1] == '>') {
@@ -251,8 +259,8 @@ function readCommentAndCDATA(xmlData, i) {
   return i;
 }
 
-var doubleQuote = '"';
-var singleQuote = "'";
+const doubleQuote = '"';
+const singleQuote = "'";
 
 /**
  * Keep reading xmlData until '<' is found outside the attribute value.
@@ -269,7 +277,6 @@ function readAttributeStr(xmlData, i) {
         startChar = xmlData[i];
       } else if (startChar !== xmlData[i]) {
         //if vaue is enclosed with double quote then single quotes are allowed inside the value and vice versa
-        continue;
       } else {
         startChar = '';
       }
@@ -310,23 +317,23 @@ function validateAttributeString(attrStr, options) {
   for (let i = 0; i < matches.length; i++) {
     if (matches[i][1].length === 0) {
       //nospace before attribute name: a="sd"b="saf"
-      return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' has no space in starting.", getPositionFromMatch(attrStr, matches[i][0]))
+      return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' has no space in starting.", getPositionFromMatch(matches[i]))
     } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {
       //independent attribute: ab
-      return getErrorObject('InvalidAttr', "boolean attribute '"+matches[i][2]+"' is not allowed.", getPositionFromMatch(attrStr, matches[i][0]));
+      return getErrorObject('InvalidAttr', "boolean attribute '"+matches[i][2]+"' is not allowed.", getPositionFromMatch(matches[i]));
     }
     /* else if(matches[i][6] === undefined){//attribute without value: ab=
                     return { err: { code:"InvalidAttr",msg:"attribute " + matches[i][2] + " has no value assigned."}};
                 } */
     const attrName = matches[i][2];
     if (!validateAttrName(attrName)) {
-      return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is an invalid name.", getPositionFromMatch(attrStr, matches[i][0]));
+      return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is an invalid name.", getPositionFromMatch(matches[i]));
     }
     if (!attrNames.hasOwnProperty(attrName)) {
       //check for duplicate attribute.
       attrNames[attrName] = 1;
     } else {
-      return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is repeated.", getPositionFromMatch(attrStr, matches[i][0]));
+      return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is repeated.", getPositionFromMatch(matches[i]));
     }
   }
 
@@ -373,7 +380,8 @@ function getErrorObject(code, message, lineNumber) {
     err: {
       code: code,
       msg: message,
-      line: lineNumber,
+      line: lineNumber.line || lineNumber,
+      col: lineNumber.col,
     },
   };
 }
@@ -390,11 +398,16 @@ function validateTagName(tagname) {
 
 //this function returns the line number for the character at the given index
 function getLineNumberForPosition(xmlData, index) {
-  var lines = xmlData.substring(0, index).split(/\r?\n/);
-  return lines.length;
+  const lines = xmlData.substring(0, index).split(/\r?\n/);
+  return {
+    line: lines.length,
+
+    // column number is last line's length + 1, because column numbering starts at 1:
+    col: lines[lines.length - 1].length + 1
+  };
 }
 
-//this function returns the position of the last character of match within attrStr
-function getPositionFromMatch(attrStr, match) {
-  return attrStr.indexOf(match) + match.length;
+//this function returns the position of the first character of match within attrStr
+function getPositionFromMatch(match) {
+  return match.startIndex + match[1].length;
 }

package/src/xmlstr2xmlnode.js

@@ -3,6 +3,8 @@
 const util = require('./util');
 const buildOptions = require('./util').buildOptions;
 const xmlNode = require('./xmlNode');
+const toNumber = require("strnum");
+
 const regx =
   '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)'
   .replace(/NAME/g, util.nameRegexp);
@@ -32,13 +34,18 @@ const defaultOptions = {
   trimValues: true, //Trim string values of tag and attributes
   cdataTagName: false,
   cdataPositionChar: '\\c',
+  numParseOptions: {
+    hex: true,
+    leadingZeros: true
+  },
   tagValueProcessor: function(a, tagName) {
     return a;
   },
   attrValueProcessor: function(a, attrName) {
     return a;
   },
-  stopNodes: []
+  stopNodes: [],
+  alwaysCreateTextNode: false
   //decodeStrict: false,
 };
 
@@ -60,7 +67,9 @@ const props = [
   'tagValueProcessor',
   'attrValueProcessor',
   'parseTrueNumberOnly',
-  'stopNodes'
+  'numParseOptions',
+  'stopNodes',
+  'alwaysCreateTextNode'
 ];
 exports.props = props;
 
@@ -76,7 +85,7 @@ function processTagValue(tagName, val, options) {
       val = val.trim();
     }
     val = options.tagValueProcessor(val, tagName);
-    val = parseValue(val, options.parseNodeValue, options.parseTrueNumberOnly);
+    val = parseValue(val, options.parseNodeValue, options.numParseOptions);
   }
 
   return val;
@@ -96,26 +105,13 @@ function resolveNameSpace(tagname, options) {
   return tagname;
 }
 
-function parseValue(val, shouldParse, parseTrueNumberOnly) {
+function parseValue(val, shouldParse, options) {
   if (shouldParse && typeof val === 'string') {
-    let parsed;
-    if (val.trim() === '' || isNaN(val)) {
-      parsed = val === 'true' ? true : val === 'false' ? false : val;
-    } else {
-      if (val.indexOf('0x') !== -1) {
-        //support hexa decimal
-        parsed = Number.parseInt(val, 16);
-      } else if (val.indexOf('.') !== -1) {
-        parsed = Number.parseFloat(val);
-        val = val.replace(/\.?0+$/, "");
-      } else {
-        parsed = Number.parseInt(val, 10);
-      }
-      if (parseTrueNumberOnly) {
-        parsed = String(parsed) === val ? parsed : val;
-      }
-    }
-    return parsed;
+    //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;
@@ -148,7 +144,7 @@ function buildAttributesMap(attrStr, options) {
           attrs[options.attributeNamePrefix + attrName] = parseValue(
             matches[i][4],
             options.parseAttributeValue,
-            options.parseTrueNumberOnly
+            options.numParseOptions
           );
         } else if (options.allowBooleanAttributes) {
           attrs[options.attributeNamePrefix + attrName] = true;