update, text, response

node_modules/fast-xml-parser/src/cli/cli.js

@@ -57,7 +57,7 @@ if (process.argv[2] === '--help' || process.argv[2] === '-h') {
     if (outputFileName) {
       writeToFile(outputFileName, output);
     } else {
-      console.log(output);
+      console.log(JSON.stringify(output, null, 2));
     }
   };
 

node_modules/fast-xml-parser/src/fxp.d.ts

@@ -1,81 +1,391 @@
 type X2jOptions = {
-  preserveOrder: boolean;
-  attributeNamePrefix: string;
-  attributesGroupName: false | string;
-  textNodeName: string;
-  ignoreAttributes: boolean;
-  removeNSPrefix: boolean;
-  allowBooleanAttributes: boolean;
-  parseTagValue: boolean;
-  parseAttributeValue: boolean;
-  trimValues: boolean;
-  cdataPropName: false | string;
-  commentPropName: false | string;
-    /**
-Control how tag value should be parsed. Called only if tag value is not empty
-
-@returns {undefined|null} `undefined` or `null` to set original value.
-@returns {unknown} 
-1. Different value or value with different data type to set new value. <br>
-2. Same value to set parsed value if `parseTagValue: true`.
+  /**
+   * Preserve the order of tags in resulting JS object
+   * 
+   * Defaults to `false`
    */
-  tagValueProcessor: (tagName: string, tagValue: string, jPath: string, hasAttributes: boolean, isLeafNode: boolean) => unknown;
-  attributeValueProcessor: (attrName: string, attrValue: string, jPath: string) => unknown;
-  numberParseOptions: strnumOptions;
-  stopNodes: string[];
-  unpairedTags: string[];
-  alwaysCreateTextNode: boolean;
-  isArray: (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean) => boolean;
-  processEntities: boolean;
-  htmlEntities: boolean;
-  ignoreDeclaration: boolean;
-  ignorePiTags: boolean;
-  transformTagName: ((tagName: string) => string) | false;
-  transformAttributeName: ((attributeName: string) => string) | false;
-    /**
-Change the tag name when a different name is returned. Skip the tag from parsed result when false is returned. 
-Modify `attrs` object to control attributes for the given tag.
+  preserveOrder?: boolean;
 
-@returns {string} new tag name.
-@returns false to skip the tag
+  /**
+   * Give a prefix to the attribute name in the resulting JS object
+   * 
+   * Defaults to '@_'
+   */  
+  attributeNamePrefix?: string;
+
+  /**
+   * A name to group all attributes of a tag under, or `false` to disable
+   * 
+   * Defaults to `false`
    */
-  updateTag: (tagName: string, jPath: string, attrs: {[k: string]: string}) =>  string | boolean;
+  attributesGroupName?: false | string;
+
+  /**
+   * The name of the next node in the resulting JS
+   * 
+   * Defaults to `#text`
+   */
+  textNodeName?: string;
+
+  /**
+   * Whether to ignore attributes when parsing
+   * 
+   * When `true` - ignores all the attributes
+   * 
+   * When `false` - parses all the attributes
+   * 
+   * When `Array<string | RegExp>` - filters out attributes that match provided patterns
+   * 
+   * When `Function` - calls the function for each attribute and filters out those for which the function returned `true`
+   * 
+   * Defaults to `true`
+   */
+  ignoreAttributes?: boolean | (string | RegExp)[] | ((attrName: string, jPath: string) => boolean);
+
+  /**
+   * Whether to remove namespace string from tag and attribute names
+   * 
+   * Defaults to `false`
+   */
+  removeNSPrefix?: boolean;
+
+  /**
+   * Whether to allow attributes without value
+   * 
+   * Defaults to `false`
+   */
+  allowBooleanAttributes?: boolean;
+
+  /**
+   * Whether to parse tag value with `strnum` package
+   * 
+   * Defaults to `true`
+   */
+  parseTagValue?: boolean;
+
+  /**
+   * Whether to parse tag value with `strnum` package
+   * 
+   * Defaults to `false`
+   */
+  parseAttributeValue?: boolean;
+
+  /**
+   * Whether to remove surrounding whitespace from tag or attribute value
+   * 
+   * Defaults to `true`
+   */
+  trimValues?: boolean;
+
+  /**
+   * Give a property name to set CDATA values to instead of merging to tag's text value
+   * 
+   * Defaults to `false`
+   */
+  cdataPropName?: false | string;
+
+  /**
+   * If set, parse comments and set as this property
+   * 
+   * Defaults to `false`
+   */
+  commentPropName?: false | string;
+
+  /**
+   * Control how tag value should be parsed. Called only if tag value is not empty
+   * 
+   * @returns {undefined|null} `undefined` or `null` to set original value.
+   * @returns {unknown} 
+   * 
+   * 1. Different value or value with different data type to set new value.
+   * 2. Same value to set parsed value if `parseTagValue: true`.
+   * 
+   * Defaults to `(tagName, val, jPath, hasAttributes, isLeafNode) => val`
+   */
+  tagValueProcessor?: (tagName: string, tagValue: string, jPath: string, hasAttributes: boolean, isLeafNode: boolean) => unknown;
+
+  /**
+   * Control how attribute value should be parsed
+   * 
+   * @param attrName 
+   * @param attrValue 
+   * @param jPath 
+   * @returns {undefined|null} `undefined` or `null` to set original value
+   * @returns {unknown}
+   * 
+   * Defaults to `(attrName, val, jPath) => val`
+   */
+  attributeValueProcessor?: (attrName: string, attrValue: string, jPath: string) => unknown;
+
+  /**
+   * Options to pass to `strnum` for parsing numbers
+   * 
+   * Defaults to `{ hex: true, leadingZeros: true, eNotation: true }`
+   */
+  numberParseOptions?: strnumOptions;
+
+  /**
+   * Nodes to stop parsing at
+   * 
+   * Defaults to `[]`
+   */
+  stopNodes?: string[];
+
+  /**
+   * List of tags without closing tags
+   * 
+   * Defaults to `[]`
+   */
+  unpairedTags?: string[];
+
+  /**
+   * Whether to always create a text node
+   * 
+   * Defaults to `false`
+   */
+  alwaysCreateTextNode?: boolean;
+
+  /**
+   * Determine whether a tag should be parsed as an array
+   * 
+   * @param tagName 
+   * @param jPath 
+   * @param isLeafNode 
+   * @param isAttribute 
+   * @returns {boolean}
+   * 
+   * Defaults to `() => false`
+   */
+  isArray?: (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean) => boolean;
+
+  /**
+   * Whether to process default and DOCTYPE entities
+   * 
+   * Defaults to `true`
+   */
+  processEntities?: boolean;
+
+  /**
+   * Whether to process HTML entities
+   * 
+   * Defaults to `false`
+   */
+  htmlEntities?: boolean;
+
+  /**
+   * Whether to ignore the declaration tag from output
+   * 
+   * Defaults to `false`
+   */
+  ignoreDeclaration?: boolean;
+
+  /**
+   * Whether to ignore Pi tags
+   * 
+   * Defaults to `false`
+   */
+  ignorePiTags?: boolean;
+
+  /**
+   * Transform tag names
+   * 
+   * Defaults to `false`
+   */
+  transformTagName?: ((tagName: string) => string) | false;
+
+  /**
+   * Transform attribute names
+   * 
+   * Defaults to `false`
+   */
+  transformAttributeName?: ((attributeName: string) => string) | false;
+
+  /**
+   * Change the tag name when a different name is returned. Skip the tag from parsed result when false is returned.
+   * Modify `attrs` object to control attributes for the given tag.
+   * 
+   * @returns {string} new tag name.
+   * @returns false to skip the tag
+   * 
+   * Defaults to `(tagName, jPath, attrs) => tagName`
+   */
+  updateTag?: (tagName: string, jPath: string, attrs: {[k: string]: string}) =>  string | boolean;
 };
+
 type strnumOptions = {
   hex: boolean;
   leadingZeros: boolean,
   skipLike?: RegExp,
   eNotation?: boolean
 }
-type X2jOptionsOptional = Partial<X2jOptions>;
+
 type validationOptions = {
-  allowBooleanAttributes: boolean;
-  unpairedTags: string[];
+  /**
+   * Whether to allow attributes without value
+   * 
+   * Defaults to `false`
+   */
+  allowBooleanAttributes?: boolean;
+  
+  /**
+   * List of tags without closing tags
+   * 
+   * Defaults to `[]`
+   */
+  unpairedTags?: string[];
 };
-type validationOptionsOptional = Partial<validationOptions>;
 
 type XmlBuilderOptions = {
-  attributeNamePrefix: string;
-  attributesGroupName: false | string;
-  textNodeName: string;
-  ignoreAttributes: boolean;
-  cdataPropName: false | string;
-  commentPropName: false | string;
-  format: boolean;
-  indentBy: string;
-  arrayNodeName: string;
-  suppressEmptyNode: boolean;
-  suppressUnpairedNode: boolean;
-  suppressBooleanAttributes: boolean;
-  preserveOrder: boolean;
-  unpairedTags: string[];
-  stopNodes: string[];
-  tagValueProcessor: (name: string, value: unknown) => string;
-  attributeValueProcessor: (name: string, value: unknown) => string;
-  processEntities: boolean;
-  oneListGroup: boolean;
+  /**
+   * Give a prefix to the attribute name in the resulting JS object
+   * 
+   * Defaults to '@_'
+   */  
+  attributeNamePrefix?: string;
+
+  /**
+   * A name to group all attributes of a tag under, or `false` to disable
+   * 
+   * Defaults to `false`
+   */
+  attributesGroupName?: false | string;
+
+  /**
+   * The name of the next node in the resulting JS
+   * 
+   * Defaults to `#text`
+   */
+  textNodeName?: string;
+
+  /**
+   * Whether to ignore attributes when building
+   * 
+   * When `true` - ignores all the attributes
+   * 
+   * When `false` - builds all the attributes
+   * 
+   * When `Array<string | RegExp>` - filters out attributes that match provided patterns
+   * 
+   * When `Function` - calls the function for each attribute and filters out those for which the function returned `true`
+   * 
+   * Defaults to `true`
+   */
+  ignoreAttributes?: boolean | (string | RegExp)[] | ((attrName: string, jPath: string) => boolean);
+
+  /**
+   * Give a property name to set CDATA values to instead of merging to tag's text value
+   * 
+   * Defaults to `false`
+   */
+  cdataPropName?: false | string;
+
+  /**
+   * If set, parse comments and set as this property
+   * 
+   * Defaults to `false`
+   */
+  commentPropName?: false | string;
+
+  /**
+   * Whether to make output pretty instead of single line
+   * 
+   * Defaults to `false`
+   */
+  format?: boolean;
+
+
+  /**
+   * If `format` is set to `true`, sets the indent string
+   * 
+   * Defaults to `  `
+   */
+  indentBy?: string;
+
+  /**
+   * Give a name to a top-level array
+   * 
+   * Defaults to `undefined`
+   */
+  arrayNodeName?: string;
+
+  /**
+   * Create empty tags for tags with no text value
+   * 
+   * Defaults to `false`
+   */
+  suppressEmptyNode?: boolean;
+
+  /**
+   * Suppress an unpaired tag
+   * 
+   * Defaults to `true`
+   */
+  suppressUnpairedNode?: boolean;
+
+  /**
+   * Don't put a value for boolean attributes
+   * 
+   * Defaults to `true`
+   */
+  suppressBooleanAttributes?: boolean;
+
+  /**
+   * Preserve the order of tags in resulting JS object
+   * 
+   * Defaults to `false`
+   */
+  preserveOrder?: boolean;
+
+  /**
+   * List of tags without closing tags
+   * 
+   * Defaults to `[]`
+   */
+  unpairedTags?: string[];
+
+  /**
+   * Nodes to stop parsing at
+   * 
+   * Defaults to `[]`
+   */
+  stopNodes?: string[];
+
+  /**
+   * Control how tag value should be parsed. Called only if tag value is not empty
+   * 
+   * @returns {undefined|null} `undefined` or `null` to set original value.
+   * @returns {unknown} 
+   * 
+   * 1. Different value or value with different data type to set new value.
+   * 2. Same value to set parsed value if `parseTagValue: true`.
+   * 
+   * Defaults to `(tagName, val, jPath, hasAttributes, isLeafNode) => val`
+   */
+  tagValueProcessor?: (name: string, value: unknown) => unknown;
+
+  /**
+   * Control how attribute value should be parsed
+   * 
+   * @param attrName 
+   * @param attrValue 
+   * @param jPath 
+   * @returns {undefined|null} `undefined` or `null` to set original value
+   * @returns {unknown}
+   * 
+   * Defaults to `(attrName, val, jPath) => val`
+   */
+  attributeValueProcessor?: (name: string, value: unknown) => unknown;
+
+  /**
+   * Whether to process default and DOCTYPE entities
+   * 
+   * Defaults to `true`
+   */
+  processEntities?: boolean;
+
+
+  oneListGroup?: boolean;
 };
-type XmlBuilderOptionsOptional = Partial<XmlBuilderOptions>;
 
 type ESchema = string | object | Array<string|object>;
 
@@ -89,20 +399,20 @@ type ValidationError = {
 };
 
 export class XMLParser {
-  constructor(options?: X2jOptionsOptional);
-  parse(xmlData: string | Buffer ,validationOptions?: validationOptionsOptional | boolean): any;
+  constructor(options?: X2jOptions);
+  parse(xmlData: string | Buffer ,validationOptions?: validationOptions | boolean): any;
   /**
    * Add Entity which is not by default supported by this library
-   * @param entityIndentifier {string} Eg: 'ent' for &ent;
+   * @param entityIdentifier {string} Eg: 'ent' for &ent;
    * @param entityValue {string} Eg: '\r'
    */
-  addEntity(entityIndentifier: string, entityValue: string): void;
+  addEntity(entityIdentifier: string, entityValue: string): void;
 }
 
 export class XMLValidator{
-  static validate(  xmlData: string,  options?: validationOptionsOptional): true | ValidationError;
+  static validate(  xmlData: string,  options?: validationOptions): true | ValidationError;
 }
 export class XMLBuilder {
-  constructor(options?: XmlBuilderOptionsOptional);
+  constructor(options?: XmlBuilderOptions);
   build(jObj: any): any;
 }

node_modules/fast-xml-parser/src/ignoreAttributes.js

@@ -0,0 +1,20 @@
+function getIgnoreAttributesFn(ignoreAttributes) {
+    if (typeof ignoreAttributes === 'function') {
+        return ignoreAttributes
+    }
+    if (Array.isArray(ignoreAttributes)) {
+        return (attrName) => {
+            for (const pattern of ignoreAttributes) {
+                if (typeof pattern === 'string' && attrName === pattern) {
+                    return true
+                }
+                if (pattern instanceof RegExp && pattern.test(attrName)) {
+                    return true
+                }
+            }
+        }
+    }
+    return () => false
+}
+
+module.exports = getIgnoreAttributesFn

node_modules/fast-xml-parser/src/v5/CharsSymbol.js

@@ -0,0 +1,16 @@
+modules.export = {
+  "<" : "<", //tag start
+  ">" : ">", //tag end
+  "/" : "/", //close tag
+  "!" : "!", //comment or docttype
+  "!--" : "!--", //comment
+  "-->" : "-->", //comment end
+  "?" : "?", //pi
+  "?>" : "?>", //pi end
+  "?xml" : "?xml", //pi end
+  "![" : "![", //cdata
+  "]]>" : "]]>", //cdata end
+  "[" : "[",
+  "-" : "-",
+  "D" : "D",
+}

node_modules/fast-xml-parser/src/v5/EntitiesParser.js

@@ -0,0 +1,107 @@
+const ampEntity = { regex: /&(amp|#38|#x26);/g, val : "&"};
+const 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: "₹" },
+    "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 10)) },
+    "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 16)) },
+};
+
+class EntitiesParser{
+    constructor(replaceHtmlEntities) {
+      this.replaceHtmlEntities = replaceHtmlEntities;
+      this.docTypeEntities = {};
+      this.lastEntities = {
+        "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 : "\""},
+      };
+    }
+
+    addExternalEntities(externalEntities){
+        const entKeys = Object.keys(externalEntities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.addExternalEntity(ent,externalEntities[ent])
+        }
+    }
+    addExternalEntity(key,val){
+      validateEntityName(key);
+      if(val.indexOf("&") !== -1) {
+        reportWarning(`Entity ${key} is not added as '&' is found in value;`)
+        return;
+      }else{
+        this.lastEntities[ent] = {
+          regex: new RegExp("&"+key+";","g"),
+          val : val
+        }
+      }
+    }
+
+    addDocTypeEntities(entities){
+        const entKeys = Object.keys(entities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.docTypeEntities[ent] = {
+             regex: new RegExp("&"+ent+";","g"),
+             val : entities[ent]
+          }
+        }
+    }
+
+    parse(val){
+        return this.replaceEntitiesValue(val)
+    }
+
+    /**
+     * 1. Replace DOCTYPE entities 
+     * 2. Replace external entities 
+     * 3. Replace HTML entities if asked
+     * @param {string} val 
+     */
+    replaceEntitiesValue(val){
+        if(typeof val === "string" && val.length > 0){
+            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.replaceHtmlEntities){
+                for(let entityName in htmlEntities){
+                  const entity = htmlEntities[entityName];
+                  val = val.replace( entity.regex, entity.val);
+                }
+              }
+            val = val.replace( ampEntity.regex, ampEntity.val);
+        }
+        return val;
+    }
+};
+
+//an entity name should not contains special characters that may be used in regex
+//Eg !?\\\/[]$%{}^&*()<>
+const specialChar = "!?\\\/[]$%{}^&*()<>|+";
+
+function validateEntityName(name){
+    for (let i = 0; i < specialChar.length; i++) {
+        const ch = specialChar[i];
+        if(name.indexOf(ch) !== -1) throw new Error(`Invalid character ${ch} in entity name`);
+    }
+    return name;
+}
+
+module.exports = EntitiesParser;

node_modules/fast-xml-parser/src/v5/OptionsBuilder.js

@@ -0,0 +1,64 @@
+
+const JsObjOutputBuilder = require("./OutputBuilders/JsObjBuilder");
+
+const defaultOptions = {
+  preserveOrder: false,
+  removeNSPrefix: false, // remove NS from tag name or attribute name if true
+  //ignoreRootElement : false,
+  stopNodes: [], //nested tags will not be parsed even for errors
+  // isArray: () => false, //User will set it
+  htmlEntities: false,
+  // skipEmptyListItem: false
+  tags:{
+    unpaired: [],
+    nameFor:{
+      cdata: false,
+      comment: false,
+      text: '#text'
+    },
+    separateTextProperty: false,
+  },
+  attributes:{
+    ignore: false,
+    booleanType: true,
+    entities: true,
+  },
+
+  // select: ["img[src]"],
+  // stop: ["anim", "[ads]"]
+  only: [], // rest tags will be skipped. It will result in flat array
+  hierarchy: false, //will be used when a particular tag is set to be parsed.
+  skip: [], // will be skipped from parse result. on('skip') will be triggered
+
+  select: [], // on('select', tag => tag ) will be called if match
+  stop: [], //given tagPath will not be parsed. innerXML will be set as string value
+  OutputBuilder: new JsObjOutputBuilder(),
+};
+   
+const buildOptions = function(options) {
+  const finalOptions = { ... defaultOptions};
+  copyProperties(finalOptions,options)
+  return finalOptions;
+};
+
+function copyProperties(target, source) {
+  for (let key in source) {
+    if (source.hasOwnProperty(key)) {
+      if (key === 'OutputBuilder') {
+        target[key] = source[key];
+      }else if (typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        // Recursively copy nested properties
+        if (typeof target[key] === 'undefined') {
+          target[key] = {};
+        }
+        copyProperties(target[key], source[key]);
+      } else {
+        // Copy non-nested properties
+        target[key] = source[key];
+      }
+    }
+  }
+}
+
+exports.buildOptions = buildOptions;
+exports.defaultOptions = defaultOptions;

node_modules/fast-xml-parser/src/v5/OutputBuilders/BaseOutputBuilder.js

@@ -0,0 +1,71 @@
+class BaseOutputBuilder{
+  constructor(){
+    // this.attributes = {};
+  }
+
+  addAttribute(name, value){
+    if(this.options.onAttribute){
+      //TODO: better to pass tag path
+      const v = this.options.onAttribute(name, value, this.tagName);
+      if(v) this.attributes[v.name] = v.value;
+    }else{
+      name = this.options.attributes.prefix + name + this.options.attributes.suffix;
+      this.attributes[name] = this.parseValue(value, this.options.attributes.valueParsers);
+    }
+  }
+
+  /**
+   * parse value by chain of parsers
+   * @param {string} val 
+   * @returns {any} parsed value if matching parser found
+   */
+    parseValue = function(val, valParsers){
+      for (let i = 0; i < valParsers.length; i++) {
+        let valParser = valParsers[i];
+        if(typeof valParser === "string"){
+          valParser = this.registeredParsers[valParser];
+        }
+        if(valParser){
+          val = valParser.parse(val);
+        }
+      }
+      return val;
+    }
+
+  /**
+   * To add a nested empty tag.
+   * @param {string} key 
+   * @param {any} val 
+   */
+  _addChild(key, val){}
+
+  /**
+   * skip the comment if property is not set
+   */
+  addComment(text){
+    if(this.options.nameFor.comment)
+      this._addChild(this.options.nameFor.comment, text);
+  }
+
+  //store CDATA separately if property is set
+  //otherwise add to tag's value
+  addCdata(text){
+    if (this.options.nameFor.cdata) {
+      this._addChild(this.options.nameFor.cdata, text);
+    } else {
+      this.addRawValue(text || "");
+    }
+  }
+
+  addRawValue = text => this.addValue(text);
+
+  addDeclaration(){
+    if(!this.options.declaration){
+    }else{
+      this.addPi("?xml");
+    }
+    this.attributes = {}
+  }
+}
+
+module.exports = BaseOutputBuilder;

node_modules/fast-xml-parser/src/v5/OutputBuilders/JsArrBuilder.js

@@ -0,0 +1,103 @@
+const {buildOptions,registerCommonValueParsers} = require("./ParserOptionsBuilder");
+
+class OutputBuilder{
+  constructor(options){
+    this.options = buildOptions(options);
+      this.registeredParsers = registerCommonValueParsers(this.options);
+    }
+    
+    registerValueParser(name,parserInstance){//existing name will override the parser without warning
+      this.registeredParsers[name] = parserInstance;
+    }
+
+  getInstance(parserOptions){
+    return new JsArrBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+const rootName = '!js_arr';
+const BaseOutputBuilder = require("./BaseOutputBuilder");
+
+class JsArrBuilder extends BaseOutputBuilder{
+
+  constructor(parserOptions, options,registeredParsers) {
+    super();
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = options;
+    this.registeredParsers = registeredParsers;
+
+    this.root = new Node(rootName);
+    this.currentNode = this.root;
+    this.attributes = {};
+  }
+
+  addTag(tag){
+    //when a new tag is added, it should be added as child of current node
+    //TODO: shift this check to the parser
+    if(tag.name === "__proto__") tag.name = "#__proto__";
+
+    this.tagsStack.push(this.currentNode);
+    this.currentNode = new Node(tag.name, this.attributes);
+    this.attributes = {};
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag(){
+    const node = this.currentNode;
+    this.currentNode = this.tagsStack.pop(); //set parent node in scope
+    if(this.options.onClose !== undefined){
+      //TODO TagPathMatcher 
+      const resultTag = this.options.onClose(node, 
+        new TagPathMatcher(this.tagsStack,node));
+
+      if(resultTag) return;
+    }
+    this.currentNode.child.push(node);  //to parent node
+  }
+
+  //Called by parent class methods
+  _addChild(key, val){
+    // if(key === "__proto__") tagName = "#__proto__";
+    this.currentNode.child.push( {[key]: val });
+    // this.currentNode.leafType = false;
+  }
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text){
+    this.currentNode.child.push( {[this.options.nameFor.text]: this.parseValue(text, this.options.tags.valueParsers) });
+  }
+
+  addPi(name){
+    //TODO: set pi flag
+    if(!this.options.ignorePiTags){
+      const node = new Node(name, this.attributes);
+      this.currentNode[":@"] = this.attributes;
+      this.currentNode.child.push(node);
+    }
+    this.attributes = {};
+  }
+  getOutput(){
+    return this.root.child[0];
+  }
+}
+
+
+
+class Node{
+  constructor(tagname, attributes){
+    this.tagname = tagname;
+    this.child = []; //nested tags, text, cdata, comments
+    if(attributes && Object.keys(attributes).length > 0)
+      this[":@"] = attributes;
+  }
+}
+
+module.exports = OutputBuilder;

node_modules/fast-xml-parser/src/v5/OutputBuilders/JsMinArrBuilder.js

@@ -0,0 +1,102 @@
+const {buildOptions,registerCommonValueParsers} = require("./ParserOptionsBuilder");
+
+class OutputBuilder{
+  constructor(options){
+    this.options = buildOptions(options);
+      this.registeredParsers = registerCommonValueParsers(this.options);
+    }
+    
+    registerValueParser(name,parserInstance){//existing name will override the parser without warning
+      this.registeredParsers[name] = parserInstance;
+    }
+
+  getInstance(parserOptions){
+    return new JsMinArrBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+const BaseOutputBuilder = require("./BaseOutputBuilder");
+const rootName = '^';
+
+class JsMinArrBuilder extends BaseOutputBuilder{
+
+  constructor(parserOptions, options,registeredParsers) {
+    super();
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = options;
+    this.registeredParsers = registeredParsers;
+
+    this.root = {[rootName]: []};
+    this.currentNode = this.root;
+    this.currentNodeTagName = rootName;
+    this.attributes = {};
+  }
+
+  addTag(tag){
+    //when a new tag is added, it should be added as child of current node
+    //TODO: shift this check to the parser
+    if(tag.name === "__proto__") tag.name = "#__proto__";
+
+    this.tagsStack.push([this.currentNodeTagName,this.currentNode]); //this.currentNode is parent node here
+    this.currentNodeTagName = tag.name;
+    this.currentNode = { [tag.name]:[]}
+    if(Object.keys(this.attributes).length > 0){
+      this.currentNode[":@"] = this.attributes;
+      this.attributes = {};
+    }
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag(){
+    const node = this.currentNode;
+    const nodeName = this.currentNodeTagName;
+    const arr = this.tagsStack.pop(); //set parent node in scope
+    this.currentNodeTagName = arr[0];
+    this.currentNode = arr[1];
+
+    if(this.options.onClose !== undefined){
+      //TODO TagPathMatcher 
+      const resultTag = this.options.onClose(node, 
+        new TagPathMatcher(this.tagsStack,node));
+
+      if(resultTag) return;
+    }
+    this.currentNode[this.currentNodeTagName].push(node);  //to parent node
+  }
+
+  //Called by parent class methods
+  _addChild(key, val){
+    // if(key === "__proto__") tagName = "#__proto__";
+    this.currentNode.push( {[key]: val });
+    // this.currentNode.leafType = false;
+  }
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text){
+    this.currentNode[this.currentNodeTagName].push( {[this.options.nameFor.text]: this.parseValue(text, this.options.tags.valueParsers) });
+  }
+
+  addPi(name){
+    if(!this.options.ignorePiTags){
+      const node = { [name]:[]}
+      if(this.attributes){
+        node[":@"] = this.attributes;
+      }
+      this.currentNode.push(node);
+    }
+    this.attributes = {};
+  }
+  getOutput(){
+    return this.root[rootName];
+  }
+}
+
+module.exports = OutputBuilder;

node_modules/fast-xml-parser/src/v5/OutputBuilders/JsObjBuilder.js

@@ -0,0 +1,156 @@
+
+
+const {buildOptions,registerCommonValueParsers} = require("./ParserOptionsBuilder");
+
+class OutputBuilder{
+  constructor(builderOptions){
+      this.options = buildOptions(builderOptions);
+      this.registeredParsers = registerCommonValueParsers(this.options);
+  }
+
+  registerValueParser(name,parserInstance){//existing name will override the parser without warning
+    this.registeredParsers[name] = parserInstance;
+  }
+
+  getInstance(parserOptions){
+    return new JsObjBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+const BaseOutputBuilder = require("./BaseOutputBuilder");
+const rootName = '^';
+
+class JsObjBuilder extends BaseOutputBuilder{
+
+  constructor(parserOptions, builderOptions,registeredParsers) {
+    super();
+    //hold the raw detail of a tag and sequence with reference to the output
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = builderOptions;
+    this.registeredParsers = registeredParsers;
+
+    this.root = {};
+    this.parent = this.root;
+    this.tagName = rootName;
+    this.value = {};
+    this.textValue = "";
+    this.attributes = {};
+  }
+
+  addTag(tag){
+
+    let value = "";
+    if( !isEmpty(this.attributes)){
+      value = {};
+      if(this.options.attributes.groupBy){
+        value[this.options.attributes.groupBy] = this.attributes;
+      }else{
+        value = this.attributes;
+      }
+    }
+
+    this.tagsStack.push([this.tagName, this.textValue, this.value]); //parent tag, parent text value, parent tag value (jsobj)
+    this.tagName = tag.name;
+    this.value = value;
+    this.textValue = "";
+    this.attributes = {};
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag(){
+    const tagName = this.tagName;
+    let value = this.value;
+    let textValue = this.textValue;
+
+    //update tag text value
+    if(typeof value !== "object" && !Array.isArray(value)){
+      value = this.parseValue(textValue.trim(), this.options.tags.valueParsers);
+    }else if(textValue.length > 0){
+      value[this.options.nameFor.text] = this.parseValue(textValue.trim(), this.options.tags.valueParsers);
+    }
+
+    
+    let resultTag= {
+      tagName: tagName,
+      value: value
+    };
+
+    if(this.options.onTagClose !== undefined){
+      //TODO TagPathMatcher 
+      resultTag = this.options.onClose(tagName, value, this.textValue, new TagPathMatcher(this.tagsStack,node));
+
+      if(!resultTag) return;
+    }
+
+    //set parent node in scope
+    let arr = this.tagsStack.pop(); 
+    let parentTag = arr[2];
+    parentTag=this._addChildTo(resultTag.tagName, resultTag.value, parentTag);
+
+    this.tagName = arr[0];
+    this.textValue = arr[1];
+    this.value = parentTag;
+  }
+
+  _addChild(key, val){
+    if(typeof this.value === "string"){
+      this.value = { [this.options.nameFor.text] : this.value };
+    }
+
+    this._addChildTo(key, val, this.value);
+    // this.currentNode.leafType = false;
+    this.attributes = {};
+  }
+
+  _addChildTo(key, val, node){
+    if(typeof node === 'string') node = {};
+    if(!node[key]){
+      node[key] = val;
+    }else{ //Repeated
+      if(!Array.isArray(node[key])){ //but not stored as array
+        node[key] = [node[key]];
+      }
+      node[key].push(val);
+    }
+    return node;
+  }
+
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text){
+    //TODO: use bytes join
+    if(this.textValue.length > 0) this.textValue += " " + text;
+    else this.textValue = text;
+  }
+
+  addPi(name){
+    let value = "";
+    if( !isEmpty(this.attributes)){
+      value = {};
+      if(this.options.attributes.groupBy){
+        value[this.options.attributes.groupBy] = this.attributes;
+      }else{
+        value = this.attributes;
+      }
+    }
+    this._addChild(name, value);
+    
+  }
+  getOutput(){
+    return this.value;
+  }
+}
+
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+
+module.exports = OutputBuilder;

node_modules/fast-xml-parser/src/v5/OutputBuilders/ParserOptionsBuilder.js

@@ -0,0 +1,99 @@
+const trimParser = require("../valueParsers/trim")
+const booleanParser = require("../valueParsers/booleanParser")
+const currencyParser = require("../valueParsers/currency")
+const numberParser = require("../valueParsers/number")
+
+const defaultOptions={
+  nameFor:{
+    text: "#text",
+    comment: "",
+    cdata: "",
+  },
+  // onTagClose: () => {},
+  // onAttribute: () => {},
+  piTag: false,
+  declaration: false, //"?xml"
+  tags: {
+    valueParsers: [
+      // "trim",
+      // "boolean",
+      // "number",
+      // "currency",
+      // "date",
+    ]
+  },
+  attributes:{
+    prefix: "@_",
+    suffix: "",
+    groupBy: "",
+    
+    valueParsers: [
+      // "trim",
+      // "boolean",
+      // "number",
+      // "currency",
+      // "date",
+    ]
+  },
+  dataType:{
+
+  }
+}
+
+//TODO
+const withJoin = ["trim","join", /*"entities",*/"number","boolean","currency"/*, "date"*/]
+const withoutJoin = ["trim", /*"entities",*/"number","boolean","currency"/*, "date"*/]
+
+function buildOptions(options){
+  //clone
+  const finalOptions = { ... defaultOptions};
+
+  //add config missed in cloning
+  finalOptions.tags.valueParsers.push(...withJoin)
+  if(!this.preserveOrder)
+    finalOptions.tags.valueParsers.push(...withoutJoin);
+
+  //add config missed in cloning
+  finalOptions.attributes.valueParsers.push(...withJoin)
+
+  //override configuration
+  copyProperties(finalOptions,options);
+  return finalOptions;
+}
+
+function copyProperties(target, source) {
+  for (let key in source) {
+    if (source.hasOwnProperty(key)) {
+      if (typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        // Recursively copy nested properties
+        if (typeof target[key] === 'undefined') {
+          target[key] = {};
+        }
+        copyProperties(target[key], source[key]);
+      } else {
+        // Copy non-nested properties
+        target[key] = source[key];
+      }
+    }
+  }
+}
+
+function registerCommonValueParsers(options){
+  return {
+    "trim": new trimParser(),
+    // "join": this.entityParser.parse,
+    "boolean": new booleanParser(),
+    "number": new numberParser({
+          hex: true,
+          leadingZeros: true,
+          eNotation: true
+        }),
+    "currency": new currencyParser(),
+    // "date": this.entityParser.parse,
+  }
+}
+
+module.exports = {
+  buildOptions : buildOptions,
+  registerCommonValueParsers: registerCommonValueParsers
+}

node_modules/fast-xml-parser/src/v5/TagPath.js

@@ -0,0 +1,81 @@
+class TagPath{
+  constructor(pathStr){
+    let text = "";
+    let tName = "";
+    let pos;
+    let aName = "";
+    let aVal = "";
+    this.stack = []
+
+    for (let i = 0; i < pathStr.length; i++) {
+      let ch = pathStr[i];
+      if(ch === " ") {
+        if(text.length === 0) continue;        
+        tName = text; text = "";
+      }else if(ch === "["){
+        if(tName.length === 0){
+          tName = text; text = "";
+        }
+        i++;
+        for (; i < pathStr.length; i++) {
+          ch = pathStr[i];
+          if(ch=== "=") continue;
+          else if(ch=== "]") {aName = text.trim(); text=""; break; i--;}
+          else if(ch === "'" || ch === '"'){
+            let attrEnd = pathStr.indexOf(ch,i+1);
+            aVal = pathStr.substring(i+1, attrEnd);
+            i = attrEnd;
+          }else{
+            text +=ch;
+          }
+        }
+      }else if(ch !== " " && text.length === 0 && tName.length > 0){//reading tagName
+        //save previous tag
+        this.stack.push(new TagPathNode(tName,pos,aName,aVal));
+        text = ch; tName = ""; aName = ""; aVal = "";
+      }else{
+        text+=ch;
+      }
+    }
+
+    //last tag in the path
+    if(tName.length >0 || text.length>0){
+      this.stack.push(new TagPathNode(text||tName,pos,aName,aVal));
+    }
+  }
+
+  match(tagStack,node){
+    if(this.stack[0].name !== "*"){
+      if(this.stack.length !== tagStack.length +1) return false;
+  
+      //loop through tagPath and tagStack and match
+      for (let i = 0; i < this.tagStack.length; i++) {
+        if(!this.stack[i].match(tagStack[i])) return false;
+      }
+    }
+    if(!this.stack[this.stack.length - 1].match(node)) return false;
+    return true;
+  }
+}
+
+class TagPathNode{
+  constructor(name,position,attrName,attrVal){
+    this.name = name;
+    this.position = position;
+    this.attrName = attrName,
+    this.attrVal = attrVal;
+  }
+
+  match(node){
+    let matching = true;
+    matching = node.name === this.name;
+    if(this.position) matching = node.position === this.position;
+    if(this.attrName) matching = node.attrs[this.attrName !== undefined];
+    if(this.attrVal) matching = node.attrs[this.attrName !== this.attrVal];
+    return matching;
+  }
+}
+
+// console.log((new TagPath("* b[b]")).stack);
+// console.log((new TagPath("a[a] b[b] c")).stack);
+// console.log((new TagPath(" b [ b= 'cf  sdadwa' ] a  ")).stack);

node_modules/fast-xml-parser/src/v5/TagPathMatcher.js

@@ -0,0 +1,15 @@
+const TagPath = require("./TagPath");
+
+class TagPathMatcher{
+  constructor(stack,node){
+    this.stack = stack;
+    this.node= node;
+  }
+
+  match(path){
+    const tagPath = new TagPath(path);
+    return tagPath.match(this.stack, this.node);
+  }
+}
+
+module.exports = TagPathMatcher;

node_modules/fast-xml-parser/src/v5/XMLParser.js

@@ -0,0 +1,85 @@
+const { buildOptions} = require("./OptionsBuilder");
+const Xml2JsParser = require("./Xml2JsParser");
+
+class XMLParser{
+    
+    constructor(options){
+        this.externalEntities = {};
+        this.options = buildOptions(options);
+        // console.log(this.options)
+    }
+    /**
+     * Parse XML data string to JS object 
+     * @param {string|Buffer} xmlData 
+     * @param {boolean|Object} validationOption 
+     */
+    parse(xmlData){
+        if(Array.isArray(xmlData) && xmlData.byteLength !== undefined){
+            return this.parse(xmlData);
+        }else if( xmlData.toString){
+            xmlData = xmlData.toString();
+        }else{
+            throw new Error("XML data is accepted in String or Bytes[] form.")
+        }
+        // if( validationOption){
+        //     if(validationOption === true) validationOption = {}; //validate with default options
+            
+        //     const result = validator.validate(xmlData, validationOption);
+        //     if (result !== true) {
+        //       throw Error( `${result.err.msg}:${result.err.line}:${result.err.col}` )
+        //     }
+        //   }
+        const parser = new Xml2JsParser(this.options);
+        parser.entityParser.addExternalEntities(this.externalEntities);
+        return parser.parse(xmlData);
+    }
+    /**
+     * Parse XML data buffer to JS object 
+     * @param {string|Buffer} xmlData 
+     * @param {boolean|Object} validationOption 
+     */
+    parseBytesArr(xmlData){
+        if(Array.isArray(xmlData) && xmlData.byteLength !== undefined){
+        }else{
+            throw new Error("XML data is accepted in Bytes[] form.")
+        }
+        const parser = new Xml2JsParser(this.options);
+        parser.entityParser.addExternalEntities(this.externalEntities);
+        return parser.parseBytesArr(xmlData);
+    }
+    /**
+     * Parse XML data stream to JS object 
+     * @param {fs.ReadableStream} xmlDataStream 
+     */
+    parseStream(xmlDataStream){
+        if(!isStream(xmlDataStream)) throw new Error("FXP: Invalid stream input");
+        
+        const orderedObjParser = new Xml2JsParser(this.options);
+        orderedObjParser.entityParser.addExternalEntities(this.externalEntities);
+        return orderedObjParser.parseStream(xmlDataStream);
+    }
+
+    /**
+     * 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 if(value === "&"){
+            throw new Error("An entity with value '&' is not permitted");
+        }else{
+            this.externalEntities[key] = value;
+        }
+    }
+}
+
+function isStream(stream){
+    if(stream && typeof stream.read === "function" && typeof stream.on === "function" && typeof stream.readableEnded === "boolean") return true;
+    return false;
+}
+
+module.exports = XMLParser;

node_modules/fast-xml-parser/src/v5/Xml2JsParser.js

@@ -0,0 +1,237 @@
+const StringSource = require("./inputSource/StringSource");
+const BufferSource = require("./inputSource/BufferSource");
+const {readTagExp,readClosingTagName} = require("./XmlPartReader");
+const {readComment, readCdata,readDocType,readPiTag} = require("./XmlSpecialTagsReader");
+const TagPath = require("./TagPath");
+const TagPathMatcher = require("./TagPathMatcher");
+const EntitiesParser = require('./EntitiesParser');
+
+//To hold the data of current tag
+//This is usually used to compare jpath expression against current tag
+class TagDetail{
+  constructor(name){
+    this.name = name;
+    this.position = 0;
+    // this.attributes = {};
+  }
+}
+
+class Xml2JsParser {
+    constructor(options) {
+      this.options = options;
+      
+      this.currentTagDetail = null;
+      this.tagTextData = "";
+      this.tagsStack = [];
+      this.entityParser = new EntitiesParser(options.htmlEntities);
+      this.stopNodes = [];
+      for (let i = 0; i < this.options.stopNodes.length; i++) {
+        this.stopNodes.push(new TagPath(this.options.stopNodes[i]));
+      }
+    }
+
+    parse(strData) {
+        this.source = new StringSource(strData);
+        this.parseXml();
+        return this.outputBuilder.getOutput();
+    }
+    parseBytesArr(data) {
+        this.source = new BufferSource(data );
+        this.parseXml();
+        return this.outputBuilder.getOutput();
+    }
+  
+    parseXml() {
+      //TODO: Separate TagValueParser as separate class. So no scope issue in node builder class 
+
+      //OutputBuilder should be set in XML Parser
+      this.outputBuilder = this.options.OutputBuilder.getInstance(this.options);
+      this.root = { root: true};
+      this.currentTagDetail = this.root;
+
+      while(this.source.canRead()){
+        let ch = this.source.readCh();
+        if (ch === "") break;
+        
+        if(ch === "<"){//tagStart
+          let nextChar = this.source.readChAt(0);
+          if (nextChar === "" ) throw new Error("Unexpected end of source");
+          
+        
+          if(nextChar === "!" || nextChar === "?"){
+            this.source.updateBufferBoundary();
+            //previously collected text should be added to current node
+            this.addTextNode(); 
+            
+            this.readSpecialTag(nextChar);// Read DOCTYPE, comment, CDATA, PI tag
+          }else if(nextChar === "/"){
+            this.source.updateBufferBoundary();
+            this.readClosingTag();
+            // console.log(this.source.buffer.length, this.source.readable);
+            // console.log(this.tagsStack.length);
+          }else{//opening tag
+            this.readOpeningTag();
+          }
+        }else{
+          this.tagTextData += ch;
+        }
+      }//End While loop
+      if(this.tagsStack.length > 0 || ( this.tagTextData !== "undefined" && this.tagTextData.trimEnd().length > 0) ) throw new Error("Unexpected data in the end of document");
+    }
+  
+    /**
+     * read closing paired tag. Set parent tag in scope.
+     * skip a node on user's choice
+     */
+    readClosingTag(){
+      const tagName = this.processTagName(readClosingTagName(this.source));
+      // console.log(tagName, this.tagsStack.length);
+      this.validateClosingTag(tagName);
+      // All the text data collected, belongs to current tag.
+      if(!this.currentTagDetail.root) this.addTextNode();
+      this.outputBuilder.closeTag();
+      // Since the tag is closed now, parent tag comes in scope
+      this.currentTagDetail = this.tagsStack.pop(); 
+    }
+
+    validateClosingTag(tagName){
+      // This can't be unpaired tag, or a stop tag.
+      if(this.isUnpaired(tagName) || this.isStopNode(tagName)) throw new Error(`Unexpected closing tag '${tagName}'`);
+      // This must match with last opening tag
+      else if(tagName !== this.currentTagDetail.name) 
+        throw new Error(`Unexpected closing tag '${tagName}' expecting '${this.currentTagDetail.name}'`)
+    }
+
+    /**
+     * Read paired, unpaired, self-closing, stop and special tags.
+     * Create a new node
+     * Push paired tag in stack.
+     */
+    readOpeningTag(){
+      //save previously collected text data to current node
+      this.addTextNode();
+
+      //create new tag
+      let tagExp = readTagExp(this, ">" );
+      
+      // process and skip from tagsStack For unpaired tag, self closing tag, and stop node
+      const tagDetail = new TagDetail(tagExp.tagName);
+      if(this.isUnpaired(tagExp.tagName)) {
+        //TODO: this will lead 2 extra stack operation
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.closeTag();
+      } else if(tagExp.selfClosing){
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.closeTag();
+      } else if(this.isStopNode(this.currentTagDetail)){
+        // TODO: let's user set a stop node boundary detector for complex contents like script tag
+        //TODO: pass tag name only to avoid string operations
+        const content = source.readUptoCloseTag(`</${tagExp.tagName}`);
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.addValue(content);
+        this.outputBuilder.closeTag();
+      }else{//paired tag
+        //set new nested tag in scope.
+        this.tagsStack.push(this.currentTagDetail);
+        this.outputBuilder.addTag(tagDetail);
+        this.currentTagDetail = tagDetail;
+      }
+      // console.log(tagExp.tagName,this.tagsStack.length);
+      // this.options.onClose()
+
+    }
+
+    readSpecialTag(startCh){
+      if(startCh == "!"){
+        let nextChar = this.source.readCh();
+        if (nextChar === null || nextChar === undefined) throw new Error("Unexpected ending of the source");
+        
+        if(nextChar === "-"){//comment
+          readComment(this);
+        }else if(nextChar === "["){//CDATA
+          readCdata(this);
+        }else if(nextChar === "D"){//DOCTYPE
+          readDocType(this);
+        }
+      }else if(startCh === "?"){
+        readPiTag(this);
+      }else{
+        throw new Error(`Invalid tag '<${startCh}' at ${this.source.line}:${this.source.col}`)
+      }
+    }
+    addTextNode = function() {
+      // if(this.currentTagDetail){
+        //save text as child node
+        // if(this.currentTagDetail.tagname !== '!xml')
+        if (this.tagTextData !== undefined && this.tagTextData !== "") { //store previously collected data as textNode
+          if(this.tagTextData.trim().length > 0){
+            //TODO: shift parsing to output builder
+
+            this.outputBuilder.addValue(this.replaceEntities(this.tagTextData));
+          }
+          this.tagTextData = "";
+        }
+      // }
+    }
+
+    processAttrName(name){
+      if(name === "__proto__") name  = "#__proto__";
+      name = resolveNameSpace(name, this.removeNSPrefix);
+      return name;
+    }
+    
+    processTagName(name){
+      if(name === "__proto__") name  = "#__proto__";
+      name = resolveNameSpace(name, this.removeNSPrefix);
+      return name;
+    }
+
+    /**
+     * Generate tags path from tagsStack
+     */
+    tagsPath(tagName){
+      //TODO: return TagPath Object. User can call match method with path
+      return "";
+    }
+
+    isUnpaired(tagName){
+      return this.options.tags.unpaired.indexOf(tagName) !== -1;
+    }
+
+    /**
+     * valid expressions are 
+     * tag nested
+     * * nested
+     * tag nested[attribute]
+     * tag nested[attribute=""]
+     * tag nested[attribute!=""]
+     * tag nested:0 //for future
+     * @param {string} tagName 
+     * @returns 
+     */
+    isStopNode(node){
+      for (let i = 0; i < this.stopNodes.length; i++) {
+        const givenPath = this.stopNodes[i];
+        if(givenPath.match(this.tagsStack, node)) return true;
+      }
+      return false 
+    }
+
+    replaceEntities(text){
+      //TODO: if option is set then replace entities
+      return this.entityParser.parse(text)
+    }
+}
+
+function resolveNameSpace(name, removeNSPrefix) {
+  if (removeNSPrefix) {
+    const parts = name.split(':');
+    if(parts.length === 2){
+      if (parts[0] === 'xmlns') return '';
+      else return parts[1];
+    }else reportError(`Multiple namespaces ${name}`)
+  }
+  return name;
+}
+
+module.exports = Xml2JsParser;

node_modules/fast-xml-parser/src/v5/XmlPartReader.js

@@ -0,0 +1,216 @@
+'use strict';
+
+/**
+ * find paired tag for a stop node
+ * @param {string} xmlDoc
+ * @param {string} tagName
+ * @param {number} i : start index
+ */
+function readStopNode(xmlDoc, tagName, i){
+    const startIndex = i;
+    // Starting at 1 since we already have an open tag
+    let openTagCount = 1;
+
+    for (; i < xmlDoc.length; i++) {
+      if( xmlDoc[i] === "<"){
+        if (xmlDoc[i+1] === "/") {//close tag
+            const closeIndex = findSubStrIndex(xmlDoc, ">", i, `${tagName} is not closed`);
+            let closeTagName = xmlDoc.substring(i+2,closeIndex).trim();
+            if(closeTagName === tagName){
+              openTagCount--;
+              if (openTagCount === 0) {
+                return {
+                  tagContent: xmlDoc.substring(startIndex, i),
+                  i : closeIndex
+                }
+              }
+            }
+            i=closeIndex;
+          } else if(xmlDoc[i+1] === '?') {
+            const closeIndex = findSubStrIndex(xmlDoc, "?>", i+1, "StopNode is not closed.")
+            i=closeIndex;
+          } else if(xmlDoc.substr(i + 1, 3) === '!--') {
+            const closeIndex = findSubStrIndex(xmlDoc, "-->", i+3, "StopNode is not closed.")
+            i=closeIndex;
+          } else if(xmlDoc.substr(i + 1, 2) === '![') {
+            const closeIndex = findSubStrIndex(xmlDoc, "]]>", i, "StopNode is not closed.") - 2;
+            i=closeIndex;
+          } else {
+            const tagData = readTagExp(xmlDoc, i, '>')
+
+            if (tagData) {
+              const openTagName = tagData && tagData.tagName;
+              if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length-1] !== "/") {
+                openTagCount++;
+              }
+              i=tagData.closeIndex;
+            }
+          }
+        }
+    }//end for loop
+}
+
+/**
+ * Read closing tag name
+ * @param {Source} source
+ * @returns tag name
+ */
+function readClosingTagName(source){
+  let text = ""; //temporary data
+  while(source.canRead()){
+    let ch = source.readCh();
+    // if (ch === null || ch === undefined) break;
+    // source.updateBuffer();
+
+    if (ch === ">") return text.trimEnd();
+    else text += ch;
+  }
+  throw new Error(`Unexpected end of source. Reading '${substr}'`);
+}
+
+/**
+ * Read XML tag and build attributes map
+ * This function can be used to read normal tag, pi tag.
+ * This function can't be used to read comment, CDATA, DOCTYPE.
+ * Eg <tag attr = ' some"' attr= ">" bool>
+ * @param {string} xmlDoc
+ * @param {number} startIndex starting index
+ * @returns tag expression includes tag name & attribute string
+ */
+function readTagExp(parser) {
+  let inSingleQuotes = false;
+  let inDoubleQuotes = false;
+  let i;
+  let EOE = false;
+
+  for (i = 0; parser.source.canRead(i); i++) {
+    const char = parser.source.readChAt(i);
+
+    if (char === "'" && !inDoubleQuotes) {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (char === '"' && !inSingleQuotes) {
+      inDoubleQuotes = !inDoubleQuotes;
+    } else if (char === '>' && !inSingleQuotes && !inDoubleQuotes) {
+      // If not inside quotes, stop reading at '>'
+      EOE = true;
+      break;
+    }
+
+  }
+  if(inSingleQuotes || inDoubleQuotes){
+    throw new Error("Invalid attribute expression. Quote is not properly closed");
+  }else if(!EOE) throw new Error("Unexpected closing of source. Waiting for '>'");
+
+
+  const exp = parser.source.readStr(i);
+  parser.source.updateBufferBoundary(i + 1);
+  return buildTagExpObj(exp, parser)
+}
+
+function readPiExp(parser) {
+  let inSingleQuotes = false;
+  let inDoubleQuotes = false;
+  let i;
+  let EOE = false;
+
+  for (i = 0; parser.source.canRead(i) ; i++) {
+    const currentChar = parser.source.readChAt(i);
+    const nextChar =  parser.source.readChAt(i+1);
+
+    if (currentChar === "'" && !inDoubleQuotes) {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (currentChar === '"' && !inSingleQuotes) {
+      inDoubleQuotes = !inDoubleQuotes;
+    }
+
+    if (!inSingleQuotes && !inDoubleQuotes) {
+      if (currentChar === '?' && nextChar === '>') {
+        EOE = true;
+        break; // Exit the loop when '?>' is found
+      }
+    }
+  }
+  if(inSingleQuotes || inDoubleQuotes){
+    throw new Error("Invalid attribute expression. Quote is not properly closed in PI tag expression");
+  }else if(!EOE) throw new Error("Unexpected closing of source. Waiting for '?>'");
+
+  if(!parser.options.attributes.ignore){
+    //TODO: use regex to verify attributes if not set to ignore
+  }
+
+  const exp = parser.source.readStr(i);
+  parser.source.updateBufferBoundary(i + 1);
+  return buildTagExpObj(exp, parser)
+}
+
+function buildTagExpObj(exp, parser){
+  const tagExp = {
+    tagName: "",
+    selfClosing: false
+  };
+  let attrsExp = "";
+
+  // Check for self-closing tag before setting the name
+  if(exp[exp.length -1] === "/") {
+    tagExp.selfClosing = true;
+    exp = exp.slice(0, -1); // Remove the trailing slash
+  }
+
+  //separate tag name
+  let i = 0;
+  for (; i < exp.length; i++) {
+    const char = exp[i];
+    if(char === " "){
+      tagExp.tagName = exp.substring(0, i);
+      attrsExp = exp.substring(i + 1);
+      break;
+    }
+  }
+  //only tag
+  if(tagExp.tagName.length === 0 && i === exp.length)tagExp.tagName = exp;
+
+  tagExp.tagName = tagExp.tagName.trimEnd();
+
+  if(!parser.options.attributes.ignore && attrsExp.length > 0){
+    parseAttributesExp(attrsExp,parser)
+  }
+
+  return tagExp;
+}
+
+const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
+
+function parseAttributesExp(attrStr, parser) {
+  const matches = getAllMatches(attrStr, attrsRegx);
+  const len = matches.length; //don't make it inline
+  for (let i = 0; i < len; i++) {
+    let attrName = parser.processAttrName(matches[i][1]);
+    let attrVal = parser.replaceEntities(matches[i][4] || true);
+
+    parser.outputBuilder.addAttribute(attrName, attrVal);
+  }
+}
+
+
+const getAllMatches = function(string, regex) {
+  const matches = [];
+  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]);
+    }
+    matches.push(allmatches);
+    match = regex.exec(string);
+  }
+  return matches;
+};
+
+module.exports = {
+    readStopNode: readStopNode,
+    readClosingTagName: readClosingTagName,
+    readTagExp: readTagExp,
+    readPiExp: readPiExp,
+}

node_modules/fast-xml-parser/src/v5/XmlSpecialTagsReader.js

@@ -0,0 +1,118 @@
+const {readPiExp} = require("./XmlPartReader");
+
+function readCdata(parser){
+  //<![ are already read till this point
+  let str = parser.source.readStr(6); //CDATA[
+  parser.source.updateBufferBoundary(6);
+
+  if(str !== "CDATA[") throw new Error(`Invalid CDATA expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let text = parser.source.readUpto("]]>");
+  parser.outputBuilder.addCdata(text);
+}
+function readPiTag(parser){
+  //<? are already read till this point
+  let tagExp = readPiExp(parser, "?>");
+  if(!tagExp) throw new Error("Invalid Pi Tag expression.");
+
+  if (tagExp.tagName === "?xml") {//TODO: test if tagName is just xml
+    parser.outputBuilder.addDeclaration();
+  } else {
+    parser.outputBuilder.addPi("?"+tagExp.tagName);
+  }
+}
+
+function readComment(parser){
+  //<!- are already read till this point
+  let ch = parser.source.readCh();
+  if(ch !== "-") throw new Error(`Invalid comment expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let text = parser.source.readUpto("-->");
+  parser.outputBuilder.addComment(text);
+}
+
+const DOCTYPE_tags = {
+  "EL":/^EMENT\s+([^\s>]+)\s+(ANY|EMPTY|\(.+\)\s*$)/m,
+  "AT":/^TLIST\s+[^\s]+\s+[^\s]+\s+[^\s]+\s+[^\s]+\s+$/m,
+  "NO":/^TATION.+$/m
+}
+function readDocType(parser){
+  //<!D are already read till this point
+  let str = parser.source.readStr(6); //OCTYPE
+  parser.source.updateBufferBoundary(6);
+
+  if(str !== "OCTYPE") throw new Error(`Invalid DOCTYPE expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let hasBody = false, lastch = "";
+
+  while(parser.source.canRead()){
+    //TODO: use readChAt like used in partReader
+    let ch = parser.source.readCh();
+    if(hasBody){
+      if (ch === '<') { //Determine the tag type
+        let str = parser.source.readStr(2);
+        parser.source.updateBufferBoundary(2);
+        if(str === "EN"){ //ENTITY
+          let str = parser.source.readStr(4);
+          parser.source.updateBufferBoundary(4);
+          if(str !== "TITY") throw new Error("Invalid DOCTYPE ENTITY expression");
+
+          registerEntity(parser);
+        }else if(str === "!-") {//comment
+          readComment(parser);
+        }else{ //ELEMENT, ATTLIST, NOTATION
+          let dTagExp = parser.source.readUpto(">");
+          const regx = DOCTYPE_tags[str];
+          if(regx){
+            const match = dTagExp.match(regx);
+            if(!match) throw new Error("Invalid DOCTYPE");
+          }else throw new Error("Invalid DOCTYPE");
+        }
+      }else if( ch === '>' && lastch === "]"){//end of doctype
+        return;  
+      }
+    }else if( ch === '>'){//end of doctype
+      return;
+    }else if( ch === '['){
+      hasBody = true;
+    }else{
+      lastch = ch;
+    }
+  }//End While loop
+
+}
+
+function registerEntity(parser){
+  //read Entity
+  let attrBoundary="";
+  let name ="", val ="";
+  while(source.canRead()){
+    let ch = source.readCh();
+
+    if(attrBoundary){
+      if (ch === attrBoundary){
+        val = text;
+        text = ""
+      }
+    }else if(ch === " " || ch === "\t"){
+      if(!name){
+        name = text.trimStart();
+        text = "";
+      }
+    }else if (ch === '"' || ch === "'") {//start of attrBoundary
+      attrBoundary = ch;
+    }else if(ch === ">"){
+      parser.entityParser.addExternalEntity(name,val);
+      return;
+    }else{
+      text+=ch;
+    }
+  }
+}
+
+module.exports = {
+  readCdata: readCdata,
+  readComment:readComment,
+  readDocType:readDocType,
+  readPiTag:readPiTag
+}

node_modules/fast-xml-parser/src/v5/inputSource/BufferSource.js

@@ -0,0 +1,118 @@
+const Constants = {
+  space: 32,
+  tab: 9
+}
+class BufferSource{
+  constructor(bytesArr){
+    this.line = 1;
+    this.cols = 0;
+    this.buffer = bytesArr;
+    this.startIndex = 0;
+  }
+
+
+
+  readCh() {
+    return String.fromCharCode(this.buffer[this.startIndex++]);
+  }
+
+  readChAt(index) {
+    return String.fromCharCode(this.buffer[this.startIndex+index]);
+  }
+
+  readStr(n,from){
+    if(typeof from === "undefined") from = this.startIndex;
+    return this.buffer.slice(from, from + n).toString();
+  }
+
+  readUpto(stopStr) {
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    const stopBuffer = Buffer.from(stopStr);
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+        let match = true;
+        for (let j = 0; j < stopLength; j++) {
+            if (this.buffer[i + j] !== stopBuffer[j]) {
+                match = false;
+                break;
+            }
+        }
+
+        if (match) {
+            const result = this.buffer.slice(this.startIndex, i).toString();
+            this.startIndex = i + stopLength;
+            return result;
+        }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+}
+
+readUptoCloseTag(stopStr) { //stopStr: "</tagname"
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    const stopBuffer = Buffer.from(stopStr);
+    let stopIndex = 0;
+    //0: non-matching, 1: matching stop string, 2: matching closing
+    let match = 0;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+        if(match === 1){//initial part matched
+            if(stopIndex === 0) stopIndex = i;
+            if(this.buffer[i] === Constants.space || this.buffer[i] === Constants.tab) continue;
+            else if(this.buffer[i] === '>'){ //TODO: if it should be equivalent ASCII
+                match = 2;
+                //tag boundary found
+                // this.startIndex
+            }
+        }else{
+            match = 1;
+            for (let j = 0; j < stopLength; j++) {
+                if (this.buffer[i + j] !== stopBuffer[j]) {
+                    match = 0;
+                    break;
+                }
+            }
+        }
+        if (match === 2) {//matched closing part
+            const result = this.buffer.slice(this.startIndex, stopIndex - 1 ).toString();
+            this.startIndex = i + 1;
+            return result;
+        }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+}
+
+  readFromBuffer(n, shouldUpdate) {
+    let ch;
+    if (n === 1) {
+      ch = this.buffer[this.startIndex];
+      if (ch === 10) {
+        this.line++;
+        this.cols = 1;
+      } else {
+        this.cols++;
+      }
+      ch = String.fromCharCode(ch);
+    } else {
+      this.cols += n;
+      ch = this.buffer.slice(this.startIndex, this.startIndex + n).toString();
+    }
+    if (shouldUpdate) this.updateBuffer(n);
+    return ch;
+  }
+
+  updateBufferBoundary(n = 1) { //n: number of characters read
+    this.startIndex += n;
+  }
+
+  canRead(n){
+    n = n || this.startIndex;
+    return this.buffer.length - n + 1 > 0;
+  }
+  
+}
+
+module.exports = BufferSource;

node_modules/fast-xml-parser/src/v5/inputSource/StringSource.js

@@ -0,0 +1,123 @@
+const whiteSpaces = [" ", "\n", "\t"];
+
+
+class StringSource{
+  constructor(str){
+    this.line = 1;
+    this.cols = 0;
+    this.buffer = str;
+    //a boundary pointer to indicate where from the buffer dat should be read
+    // data before this pointer can be deleted to free the memory
+    this.startIndex = 0;
+  }
+
+  readCh() {
+    return this.buffer[this.startIndex++];
+  }
+
+  readChAt(index) {
+    return this.buffer[this.startIndex+index];
+  }
+
+  readStr(n,from){
+    if(typeof from === "undefined") from = this.startIndex;
+    return this.buffer.substring(from, from + n);
+  }
+
+  readUpto(stopStr) {
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+      let match = true;
+      for (let j = 0; j < stopLength; j++) {
+        if (this.buffer[i + j] !== stopStr[j]) {
+          match = false;
+          break;
+        }
+      }
+
+      if (match) {
+        const result = this.buffer.substring(this.startIndex, i);
+        this.startIndex = i + stopLength;
+        return result;
+      }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+  }
+
+  readUptoCloseTag(stopStr) { //stopStr: "</tagname"
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    let stopIndex = 0;
+    //0: non-matching, 1: matching stop string, 2: matching closing
+    let match = 0;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+      if(match === 1){//initial part matched
+        if(stopIndex === 0) stopIndex = i;
+        if(this.buffer[i] === ' ' || this.buffer[i] === '\t') continue;
+        else if(this.buffer[i] === '>'){
+          match = 2;
+          //tag boundary found
+          // this.startIndex
+        }
+      }else{
+        match = 1;
+        for (let j = 0; j < stopLength; j++) {
+          if (this.buffer[i + j] !== stopStr[j]) {
+            match = 0;
+            break;
+          }
+        }
+      }
+      if (match === 2) {//matched closing part
+        const result = this.buffer.substring(this.startIndex, stopIndex - 1 );
+        this.startIndex = i + 1;
+        return result;
+      }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+  }
+
+  readFromBuffer(n, updateIndex){
+    let ch;
+    if(n===1){
+      ch = this.buffer[this.startIndex];
+      // if(ch === "\n") {
+      //   this.line++;
+      //   this.cols = 1;
+      // }else{
+      //   this.cols++;
+      // }
+    }else{
+      ch = this.buffer.substring(this.startIndex, this.startIndex + n);
+      // if("".indexOf("\n") !== -1){
+      //   //TODO: handle the scenario when there are multiple lines
+      //   //TODO: col should be set to number of chars after last '\n'
+      //   // this.cols = 1;
+      // }else{
+      //   this.cols += n;
+
+      // }
+    }
+    if(updateIndex) this.updateBufferBoundary(n);
+    return ch;
+  }
+
+  //TODO: rename to updateBufferReadIndex
+  
+  updateBufferBoundary(n = 1) { //n: number of characters read
+    this.startIndex += n;
+  }
+
+  canRead(n){
+    n = n || this.startIndex;
+    return this.buffer.length - n + 1 > 0;
+  }
+  
+}
+
+module.exports = StringSource;

node_modules/fast-xml-parser/src/v5/valueParsers/EntitiesParser.js

@@ -0,0 +1,107 @@
+const ampEntity = { regex: /&(amp|#38|#x26);/g, val : "&"};
+const 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: "₹" },
+    "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 10)) },
+    "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 16)) },
+};
+
+class EntitiesParser{
+    constructor(replaceHtmlEntities) {
+      this.replaceHtmlEntities = replaceHtmlEntities;
+      this.docTypeEntities = {};
+      this.lastEntities = {
+        "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 : "\""},
+      };
+    }
+
+    addExternalEntities(externalEntities){
+        const entKeys = Object.keys(externalEntities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.addExternalEntity(ent,externalEntities[ent])
+        }
+    }
+    addExternalEntity(key,val){
+      validateEntityName(key);
+      if(val.indexOf("&") !== -1) {
+        reportWarning(`Entity ${key} is not added as '&' is found in value;`)
+        return;
+      }else{
+        this.lastEntities[ent] = {
+          regex: new RegExp("&"+key+";","g"),
+          val : val
+        }
+      }
+    }
+
+    addDocTypeEntities(entities){
+        const entKeys = Object.keys(entities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.docTypeEntities[ent] = {
+             regex: new RegExp("&"+ent+";","g"),
+             val : entities[ent]
+          }
+        }
+    }
+
+    parse(val){
+        return this.replaceEntitiesValue(val)
+    }
+
+    /**
+     * 1. Replace DOCTYPE entities 
+     * 2. Replace external entities 
+     * 3. Replace HTML entities if asked
+     * @param {string} val 
+     */
+    replaceEntitiesValue(val){
+        if(typeof val === "string" && val.length > 0){
+            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.replaceHtmlEntities){
+                for(let entityName in htmlEntities){
+                  const entity = htmlEntities[entityName];
+                  val = val.replace( entity.regex, entity.val);
+                }
+              }
+            val = val.replace( ampEntity.regex, ampEntity.val);
+        }
+        return val;
+    }
+};
+
+//an entity name should not contains special characters that may be used in regex
+//Eg !?\\\/[]$%{}^&*()<>
+const specialChar = "!?\\\/[]$%{}^&*()<>|+";
+
+function validateEntityName(name){
+    for (let i = 0; i < specialChar.length; i++) {
+        const ch = specialChar[i];
+        if(name.indexOf(ch) !== -1) throw new Error(`Invalid character ${ch} in entity name`);
+    }
+    return name;
+}
+
+module.exports = EntitiesParser;

node_modules/fast-xml-parser/src/v5/valueParsers/booleanParser.js

@@ -0,0 +1,23 @@
+class boolParser{
+    constructor(trueList, falseList){
+        if(trueList)
+            this.trueList = trueList;
+        else
+            this.trueList = ["true"];
+        
+        if(falseList)
+            this.falseList = falseList;
+        else
+            this.falseList = ["false"];
+    }
+    parse(val){
+        if (typeof val === 'string') {
+            //TODO: performance: don't convert
+            const temp = val.toLowerCase();
+            if(this.trueList.indexOf(temp) !== -1) return true;
+            else if(this.falseList.indexOf(temp) !== -1 ) return false;
+        }
+        return val;
+    }
+}
+module.exports = boolParser;

node_modules/fast-xml-parser/src/v5/valueParsers/booleanParserExt.js

@@ -0,0 +1,20 @@
+function boolParserExt(val){
+    if(isArray(val)){
+        for (let i = 0; i < val.length; i++) {
+            val[i] = parse(val[i])
+        }
+    }else{
+        val = parse(val)
+    }
+    return val;
+}
+
+function parse(val){
+    if (typeof val === 'string') {
+        const temp = val.toLowerCase();
+        if(temp === 'true' || temp ==="yes" || temp==="1") return true;
+        else if(temp === 'false' || temp ==="no" || temp==="0") return false;
+    }
+    return val;
+}
+module.exports = boolParserExt;

node_modules/fast-xml-parser/src/v5/valueParsers/currency.js

@@ -0,0 +1,40 @@
+const defaultOptions = {
+    maxLength: 200,
+    // locale: "en-IN"
+}
+const localeMap = {
+    "$":"en-US",
+    "€":"de-DE",
+    "£":"en-GB",
+    "¥":"ja-JP",
+    "₹":"en-IN",
+}
+const sign = "(?:-|\+)?";
+const digitsAndSeparator = "(?:\d+|\d{1,3}(?:,\d{3})+)";
+const decimalPart = "(?:\.\d{1,2})?";
+const symbol = "(?:\$|€|¥|₹)?";
+
+const currencyCheckRegex = /^\s*(?:-|\+)?(?:\d+|\d{1,3}(?:,\d{3})+)?(?:\.\d{1,2})?\s*(?:\$|€|¥|₹)?\s*$/u;
+
+class CurrencyParser{
+    constructor(options){
+        this.options = options || defaultOptions;
+    }
+    parse(val){
+        if (typeof val === 'string' && val.length <= this.options.maxLength) {
+            if(val.indexOf(",,") !== -1 && val.indexOf(".." !== -1)){
+                const match = val.match(currencyCheckRegex);
+                if(match){
+                    const locale = this.options.locale || localeMap[match[2]||match[5]||"₹"];
+                    const formatter = new Intl.NumberFormat(locale)
+                    val = val.replace(/[^0-9,.]/g, '').trim();
+                    val = Number(val.replace(formatter.format(1000)[1], ''));
+                }
+            }
+        }
+        return val;
+    }
+}
+CurrencyParser.defaultOptions = defaultOptions;
+
+module.exports = CurrencyParser;

node_modules/fast-xml-parser/src/v5/valueParsers/join.js

@@ -0,0 +1,14 @@
+/**
+ * 
+ * @param {array} val 
+ * @param {string} by 
+ * @returns 
+ */
+function join(val, by=" "){
+    if(isArray(val)){
+        val.join(by)
+    }
+    return val;
+}
+
+module.exports = join;

node_modules/fast-xml-parser/src/v5/valueParsers/number.js

@@ -0,0 +1,16 @@
+const toNumber = require("strnum");
+
+
+class numParser{
+    constructor(options){
+        this.options = options;
+    }
+    parse(val){
+        if (typeof val === 'string') {
+            val = toNumber(val,this.options);
+        }
+        return val;
+    }
+}
+
+module.exports = numParser;

node_modules/fast-xml-parser/src/v5/valueParsers/trim.js

@@ -0,0 +1,8 @@
+class trimmer{
+    parse(val){
+        if(typeof val === "string") return val.trim();
+        else return val;
+    }
+}
+
+module.exports = trimmer;

node_modules/fast-xml-parser/src/v6/CharsSymbol.js

@@ -0,0 +1,16 @@
+export default {
+  "<" : "<", //tag start
+  ">" : ">", //tag end
+  "/" : "/", //close tag
+  "!" : "!", //comment or docttype
+  "!--" : "!--", //comment
+  "-->" : "-->", //comment end
+  "?" : "?", //pi
+  "?>" : "?>", //pi end
+  "?xml" : "?xml", //pi end
+  "![" : "![", //cdata
+  "]]>" : "]]>", //cdata end
+  "[" : "[",
+  "-" : "-",
+  "D" : "D",
+}

node_modules/fast-xml-parser/src/v6/EntitiesParser.js

@@ -0,0 +1,104 @@
+const ampEntity = { regex: /&(amp|#38|#x26);/g, val : "&"};
+const 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: "₹" },
+    "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 10)) },
+    "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 16)) },
+};
+export default class EntitiesParser{
+    constructor(replaceHtmlEntities) {
+      this.replaceHtmlEntities = replaceHtmlEntities;
+      this.docTypeEntities = {};
+      this.lastEntities = {
+        "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 : "\""},
+      };
+    }
+
+    addExternalEntities(externalEntities){
+        const entKeys = Object.keys(externalEntities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.addExternalEntity(ent,externalEntities[ent])
+        }
+    }
+    addExternalEntity(key,val){
+      validateEntityName(key);
+      if(val.indexOf("&") !== -1) {
+        reportWarning(`Entity ${key} is not added as '&' is found in value;`)
+        return;
+      }else{
+        this.lastEntities[ent] = {
+          regex: new RegExp("&"+key+";","g"),
+          val : val
+        }
+      }
+    }
+
+    addDocTypeEntities(entities){
+        const entKeys = Object.keys(entities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.docTypeEntities[ent] = {
+             regex: new RegExp("&"+ent+";","g"),
+             val : entities[ent]
+          }
+        }
+    }
+
+    parse(val){
+        return this.replaceEntitiesValue(val)
+    }
+
+    /**
+     * 1. Replace DOCTYPE entities 
+     * 2. Replace external entities 
+     * 3. Replace HTML entities if asked
+     * @param {string} val 
+     */
+    replaceEntitiesValue(val){
+        if(typeof val === "string" && val.length > 0){
+            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.replaceHtmlEntities){
+                for(let entityName in htmlEntities){
+                  const entity = htmlEntities[entityName];
+                  val = val.replace( entity.regex, entity.val);
+                }
+              }
+            val = val.replace( ampEntity.regex, ampEntity.val);
+        }
+        return val;
+    }
+};
+
+//an entity name should not contains special characters that may be used in regex
+//Eg !?\\\/[]$%{}^&*()<>
+const specialChar = "!?\\\/[]$%{}^&*()<>|+";
+
+function validateEntityName(name){
+    for (let i = 0; i < specialChar.length; i++) {
+        const ch = specialChar[i];
+        if(name.indexOf(ch) !== -1) throw new Error(`Invalid character ${ch} in entity name`);
+    }
+    return name;
+}

node_modules/fast-xml-parser/src/v6/OptionsBuilder.js

@@ -0,0 +1,61 @@
+
+import {JsObjOutputBuilder} from './OutputBuilders/JsObjBuilder.js';
+
+export const defaultOptions = {
+  preserveOrder: false,
+  removeNSPrefix: false, // remove NS from tag name or attribute name if true
+  //ignoreRootElement : false,
+  stopNodes: [], //nested tags will not be parsed even for errors
+  // isArray: () => false, //User will set it
+  htmlEntities: false,
+  // skipEmptyListItem: false
+  tags:{
+    unpaired: [],
+    nameFor:{
+      cdata: false,
+      comment: false,
+      text: '#text'
+    },
+    separateTextProperty: false,
+  },
+  attributes:{
+    ignore: false,
+    booleanType: true,
+    entities: true,
+  },
+
+  // select: ["img[src]"],
+  // stop: ["anim", "[ads]"]
+  only: [], // rest tags will be skipped. It will result in flat array
+  hierarchy: false, //will be used when a particular tag is set to be parsed.
+  skip: [], // will be skipped from parse result. on('skip') will be triggered
+
+  select: [], // on('select', tag => tag ) will be called if match
+  stop: [], //given tagPath will not be parsed. innerXML will be set as string value
+  OutputBuilder: new JsObjOutputBuilder(),
+};
+   
+export const buildOptions = function(options) {
+  const finalOptions = { ... defaultOptions};
+  copyProperties(finalOptions,options)
+  return finalOptions;
+};
+
+function copyProperties(target, source) {
+  for (let key in source) {
+    if (source.hasOwnProperty(key)) {
+      if (key === 'OutputBuilder') {
+        target[key] = source[key];
+      }else if (typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        // Recursively copy nested properties
+        if (typeof target[key] === 'undefined') {
+          target[key] = {};
+        }
+        copyProperties(target[key], source[key]);
+      } else {
+        // Copy non-nested properties
+        target[key] = source[key];
+      }
+    }
+  }
+}

node_modules/fast-xml-parser/src/v6/OutputBuilders/BaseOutputBuilder.js

@@ -0,0 +1,69 @@
+export default class BaseOutputBuilder{
+  constructor(){
+    // this.attributes = {};
+  }
+
+  addAttribute(name, value){
+    if(this.options.onAttribute){
+      //TODO: better to pass tag path
+      const v = this.options.onAttribute(name, value, this.tagName);
+      if(v) this.attributes[v.name] = v.value;
+    }else{
+      name = this.options.attributes.prefix + name + this.options.attributes.suffix;
+      this.attributes[name] = this.parseValue(value, this.options.attributes.valueParsers);
+    }
+  }
+
+  /**
+   * parse value by chain of parsers
+   * @param {string} val 
+   * @returns {any} parsed value if matching parser found
+   */
+    parseValue = function(val, valParsers){
+      for (let i = 0; i < valParsers.length; i++) {
+        let valParser = valParsers[i];
+        if(typeof valParser === "string"){
+          valParser = this.registeredParsers[valParser];
+        }
+        if(valParser){
+          val = valParser.parse(val);
+        }
+      }
+      return val;
+    }
+
+  /**
+   * To add a nested empty tag.
+   * @param {string} key 
+   * @param {any} val 
+   */
+  _addChild(key, val){}
+
+  /**
+   * skip the comment if property is not set
+   */
+  addComment(text){
+    if(this.options.nameFor.comment)
+      this._addChild(this.options.nameFor.comment, text);
+  }
+
+  //store CDATA separately if property is set
+  //otherwise add to tag's value
+  addCdata(text){
+    if (this.options.nameFor.cdata) {
+      this._addChild(this.options.nameFor.cdata, text);
+    } else {
+      this.addRawValue(text || "");
+    }
+  }
+
+  addRawValue = text => this.addValue(text);
+
+  addDeclaration(){
+    if(!this.options.declaration){
+    }else{
+      this.addPi("?xml");
+    }
+    this.attributes = {}
+  }
+}

node_modules/fast-xml-parser/src/v6/OutputBuilders/JsArrBuilder.js

@@ -0,0 +1,103 @@
+import {buildOptions,registerCommonValueParsers} from './ParserOptionsBuilder.js';
+
+export default class OutputBuilder{
+  constructor(options){
+    this.options = buildOptions(options);
+      this.registeredParsers = registerCommonValueParsers(this.options);
+    }
+    
+    registerValueParser(name,parserInstance){//existing name will override the parser without warning
+      this.registeredParsers[name] = parserInstance;
+    }
+
+  getInstance(parserOptions){
+    return new JsArrBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+const rootName = '!js_arr';
+import BaseOutputBuilder from './BaseOutputBuilder.js';
+
+class JsArrBuilder extends BaseOutputBuilder{
+
+  constructor(parserOptions, options,registeredParsers) {
+    super();
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = options;
+    this.registeredParsers = registeredParsers;
+
+    this.root = new Node(rootName);
+    this.currentNode = this.root;
+    this.attributes = {};
+  }
+
+  addTag(tag){
+    //when a new tag is added, it should be added as child of current node
+    //TODO: shift this check to the parser
+    if(tag.name === "__proto__") tag.name = "#__proto__";
+
+    this.tagsStack.push(this.currentNode);
+    this.currentNode = new Node(tag.name, this.attributes);
+    this.attributes = {};
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag(){
+    const node = this.currentNode;
+    this.currentNode = this.tagsStack.pop(); //set parent node in scope
+    if(this.options.onClose !== undefined){
+      //TODO TagPathMatcher 
+      const resultTag = this.options.onClose(node, 
+        new TagPathMatcher(this.tagsStack,node));
+
+      if(resultTag) return;
+    }
+    this.currentNode.child.push(node);  //to parent node
+  }
+
+  //Called by parent class methods
+  _addChild(key, val){
+    // if(key === "__proto__") tagName = "#__proto__";
+    this.currentNode.child.push( {[key]: val });
+    // this.currentNode.leafType = false;
+  }
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text){
+    this.currentNode.child.push( {[this.options.nameFor.text]: this.parseValue(text, this.options.tags.valueParsers) });
+  }
+
+  addPi(name){
+    //TODO: set pi flag
+    if(!this.options.ignorePiTags){
+      const node = new Node(name, this.attributes);
+      this.currentNode[":@"] = this.attributes;
+      this.currentNode.child.push(node);
+    }
+    this.attributes = {};
+  }
+  getOutput(){
+    return this.root.child[0];
+  }
+}
+
+
+
+class Node{
+  constructor(tagname, attributes){
+    this.tagname = tagname;
+    this.child = []; //nested tags, text, cdata, comments
+    if(attributes && Object.keys(attributes).length > 0)
+      this[":@"] = attributes;
+  }
+}
+
+module.exports = OutputBuilder;

node_modules/fast-xml-parser/src/v6/OutputBuilders/JsMinArrBuilder.js

@@ -0,0 +1,100 @@
+import {buildOptions,registerCommonValueParsers} from"./ParserOptionsBuilder";
+
+export default class OutputBuilder{
+  constructor(options){
+    this.options = buildOptions(options);
+      this.registeredParsers = registerCommonValueParsers(this.options);
+    }
+    
+    registerValueParser(name,parserInstance){//existing name will override the parser without warning
+      this.registeredParsers[name] = parserInstance;
+    }
+
+  getInstance(parserOptions){
+    return new JsMinArrBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+import BaseOutputBuilder  from "./BaseOutputBuilder.js";
+const rootName = '^';
+
+class JsMinArrBuilder extends BaseOutputBuilder{
+
+  constructor(parserOptions, options,registeredParsers) {
+    super();
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = options;
+    this.registeredParsers = registeredParsers;
+
+    this.root = {[rootName]: []};
+    this.currentNode = this.root;
+    this.currentNodeTagName = rootName;
+    this.attributes = {};
+  }
+
+  addTag(tag){
+    //when a new tag is added, it should be added as child of current node
+    //TODO: shift this check to the parser
+    if(tag.name === "__proto__") tag.name = "#__proto__";
+
+    this.tagsStack.push([this.currentNodeTagName,this.currentNode]); //this.currentNode is parent node here
+    this.currentNodeTagName = tag.name;
+    this.currentNode = { [tag.name]:[]}
+    if(Object.keys(this.attributes).length > 0){
+      this.currentNode[":@"] = this.attributes;
+      this.attributes = {};
+    }
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag(){
+    const node = this.currentNode;
+    const nodeName = this.currentNodeTagName;
+    const arr = this.tagsStack.pop(); //set parent node in scope
+    this.currentNodeTagName = arr[0];
+    this.currentNode = arr[1];
+
+    if(this.options.onClose !== undefined){
+      //TODO TagPathMatcher 
+      const resultTag = this.options.onClose(node, 
+        new TagPathMatcher(this.tagsStack,node));
+
+      if(resultTag) return;
+    }
+    this.currentNode[this.currentNodeTagName].push(node);  //to parent node
+  }
+
+  //Called by parent class methods
+  _addChild(key, val){
+    // if(key === "__proto__") tagName = "#__proto__";
+    this.currentNode.push( {[key]: val });
+    // this.currentNode.leafType = false;
+  }
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text){
+    this.currentNode[this.currentNodeTagName].push( {[this.options.nameFor.text]: this.parseValue(text, this.options.tags.valueParsers) });
+  }
+
+  addPi(name){
+    if(!this.options.ignorePiTags){
+      const node = { [name]:[]}
+      if(this.attributes){
+        node[":@"] = this.attributes;
+      }
+      this.currentNode.push(node);
+    }
+    this.attributes = {};
+  }
+  getOutput(){
+    return this.root[rootName];
+  }
+}

node_modules/fast-xml-parser/src/v6/OutputBuilders/JsObjBuilder.js

@@ -0,0 +1,154 @@
+
+
+import {buildOptions,registerCommonValueParsers} from './ParserOptionsBuilder.js';
+
+export default class OutputBuilder{
+  constructor(builderOptions){
+      this.options = buildOptions(builderOptions);
+      this.registeredParsers = registerCommonValueParsers(this.options);
+  }
+
+  registerValueParser(name,parserInstance){//existing name will override the parser without warning
+    this.registeredParsers[name] = parserInstance;
+  }
+
+  getInstance(parserOptions){
+    return new JsObjBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+import BaseOutputBuilder from './BaseOutputBuilder.js';
+const rootName = '^';
+
+class JsObjBuilder extends BaseOutputBuilder{
+
+  constructor(parserOptions, builderOptions,registeredParsers) {
+    super();
+    //hold the raw detail of a tag and sequence with reference to the output
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = builderOptions;
+    this.registeredParsers = registeredParsers;
+
+    this.root = {};
+    this.parent = this.root;
+    this.tagName = rootName;
+    this.value = {};
+    this.textValue = "";
+    this.attributes = {};
+  }
+
+  addTag(tag){
+
+    let value = "";
+    if( !isEmpty(this.attributes)){
+      value = {};
+      if(this.options.attributes.groupBy){
+        value[this.options.attributes.groupBy] = this.attributes;
+      }else{
+        value = this.attributes;
+      }
+    }
+
+    this.tagsStack.push([this.tagName, this.textValue, this.value]); //parent tag, parent text value, parent tag value (jsobj)
+    this.tagName = tag.name;
+    this.value = value;
+    this.textValue = "";
+    this.attributes = {};
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag(){
+    const tagName = this.tagName;
+    let value = this.value;
+    let textValue = this.textValue;
+
+    //update tag text value
+    if(typeof value !== "object" && !Array.isArray(value)){
+      value = this.parseValue(textValue.trim(), this.options.tags.valueParsers);
+    }else if(textValue.length > 0){
+      value[this.options.nameFor.text] = this.parseValue(textValue.trim(), this.options.tags.valueParsers);
+    }
+
+    
+    let resultTag= {
+      tagName: tagName,
+      value: value
+    };
+
+    if(this.options.onTagClose !== undefined){
+      //TODO TagPathMatcher 
+      resultTag = this.options.onClose(tagName, value, this.textValue, new TagPathMatcher(this.tagsStack,node));
+
+      if(!resultTag) return;
+    }
+
+    //set parent node in scope
+    let arr = this.tagsStack.pop(); 
+    let parentTag = arr[2];
+    parentTag=this._addChildTo(resultTag.tagName, resultTag.value, parentTag);
+
+    this.tagName = arr[0];
+    this.textValue = arr[1];
+    this.value = parentTag;
+  }
+
+  _addChild(key, val){
+    if(typeof this.value === "string"){
+      this.value = { [this.options.nameFor.text] : this.value };
+    }
+
+    this._addChildTo(key, val, this.value);
+    // this.currentNode.leafType = false;
+    this.attributes = {};
+  }
+
+  _addChildTo(key, val, node){
+    if(typeof node === 'string') node = {};
+    if(!node[key]){
+      node[key] = val;
+    }else{ //Repeated
+      if(!Array.isArray(node[key])){ //but not stored as array
+        node[key] = [node[key]];
+      }
+      node[key].push(val);
+    }
+    return node;
+  }
+
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text){
+    //TODO: use bytes join
+    if(this.textValue.length > 0) this.textValue += " " + text;
+    else this.textValue = text;
+  }
+
+  addPi(name){
+    let value = "";
+    if( !isEmpty(this.attributes)){
+      value = {};
+      if(this.options.attributes.groupBy){
+        value[this.options.attributes.groupBy] = this.attributes;
+      }else{
+        value = this.attributes;
+      }
+    }
+    this._addChild(name, value);
+    
+  }
+  getOutput(){
+    return this.value;
+  }
+}
+
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}

node_modules/fast-xml-parser/src/v6/OutputBuilders/ParserOptionsBuilder.js

@@ -0,0 +1,94 @@
+import trimParser from "../valueParsers/trim";
+import booleanParser from "../valueParsers/booleanParser";
+import currencyParser from "../valueParsers/currency";
+import numberParser from "../valueParsers/number";
+
+const defaultOptions={
+  nameFor:{
+    text: "#text",
+    comment: "",
+    cdata: "",
+  },
+  // onTagClose: () => {},
+  // onAttribute: () => {},
+  piTag: false,
+  declaration: false, //"?xml"
+  tags: {
+    valueParsers: [
+      // "trim",
+      // "boolean",
+      // "number",
+      // "currency",
+      // "date",
+    ]
+  },
+  attributes:{
+    prefix: "@_",
+    suffix: "",
+    groupBy: "",
+    
+    valueParsers: [
+      // "trim",
+      // "boolean",
+      // "number",
+      // "currency",
+      // "date",
+    ]
+  },
+  dataType:{
+
+  }
+}
+
+//TODO
+const withJoin = ["trim","join", /*"entities",*/"number","boolean","currency"/*, "date"*/]
+const withoutJoin = ["trim", /*"entities",*/"number","boolean","currency"/*, "date"*/]
+
+export function buildOptions(options){
+  //clone
+  const finalOptions = { ... defaultOptions};
+
+  //add config missed in cloning
+  finalOptions.tags.valueParsers.push(...withJoin)
+  if(!this.preserveOrder)
+    finalOptions.tags.valueParsers.push(...withoutJoin);
+
+  //add config missed in cloning
+  finalOptions.attributes.valueParsers.push(...withJoin)
+
+  //override configuration
+  copyProperties(finalOptions,options);
+  return finalOptions;
+}
+
+function copyProperties(target, source) {
+  for (let key in source) {
+    if (source.hasOwnProperty(key)) {
+      if (typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        // Recursively copy nested properties
+        if (typeof target[key] === 'undefined') {
+          target[key] = {};
+        }
+        copyProperties(target[key], source[key]);
+      } else {
+        // Copy non-nested properties
+        target[key] = source[key];
+      }
+    }
+  }
+}
+
+export function registerCommonValueParsers(options){
+  return {
+    "trim": new trimParser(),
+    // "join": this.entityParser.parse,
+    "boolean": new booleanParser(),
+    "number": new numberParser({
+          hex: true,
+          leadingZeros: true,
+          eNotation: true
+        }),
+    "currency": new currencyParser(),
+    // "date": this.entityParser.parse,
+  }
+}

node_modules/fast-xml-parser/src/v6/TagPath.js

@@ -0,0 +1,81 @@
+export default class TagPath{
+  constructor(pathStr){
+    let text = "";
+    let tName = "";
+    let pos;
+    let aName = "";
+    let aVal = "";
+    this.stack = []
+
+    for (let i = 0; i < pathStr.length; i++) {
+      let ch = pathStr[i];
+      if(ch === " ") {
+        if(text.length === 0) continue;        
+        tName = text; text = "";
+      }else if(ch === "["){
+        if(tName.length === 0){
+          tName = text; text = "";
+        }
+        i++;
+        for (; i < pathStr.length; i++) {
+          ch = pathStr[i];
+          if(ch=== "=") continue;
+          else if(ch=== "]") {aName = text.trim(); text=""; break; i--;}
+          else if(ch === "'" || ch === '"'){
+            let attrEnd = pathStr.indexOf(ch,i+1);
+            aVal = pathStr.substring(i+1, attrEnd);
+            i = attrEnd;
+          }else{
+            text +=ch;
+          }
+        }
+      }else if(ch !== " " && text.length === 0 && tName.length > 0){//reading tagName
+        //save previous tag
+        this.stack.push(new TagPathNode(tName,pos,aName,aVal));
+        text = ch; tName = ""; aName = ""; aVal = "";
+      }else{
+        text+=ch;
+      }
+    }
+
+    //last tag in the path
+    if(tName.length >0 || text.length>0){
+      this.stack.push(new TagPathNode(text||tName,pos,aName,aVal));
+    }
+  }
+
+  match(tagStack,node){
+    if(this.stack[0].name !== "*"){
+      if(this.stack.length !== tagStack.length +1) return false;
+  
+      //loop through tagPath and tagStack and match
+      for (let i = 0; i < this.tagStack.length; i++) {
+        if(!this.stack[i].match(tagStack[i])) return false;
+      }
+    }
+    if(!this.stack[this.stack.length - 1].match(node)) return false;
+    return true;
+  }
+}
+
+class TagPathNode{
+  constructor(name,position,attrName,attrVal){
+    this.name = name;
+    this.position = position;
+    this.attrName = attrName,
+    this.attrVal = attrVal;
+  }
+
+  match(node){
+    let matching = true;
+    matching = node.name === this.name;
+    if(this.position) matching = node.position === this.position;
+    if(this.attrName) matching = node.attrs[this.attrName !== undefined];
+    if(this.attrVal) matching = node.attrs[this.attrName !== this.attrVal];
+    return matching;
+  }
+}
+
+// console.log((new TagPath("* b[b]")).stack);
+// console.log((new TagPath("a[a] b[b] c")).stack);
+// console.log((new TagPath(" b [ b= 'cf  sdadwa' ] a  ")).stack);

node_modules/fast-xml-parser/src/v6/TagPathMatcher.js

@@ -0,0 +1,13 @@
+import {TagPath} from './TagPath.js';
+
+export default class TagPathMatcher{
+  constructor(stack,node){
+    this.stack = stack;
+    this.node= node;
+  }
+
+  match(path){
+    const tagPath = new TagPath(path);
+    return tagPath.match(this.stack, this.node);
+  }
+}

node_modules/fast-xml-parser/src/v6/XMLParser.js

@@ -0,0 +1,83 @@
+import { buildOptions} from './OptionsBuilder.js';
+import Xml2JsParser from './Xml2JsParser.js';
+
+export default class XMLParser{
+    
+    constructor(options){
+        this.externalEntities = {};
+        this.options = buildOptions(options);
+        // console.log(this.options)
+    }
+    /**
+     * Parse XML data string to JS object 
+     * @param {string|Buffer} xmlData 
+     * @param {boolean|Object} validationOption 
+     */
+    parse(xmlData){
+        if(Array.isArray(xmlData) && xmlData.byteLength !== undefined){
+            return this.parse(xmlData);
+        }else if( xmlData.toString){
+            xmlData = xmlData.toString();
+        }else{
+            throw new Error("XML data is accepted in String or Bytes[] form.")
+        }
+        // if( validationOption){
+        //     if(validationOption === true) validationOption = {}; //validate with default options
+            
+        //     const result = validator.validate(xmlData, validationOption);
+        //     if (result !== true) {
+        //       throw Error( `${result.err.msg}:${result.err.line}:${result.err.col}` )
+        //     }
+        //   }
+        const parser = new Xml2JsParser(this.options);
+        parser.entityParser.addExternalEntities(this.externalEntities);
+        return parser.parse(xmlData);
+    }
+    /**
+     * Parse XML data buffer to JS object 
+     * @param {string|Buffer} xmlData 
+     * @param {boolean|Object} validationOption 
+     */
+    parseBytesArr(xmlData){
+        if(Array.isArray(xmlData) && xmlData.byteLength !== undefined){
+        }else{
+            throw new Error("XML data is accepted in Bytes[] form.")
+        }
+        const parser = new Xml2JsParser(this.options);
+        parser.entityParser.addExternalEntities(this.externalEntities);
+        return parser.parseBytesArr(xmlData);
+    }
+    /**
+     * Parse XML data stream to JS object 
+     * @param {fs.ReadableStream} xmlDataStream 
+     */
+    parseStream(xmlDataStream){
+        if(!isStream(xmlDataStream)) throw new Error("FXP: Invalid stream input");
+        
+        const orderedObjParser = new Xml2JsParser(this.options);
+        orderedObjParser.entityParser.addExternalEntities(this.externalEntities);
+        return orderedObjParser.parseStream(xmlDataStream);
+    }
+
+    /**
+     * 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 if(value === "&"){
+            throw new Error("An entity with value '&' is not permitted");
+        }else{
+            this.externalEntities[key] = value;
+        }
+    }
+}
+
+function isStream(stream){
+    if(stream && typeof stream.read === "function" && typeof stream.on === "function" && typeof stream.readableEnded === "boolean") return true;
+    return false;
+}

node_modules/fast-xml-parser/src/v6/Xml2JsParser.js

@@ -0,0 +1,235 @@
+import StringSource from './inputSource/StringSource.js';
+import BufferSource from './inputSource/BufferSource.js';
+import {readTagExp,readClosingTagName} from './XmlPartReader.js';
+import {readComment, readCdata,readDocType,readPiTag} from './XmlSpecialTagsReader.js';
+import TagPath from './TagPath.js';
+import TagPathMatcher from './TagPathMatcher.js';
+import EntitiesParser from './EntitiesParser.js';
+
+//To hold the data of current tag
+//This is usually used to compare jpath expression against current tag
+class TagDetail{
+  constructor(name){
+    this.name = name;
+    this.position = 0;
+    // this.attributes = {};
+  }
+}
+
+export default class Xml2JsParser {
+    constructor(options) {
+      this.options = options;
+      
+      this.currentTagDetail = null;
+      this.tagTextData = "";
+      this.tagsStack = [];
+      this.entityParser = new EntitiesParser(options.htmlEntities);
+      this.stopNodes = [];
+      for (let i = 0; i < this.options.stopNodes.length; i++) {
+        this.stopNodes.push(new TagPath(this.options.stopNodes[i]));
+      }
+    }
+
+    parse(strData) {
+        this.source = new StringSource(strData);
+        this.parseXml();
+        return this.outputBuilder.getOutput();
+    }
+    parseBytesArr(data) {
+        this.source = new BufferSource(data );
+        this.parseXml();
+        return this.outputBuilder.getOutput();
+    }
+  
+    parseXml() {
+      //TODO: Separate TagValueParser as separate class. So no scope issue in node builder class 
+
+      //OutputBuilder should be set in XML Parser
+      this.outputBuilder = this.options.OutputBuilder.getInstance(this.options);
+      this.root = { root: true};
+      this.currentTagDetail = this.root;
+
+      while(this.source.canRead()){
+        let ch = this.source.readCh();
+        if (ch === "") break;
+        
+        if(ch === "<"){//tagStart
+          let nextChar = this.source.readChAt(0);
+          if (nextChar === "" ) throw new Error("Unexpected end of source");
+          
+        
+          if(nextChar === "!" || nextChar === "?"){
+            this.source.updateBufferBoundary();
+            //previously collected text should be added to current node
+            this.addTextNode(); 
+            
+            this.readSpecialTag(nextChar);// Read DOCTYPE, comment, CDATA, PI tag
+          }else if(nextChar === "/"){
+            this.source.updateBufferBoundary();
+            this.readClosingTag();
+            // console.log(this.source.buffer.length, this.source.readable);
+            // console.log(this.tagsStack.length);
+          }else{//opening tag
+            this.readOpeningTag();
+          }
+        }else{
+          this.tagTextData += ch;
+        }
+      }//End While loop
+      if(this.tagsStack.length > 0 || ( this.tagTextData !== "undefined" && this.tagTextData.trimEnd().length > 0) ) throw new Error("Unexpected data in the end of document");
+    }
+  
+    /**
+     * read closing paired tag. Set parent tag in scope.
+     * skip a node on user's choice
+     */
+    readClosingTag(){
+      const tagName = this.processTagName(readClosingTagName(this.source));
+      // console.log(tagName, this.tagsStack.length);
+      this.validateClosingTag(tagName);
+      // All the text data collected, belongs to current tag.
+      if(!this.currentTagDetail.root) this.addTextNode();
+      this.outputBuilder.closeTag();
+      // Since the tag is closed now, parent tag comes in scope
+      this.currentTagDetail = this.tagsStack.pop(); 
+    }
+
+    validateClosingTag(tagName){
+      // This can't be unpaired tag, or a stop tag.
+      if(this.isUnpaired(tagName) || this.isStopNode(tagName)) throw new Error(`Unexpected closing tag '${tagName}'`);
+      // This must match with last opening tag
+      else if(tagName !== this.currentTagDetail.name) 
+        throw new Error(`Unexpected closing tag '${tagName}' expecting '${this.currentTagDetail.name}'`)
+    }
+
+    /**
+     * Read paired, unpaired, self-closing, stop and special tags.
+     * Create a new node
+     * Push paired tag in stack.
+     */
+    readOpeningTag(){
+      //save previously collected text data to current node
+      this.addTextNode();
+
+      //create new tag
+      let tagExp = readTagExp(this, ">" );
+      
+      // process and skip from tagsStack For unpaired tag, self closing tag, and stop node
+      const tagDetail = new TagDetail(tagExp.tagName);
+      if(this.isUnpaired(tagExp.tagName)) {
+        //TODO: this will lead 2 extra stack operation
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.closeTag();
+      } else if(tagExp.selfClosing){
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.closeTag();
+      } else if(this.isStopNode(this.currentTagDetail)){
+        // TODO: let's user set a stop node boundary detector for complex contents like script tag
+        //TODO: pass tag name only to avoid string operations
+        const content = source.readUptoCloseTag(`</${tagExp.tagName}`);
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.addValue(content);
+        this.outputBuilder.closeTag();
+      }else{//paired tag
+        //set new nested tag in scope.
+        this.tagsStack.push(this.currentTagDetail);
+        this.outputBuilder.addTag(tagDetail);
+        this.currentTagDetail = tagDetail;
+      }
+      // console.log(tagExp.tagName,this.tagsStack.length);
+      // this.options.onClose()
+
+    }
+
+    readSpecialTag(startCh){
+      if(startCh == "!"){
+        let nextChar = this.source.readCh();
+        if (nextChar === null || nextChar === undefined) throw new Error("Unexpected ending of the source");
+        
+        if(nextChar === "-"){//comment
+          readComment(this);
+        }else if(nextChar === "["){//CDATA
+          readCdata(this);
+        }else if(nextChar === "D"){//DOCTYPE
+          readDocType(this);
+        }
+      }else if(startCh === "?"){
+        readPiTag(this);
+      }else{
+        throw new Error(`Invalid tag '<${startCh}' at ${this.source.line}:${this.source.col}`)
+      }
+    }
+    addTextNode = function() {
+      // if(this.currentTagDetail){
+        //save text as child node
+        // if(this.currentTagDetail.tagname !== '!xml')
+        if (this.tagTextData !== undefined && this.tagTextData !== "") { //store previously collected data as textNode
+          if(this.tagTextData.trim().length > 0){
+            //TODO: shift parsing to output builder
+
+            this.outputBuilder.addValue(this.replaceEntities(this.tagTextData));
+          }
+          this.tagTextData = "";
+        }
+      // }
+    }
+
+    processAttrName(name){
+      if(name === "__proto__") name  = "#__proto__";
+      name = resolveNameSpace(name, this.removeNSPrefix);
+      return name;
+    }
+    
+    processTagName(name){
+      if(name === "__proto__") name  = "#__proto__";
+      name = resolveNameSpace(name, this.removeNSPrefix);
+      return name;
+    }
+
+    /**
+     * Generate tags path from tagsStack
+     */
+    tagsPath(tagName){
+      //TODO: return TagPath Object. User can call match method with path
+      return "";
+    }
+
+    isUnpaired(tagName){
+      return this.options.tags.unpaired.indexOf(tagName) !== -1;
+    }
+
+    /**
+     * valid expressions are 
+     * tag nested
+     * * nested
+     * tag nested[attribute]
+     * tag nested[attribute=""]
+     * tag nested[attribute!=""]
+     * tag nested:0 //for future
+     * @param {string} tagName 
+     * @returns 
+     */
+    isStopNode(node){
+      for (let i = 0; i < this.stopNodes.length; i++) {
+        const givenPath = this.stopNodes[i];
+        if(givenPath.match(this.tagsStack, node)) return true;
+      }
+      return false 
+    }
+
+    replaceEntities(text){
+      //TODO: if option is set then replace entities
+      return this.entityParser.parse(text)
+    }
+}
+
+function resolveNameSpace(name, removeNSPrefix) {
+  if (removeNSPrefix) {
+    const parts = name.split(':');
+    if(parts.length === 2){
+      if (parts[0] === 'xmlns') return '';
+      else return parts[1];
+    }else reportError(`Multiple namespaces ${name}`)
+  }
+  return name;
+}

node_modules/fast-xml-parser/src/v6/XmlPartReader.js

@@ -0,0 +1,210 @@
+'use strict';
+
+/**
+ * find paired tag for a stop node
+ * @param {string} xmlDoc
+ * @param {string} tagName
+ * @param {number} i : start index
+ */
+export function readStopNode(xmlDoc, tagName, i){
+    const startIndex = i;
+    // Starting at 1 since we already have an open tag
+    let openTagCount = 1;
+
+    for (; i < xmlDoc.length; i++) {
+      if( xmlDoc[i] === "<"){
+        if (xmlDoc[i+1] === "/") {//close tag
+            const closeIndex = findSubStrIndex(xmlDoc, ">", i, `${tagName} is not closed`);
+            let closeTagName = xmlDoc.substring(i+2,closeIndex).trim();
+            if(closeTagName === tagName){
+              openTagCount--;
+              if (openTagCount === 0) {
+                return {
+                  tagContent: xmlDoc.substring(startIndex, i),
+                  i : closeIndex
+                }
+              }
+            }
+            i=closeIndex;
+          } else if(xmlDoc[i+1] === '?') {
+            const closeIndex = findSubStrIndex(xmlDoc, "?>", i+1, "StopNode is not closed.")
+            i=closeIndex;
+          } else if(xmlDoc.substr(i + 1, 3) === '!--') {
+            const closeIndex = findSubStrIndex(xmlDoc, "-->", i+3, "StopNode is not closed.")
+            i=closeIndex;
+          } else if(xmlDoc.substr(i + 1, 2) === '![') {
+            const closeIndex = findSubStrIndex(xmlDoc, "]]>", i, "StopNode is not closed.") - 2;
+            i=closeIndex;
+          } else {
+            const tagData = readTagExp(xmlDoc, i, '>')
+
+            if (tagData) {
+              const openTagName = tagData && tagData.tagName;
+              if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length-1] !== "/") {
+                openTagCount++;
+              }
+              i=tagData.closeIndex;
+            }
+          }
+        }
+    }//end for loop
+}
+
+/**
+ * Read closing tag name
+ * @param {Source} source
+ * @returns tag name
+ */
+export function readClosingTagName(source){
+  let text = ""; //temporary data
+  while(source.canRead()){
+    let ch = source.readCh();
+    // if (ch === null || ch === undefined) break;
+    // source.updateBuffer();
+
+    if (ch === ">") return text.trimEnd();
+    else text += ch;
+  }
+  throw new Error(`Unexpected end of source. Reading '${substr}'`);
+}
+
+/**
+ * Read XML tag and build attributes map
+ * This function can be used to read normal tag, pi tag.
+ * This function can't be used to read comment, CDATA, DOCTYPE.
+ * Eg <tag attr = ' some"' attr= ">" bool>
+ * @param {string} xmlDoc
+ * @param {number} startIndex starting index
+ * @returns tag expression includes tag name & attribute string
+ */
+export function readTagExp(parser) {
+  let inSingleQuotes = false;
+  let inDoubleQuotes = false;
+  let i;
+  let EOE = false;
+
+  for (i = 0; parser.source.canRead(i); i++) {
+    const char = parser.source.readChAt(i);
+
+    if (char === "'" && !inDoubleQuotes) {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (char === '"' && !inSingleQuotes) {
+      inDoubleQuotes = !inDoubleQuotes;
+    } else if (char === '>' && !inSingleQuotes && !inDoubleQuotes) {
+      // If not inside quotes, stop reading at '>'
+      EOE = true;
+      break;
+    }
+
+  }
+  if(inSingleQuotes || inDoubleQuotes){
+    throw new Error("Invalid attribute expression. Quote is not properly closed");
+  }else if(!EOE) throw new Error("Unexpected closing of source. Waiting for '>'");
+
+
+  const exp = parser.source.readStr(i);
+  parser.source.updateBufferBoundary(i + 1);
+  return buildTagExpObj(exp, parser)
+}
+
+export function readPiExp(parser) {
+  let inSingleQuotes = false;
+  let inDoubleQuotes = false;
+  let i;
+  let EOE = false;
+
+  for (i = 0; parser.source.canRead(i) ; i++) {
+    const currentChar = parser.source.readChAt(i);
+    const nextChar =  parser.source.readChAt(i+1);
+
+    if (currentChar === "'" && !inDoubleQuotes) {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (currentChar === '"' && !inSingleQuotes) {
+      inDoubleQuotes = !inDoubleQuotes;
+    }
+
+    if (!inSingleQuotes && !inDoubleQuotes) {
+      if (currentChar === '?' && nextChar === '>') {
+        EOE = true;
+        break; // Exit the loop when '?>' is found
+      }
+    }
+  }
+  if(inSingleQuotes || inDoubleQuotes){
+    throw new Error("Invalid attribute expression. Quote is not properly closed in PI tag expression");
+  }else if(!EOE) throw new Error("Unexpected closing of source. Waiting for '?>'");
+
+  if(!parser.options.attributes.ignore){
+    //TODO: use regex to verify attributes if not set to ignore
+  }
+
+  const exp = parser.source.readStr(i);
+  parser.source.updateBufferBoundary(i + 1);
+  return buildTagExpObj(exp, parser)
+}
+
+function buildTagExpObj(exp, parser){
+  const tagExp = {
+    tagName: "",
+    selfClosing: false
+  };
+  let attrsExp = "";
+
+  // Check for self-closing tag before setting the name
+  if(exp[exp.length -1] === "/") {
+    tagExp.selfClosing = true;
+    exp = exp.slice(0, -1); // Remove the trailing slash
+  }
+
+  //separate tag name
+  let i = 0;
+  for (; i < exp.length; i++) {
+    const char = exp[i];
+    if(char === " "){
+      tagExp.tagName = exp.substring(0, i);
+      attrsExp = exp.substring(i + 1);
+      break;
+    }
+  }
+  //only tag
+  if(tagExp.tagName.length === 0 && i === exp.length)tagExp.tagName = exp;
+
+  tagExp.tagName = tagExp.tagName.trimEnd();
+
+  if(!parser.options.attributes.ignore && attrsExp.length > 0){
+    parseAttributesExp(attrsExp,parser)
+  }
+
+  return tagExp;
+}
+
+const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
+
+function parseAttributesExp(attrStr, parser) {
+  const matches = getAllMatches(attrStr, attrsRegx);
+  const len = matches.length; //don't make it inline
+  for (let i = 0; i < len; i++) {
+    let attrName = parser.processAttrName(matches[i][1]);
+    let attrVal = parser.replaceEntities(matches[i][4] || true);
+
+    parser.outputBuilder.addAttribute(attrName, attrVal);
+  }
+}
+
+
+const getAllMatches = function(string, regex) {
+  const matches = [];
+  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]);
+    }
+    matches.push(allmatches);
+    match = regex.exec(string);
+  }
+  return matches;
+};
+

node_modules/fast-xml-parser/src/v6/XmlSpecialTagsReader.js

@@ -0,0 +1,111 @@
+import {readPiExp} from './XmlPartReader.js';
+
+export function readCdata(parser){
+  //<![ are already read till this point
+  let str = parser.source.readStr(6); //CDATA[
+  parser.source.updateBufferBoundary(6);
+
+  if(str !== "CDATA[") throw new Error(`Invalid CDATA expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let text = parser.source.readUpto("]]>");
+  parser.outputBuilder.addCdata(text);
+}
+export function readPiTag(parser){
+  //<? are already read till this point
+  let tagExp = readPiExp(parser, "?>");
+  if(!tagExp) throw new Error("Invalid Pi Tag expression.");
+
+  if (tagExp.tagName === "?xml") {//TODO: test if tagName is just xml
+    parser.outputBuilder.addDeclaration();
+  } else {
+    parser.outputBuilder.addPi("?"+tagExp.tagName);
+  }
+}
+
+export function readComment(parser){
+  //<!- are already read till this point
+  let ch = parser.source.readCh();
+  if(ch !== "-") throw new Error(`Invalid comment expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let text = parser.source.readUpto("-->");
+  parser.outputBuilder.addComment(text);
+}
+
+const DOCTYPE_tags = {
+  "EL":/^EMENT\s+([^\s>]+)\s+(ANY|EMPTY|\(.+\)\s*$)/m,
+  "AT":/^TLIST\s+[^\s]+\s+[^\s]+\s+[^\s]+\s+[^\s]+\s+$/m,
+  "NO":/^TATION.+$/m
+}
+export function readDocType(parser){
+  //<!D are already read till this point
+  let str = parser.source.readStr(6); //OCTYPE
+  parser.source.updateBufferBoundary(6);
+
+  if(str !== "OCTYPE") throw new Error(`Invalid DOCTYPE expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let hasBody = false, lastch = "";
+
+  while(parser.source.canRead()){
+    //TODO: use readChAt like used in partReader
+    let ch = parser.source.readCh();
+    if(hasBody){
+      if (ch === '<') { //Determine the tag type
+        let str = parser.source.readStr(2);
+        parser.source.updateBufferBoundary(2);
+        if(str === "EN"){ //ENTITY
+          let str = parser.source.readStr(4);
+          parser.source.updateBufferBoundary(4);
+          if(str !== "TITY") throw new Error("Invalid DOCTYPE ENTITY expression");
+
+          registerEntity(parser);
+        }else if(str === "!-") {//comment
+          readComment(parser);
+        }else{ //ELEMENT, ATTLIST, NOTATION
+          let dTagExp = parser.source.readUpto(">");
+          const regx = DOCTYPE_tags[str];
+          if(regx){
+            const match = dTagExp.match(regx);
+            if(!match) throw new Error("Invalid DOCTYPE");
+          }else throw new Error("Invalid DOCTYPE");
+        }
+      }else if( ch === '>' && lastch === "]"){//end of doctype
+        return;  
+      }
+    }else if( ch === '>'){//end of doctype
+      return;
+    }else if( ch === '['){
+      hasBody = true;
+    }else{
+      lastch = ch;
+    }
+  }//End While loop
+
+}
+
+function registerEntity(parser){
+  //read Entity
+  let attrBoundary="";
+  let name ="", val ="";
+  while(source.canRead()){
+    let ch = source.readCh();
+
+    if(attrBoundary){
+      if (ch === attrBoundary){
+        val = text;
+        text = ""
+      }
+    }else if(ch === " " || ch === "\t"){
+      if(!name){
+        name = text.trimStart();
+        text = "";
+      }
+    }else if (ch === '"' || ch === "'") {//start of attrBoundary
+      attrBoundary = ch;
+    }else if(ch === ">"){
+      parser.entityParser.addExternalEntity(name,val);
+      return;
+    }else{
+      text+=ch;
+    }
+  }
+}

node_modules/fast-xml-parser/src/v6/inputSource/BufferSource.js

@@ -0,0 +1,116 @@
+const Constants = {
+  space: 32,
+  tab: 9
+}
+export default class BufferSource{
+  constructor(bytesArr){
+    this.line = 1;
+    this.cols = 0;
+    this.buffer = bytesArr;
+    this.startIndex = 0;
+  }
+
+
+
+  readCh() {
+    return String.fromCharCode(this.buffer[this.startIndex++]);
+  }
+
+  readChAt(index) {
+    return String.fromCharCode(this.buffer[this.startIndex+index]);
+  }
+
+  readStr(n,from){
+    if(typeof from === "undefined") from = this.startIndex;
+    return this.buffer.slice(from, from + n).toString();
+  }
+
+  readUpto(stopStr) {
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    const stopBuffer = Buffer.from(stopStr);
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+        let match = true;
+        for (let j = 0; j < stopLength; j++) {
+            if (this.buffer[i + j] !== stopBuffer[j]) {
+                match = false;
+                break;
+            }
+        }
+
+        if (match) {
+            const result = this.buffer.slice(this.startIndex, i).toString();
+            this.startIndex = i + stopLength;
+            return result;
+        }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+}
+
+readUptoCloseTag(stopStr) { //stopStr: "</tagname"
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    const stopBuffer = Buffer.from(stopStr);
+    let stopIndex = 0;
+    //0: non-matching, 1: matching stop string, 2: matching closing
+    let match = 0;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+        if(match === 1){//initial part matched
+            if(stopIndex === 0) stopIndex = i;
+            if(this.buffer[i] === Constants.space || this.buffer[i] === Constants.tab) continue;
+            else if(this.buffer[i] === '>'){ //TODO: if it should be equivalent ASCII
+                match = 2;
+                //tag boundary found
+                // this.startIndex
+            }
+        }else{
+            match = 1;
+            for (let j = 0; j < stopLength; j++) {
+                if (this.buffer[i + j] !== stopBuffer[j]) {
+                    match = 0;
+                    break;
+                }
+            }
+        }
+        if (match === 2) {//matched closing part
+            const result = this.buffer.slice(this.startIndex, stopIndex - 1 ).toString();
+            this.startIndex = i + 1;
+            return result;
+        }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+}
+
+  readFromBuffer(n, shouldUpdate) {
+    let ch;
+    if (n === 1) {
+      ch = this.buffer[this.startIndex];
+      if (ch === 10) {
+        this.line++;
+        this.cols = 1;
+      } else {
+        this.cols++;
+      }
+      ch = String.fromCharCode(ch);
+    } else {
+      this.cols += n;
+      ch = this.buffer.slice(this.startIndex, this.startIndex + n).toString();
+    }
+    if (shouldUpdate) this.updateBuffer(n);
+    return ch;
+  }
+
+  updateBufferBoundary(n = 1) { //n: number of characters read
+    this.startIndex += n;
+  }
+
+  canRead(n){
+    n = n || this.startIndex;
+    return this.buffer.length - n + 1 > 0;
+  }
+  
+}

node_modules/fast-xml-parser/src/v6/inputSource/StringSource.js

@@ -0,0 +1,121 @@
+const whiteSpaces = [" ", "\n", "\t"];
+
+
+export default class StringSource{
+  constructor(str){
+    this.line = 1;
+    this.cols = 0;
+    this.buffer = str;
+    //a boundary pointer to indicate where from the buffer dat should be read
+    // data before this pointer can be deleted to free the memory
+    this.startIndex = 0;
+  }
+
+  readCh() {
+    return this.buffer[this.startIndex++];
+  }
+
+  readChAt(index) {
+    return this.buffer[this.startIndex+index];
+  }
+
+  readStr(n,from){
+    if(typeof from === "undefined") from = this.startIndex;
+    return this.buffer.substring(from, from + n);
+  }
+
+  readUpto(stopStr) {
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+      let match = true;
+      for (let j = 0; j < stopLength; j++) {
+        if (this.buffer[i + j] !== stopStr[j]) {
+          match = false;
+          break;
+        }
+      }
+
+      if (match) {
+        const result = this.buffer.substring(this.startIndex, i);
+        this.startIndex = i + stopLength;
+        return result;
+      }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+  }
+
+  readUptoCloseTag(stopStr) { //stopStr: "</tagname"
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    let stopIndex = 0;
+    //0: non-matching, 1: matching stop string, 2: matching closing
+    let match = 0;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+      if(match === 1){//initial part matched
+        if(stopIndex === 0) stopIndex = i;
+        if(this.buffer[i] === ' ' || this.buffer[i] === '\t') continue;
+        else if(this.buffer[i] === '>'){
+          match = 2;
+          //tag boundary found
+          // this.startIndex
+        }
+      }else{
+        match = 1;
+        for (let j = 0; j < stopLength; j++) {
+          if (this.buffer[i + j] !== stopStr[j]) {
+            match = 0;
+            break;
+          }
+        }
+      }
+      if (match === 2) {//matched closing part
+        const result = this.buffer.substring(this.startIndex, stopIndex - 1 );
+        this.startIndex = i + 1;
+        return result;
+      }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+  }
+
+  readFromBuffer(n, updateIndex){
+    let ch;
+    if(n===1){
+      ch = this.buffer[this.startIndex];
+      // if(ch === "\n") {
+      //   this.line++;
+      //   this.cols = 1;
+      // }else{
+      //   this.cols++;
+      // }
+    }else{
+      ch = this.buffer.substring(this.startIndex, this.startIndex + n);
+      // if("".indexOf("\n") !== -1){
+      //   //TODO: handle the scenario when there are multiple lines
+      //   //TODO: col should be set to number of chars after last '\n'
+      //   // this.cols = 1;
+      // }else{
+      //   this.cols += n;
+
+      // }
+    }
+    if(updateIndex) this.updateBufferBoundary(n);
+    return ch;
+  }
+
+  //TODO: rename to updateBufferReadIndex
+  
+  updateBufferBoundary(n = 1) { //n: number of characters read
+    this.startIndex += n;
+  }
+
+  canRead(n){
+    n = n || this.startIndex;
+    return this.buffer.length - n + 1 > 0;
+  }
+  
+}

node_modules/fast-xml-parser/src/v6/valueParsers/EntitiesParser.js

@@ -0,0 +1,105 @@
+const ampEntity = { regex: /&(amp|#38|#x26);/g, val : "&"};
+const 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: "₹" },
+    "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 10)) },
+    "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 16)) },
+};
+
+export default class EntitiesParser{
+    constructor(replaceHtmlEntities) {
+      this.replaceHtmlEntities = replaceHtmlEntities;
+      this.docTypeEntities = {};
+      this.lastEntities = {
+        "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 : "\""},
+      };
+    }
+
+    addExternalEntities(externalEntities){
+        const entKeys = Object.keys(externalEntities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.addExternalEntity(ent,externalEntities[ent])
+        }
+    }
+    addExternalEntity(key,val){
+      validateEntityName(key);
+      if(val.indexOf("&") !== -1) {
+        reportWarning(`Entity ${key} is not added as '&' is found in value;`)
+        return;
+      }else{
+        this.lastEntities[ent] = {
+          regex: new RegExp("&"+key+";","g"),
+          val : val
+        }
+      }
+    }
+
+    addDocTypeEntities(entities){
+        const entKeys = Object.keys(entities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.docTypeEntities[ent] = {
+             regex: new RegExp("&"+ent+";","g"),
+             val : entities[ent]
+          }
+        }
+    }
+
+    parse(val){
+        return this.replaceEntitiesValue(val)
+    }
+
+    /**
+     * 1. Replace DOCTYPE entities 
+     * 2. Replace external entities 
+     * 3. Replace HTML entities if asked
+     * @param {string} val 
+     */
+    replaceEntitiesValue(val){
+        if(typeof val === "string" && val.length > 0){
+            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.replaceHtmlEntities){
+                for(let entityName in htmlEntities){
+                  const entity = htmlEntities[entityName];
+                  val = val.replace( entity.regex, entity.val);
+                }
+              }
+            val = val.replace( ampEntity.regex, ampEntity.val);
+        }
+        return val;
+    }
+};
+
+//an entity name should not contains special characters that may be used in regex
+//Eg !?\\\/[]$%{}^&*()<>
+const specialChar = "!?\\\/[]$%{}^&*()<>|+";
+
+function validateEntityName(name){
+    for (let i = 0; i < specialChar.length; i++) {
+        const ch = specialChar[i];
+        if(name.indexOf(ch) !== -1) throw new Error(`Invalid character ${ch} in entity name`);
+    }
+    return name;
+}

node_modules/fast-xml-parser/src/v6/valueParsers/booleanParser.js

@@ -0,0 +1,22 @@
+export default class boolParser{
+    constructor(trueList, falseList){
+        if(trueList)
+            this.trueList = trueList;
+        else
+            this.trueList = ["true"];
+        
+        if(falseList)
+            this.falseList = falseList;
+        else
+            this.falseList = ["false"];
+    }
+    parse(val){
+        if (typeof val === 'string') {
+            //TODO: performance: don't convert
+            const temp = val.toLowerCase();
+            if(this.trueList.indexOf(temp) !== -1) return true;
+            else if(this.falseList.indexOf(temp) !== -1 ) return false;
+        }
+        return val;
+    }
+}

node_modules/fast-xml-parser/src/v6/valueParsers/booleanParserExt.js

@@ -0,0 +1,19 @@
+export default function boolParserExt(val){
+    if(isArray(val)){
+        for (let i = 0; i < val.length; i++) {
+            val[i] = parse(val[i])
+        }
+    }else{
+        val = parse(val)
+    }
+    return val;
+}
+
+function parse(val){
+    if (typeof val === 'string') {
+        const temp = val.toLowerCase();
+        if(temp === 'true' || temp ==="yes" || temp==="1") return true;
+        else if(temp === 'false' || temp ==="no" || temp==="0") return false;
+    }
+    return val;
+}

node_modules/fast-xml-parser/src/v6/valueParsers/currency.js

@@ -0,0 +1,38 @@
+const defaultOptions = {
+    maxLength: 200,
+    // locale: "en-IN"
+}
+const localeMap = {
+    "$":"en-US",
+    "€":"de-DE",
+    "£":"en-GB",
+    "¥":"ja-JP",
+    "₹":"en-IN",
+}
+const sign = "(?:-|\+)?";
+const digitsAndSeparator = "(?:\d+|\d{1,3}(?:,\d{3})+)";
+const decimalPart = "(?:\.\d{1,2})?";
+const symbol = "(?:\$|€|¥|₹)?";
+
+const currencyCheckRegex = /^\s*(?:-|\+)?(?:\d+|\d{1,3}(?:,\d{3})+)?(?:\.\d{1,2})?\s*(?:\$|€|¥|₹)?\s*$/u;
+
+export default class CurrencyParser{
+    constructor(options){
+        this.options = options || defaultOptions;
+    }
+    parse(val){
+        if (typeof val === 'string' && val.length <= this.options.maxLength) {
+            if(val.indexOf(",,") !== -1 && val.indexOf(".." !== -1)){
+                const match = val.match(currencyCheckRegex);
+                if(match){
+                    const locale = this.options.locale || localeMap[match[2]||match[5]||"₹"];
+                    const formatter = new Intl.NumberFormat(locale)
+                    val = val.replace(/[^0-9,.]/g, '').trim();
+                    val = Number(val.replace(formatter.format(1000)[1], ''));
+                }
+            }
+        }
+        return val;
+    }
+}
+CurrencyParser.defaultOptions = defaultOptions;

node_modules/fast-xml-parser/src/v6/valueParsers/join.js

@@ -0,0 +1,13 @@
+/**
+ * 
+ * @param {array} val 
+ * @param {string} by 
+ * @returns 
+ */
+export default function join(val, by=" "){
+    if(isArray(val)){
+        val.join(by)
+    }
+    return val;
+}
+

node_modules/fast-xml-parser/src/v6/valueParsers/number.js

@@ -0,0 +1,14 @@
+import toNumber from "strnum";
+
+
+export default class numParser{
+    constructor(options){
+        this.options = options;
+    }
+    parse(val){
+        if (typeof val === 'string') {
+            val = toNumber(val,this.options);
+        }
+        return val;
+    }
+}

node_modules/fast-xml-parser/src/v6/valueParsers/trim.js

@@ -0,0 +1,6 @@
+export default class trimmer{
+    parse(val){
+        if(typeof val === "string") return val.trim();
+        else return val;
+    }
+}

node_modules/fast-xml-parser/src/validator.js

@@ -103,6 +103,8 @@ exports.validate = function (xmlData, options) {
             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, tagStartPos));
+          } else if (tags.length === 0) {
+            return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
           } else {
             const otg = tags.pop();
             if (tagName !== otg.tagName) {

node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js

@@ -1,6 +1,7 @@
 'use strict';
 //parse Empty Node as self closing node
 const buildFromOrderedJs = require('./orderedJs2Xml');
+const getIgnoreAttributesFn = require('../ignoreAttributes')
 
 const defaultOptions = {
   attributeNamePrefix: '@_',
@@ -38,11 +39,12 @@ const defaultOptions = {
 
 function Builder(options) {
   this.options = Object.assign({}, defaultOptions, options);
-  if (this.options.ignoreAttributes || this.options.attributesGroupName) {
+  if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {
     this.isAttribute = function(/*a*/) {
       return false;
     };
   } else {
+    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)
     this.attrPrefixLen = this.options.attributeNamePrefix.length;
     this.isAttribute = isAttribute;
   }
@@ -71,14 +73,16 @@ Builder.prototype.build = function(jObj) {
         [this.options.arrayNodeName] : jObj
       }
     }
-    return this.j2x(jObj, 0).val;
+    return this.j2x(jObj, 0, []).val;
   }
 };
 
-Builder.prototype.j2x = function(jObj, level) {
+Builder.prototype.j2x = function(jObj, level, ajPath) {
   let attrStr = '';
   let val = '';
+  const jPath = ajPath.join('.')
   for (let key in jObj) {
+    if(!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
     if (typeof jObj[key] === 'undefined') {
       // supress undefined node only if it is not an attribute
       if (this.isAttribute(key)) {
@@ -88,6 +92,8 @@ Builder.prototype.j2x = function(jObj, level) {
       // null attribute should be ignored by the attribute list, but should not cause the tag closing
       if (this.isAttribute(key)) {
         val += '';
+      } else if (key === this.options.cdataPropName) {
+        val += '';
       } else if (key[0] === '?') {
         val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
       } else {
@@ -99,9 +105,9 @@ Builder.prototype.j2x = function(jObj, level) {
     } else if (typeof jObj[key] !== 'object') {
       //premitive type
       const attr = this.isAttribute(key);
-      if (attr) {
+      if (attr && !this.ignoreAttributesFn(attr, jPath)) {
         attrStr += this.buildAttrPairStr(attr, '' + jObj[key]);
-      }else {
+      } else if (!attr) {
         //tag value
         if (key === this.options.textNodeName) {
           let newval = this.options.tagValueProcessor(key, '' + jObj[key]);
@@ -114,6 +120,7 @@ Builder.prototype.j2x = function(jObj, level) {
       //repeated nodes
       const arrLen = jObj[key].length;
       let listTagVal = "";
+      let listTagAttr = "";
       for (let j = 0; j < arrLen; j++) {
         const item = jObj[key][j];
         if (typeof item === 'undefined') {
@@ -123,17 +130,27 @@ Builder.prototype.j2x = function(jObj, level) {
           else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
           // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
         } else if (typeof item === 'object') {
-          if(this.options.oneListGroup ){
-            listTagVal += this.j2x(item, level + 1).val;
+          if(this.options.oneListGroup){
+            const result = this.j2x(item, level + 1, ajPath.concat(key));
+            listTagVal += result.val;
+            if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {
+              listTagAttr += result.attrStr
+            }
           }else{
-            listTagVal += this.processTextOrObjNode(item, key, level)
+            listTagVal += this.processTextOrObjNode(item, key, level, ajPath)
           }
         } else {
-          listTagVal += this.buildTextValNode(item, key, '', level);
+          if (this.options.oneListGroup) {
+            let textValue = this.options.tagValueProcessor(key, item);
+            textValue = this.replaceEntitiesValue(textValue);
+            listTagVal += textValue;
+          } else {
+            listTagVal += this.buildTextValNode(item, key, '', level);
+          }
         }
       }
       if(this.options.oneListGroup){
-        listTagVal = this.buildObjectNode(listTagVal, key, '', level);
+        listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);
       }
       val += listTagVal;
     } else {
@@ -145,7 +162,7 @@ Builder.prototype.j2x = function(jObj, level) {
           attrStr += this.buildAttrPairStr(Ks[j], '' + jObj[key][Ks[j]]);
         }
       } else {
-        val += this.processTextOrObjNode(jObj[key], key, level)
+        val += this.processTextOrObjNode(jObj[key], key, level, ajPath)
       }
     }
   }
@@ -160,8 +177,8 @@ Builder.prototype.buildAttrPairStr = function(attrName, val){
   } else return ' ' + attrName + '="' + val + '"';
 }
 
-function processTextOrObjNode (object, key, level) {
-  const result = this.j2x(object, level + 1);
+function processTextOrObjNode (object, key, level, ajPath) {
+  const result = this.j2x(object, level + 1, ajPath.concat(key));
   if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {
     return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
   } else {

node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js

@@ -21,6 +21,8 @@ function arrToStr(arr, options, jPath, indentation) {
     for (let i = 0; i < arr.length; i++) {
         const tagObj = arr[i];
         const tagName = propName(tagObj);
+        if(tagName === undefined) continue;
+
         let newJPath = "";
         if (jPath.length === 0) newJPath = tagName
         else newJPath = `${jPath}.${tagName}`;
@@ -90,6 +92,7 @@ function propName(obj) {
     const keys = Object.keys(obj);
     for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
+        if(!obj.hasOwnProperty(key)) continue;
         if (key !== ":@") return key;
     }
 }
@@ -98,6 +101,7 @@ function attr_to_str(attrMap, options) {
     let attrStr = "";
     if (attrMap && !options.ignoreAttributes) {
         for (let attr in attrMap) {
+            if(!attrMap.hasOwnProperty(attr)) continue;
             let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
             attrVal = replaceEntitiesValue(attrVal, options);
             if (attrVal === true && options.suppressBooleanAttributes) {

node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js

@@ -19,6 +19,7 @@ function readDocType(xmlData, i){
             if (xmlData[i] === '<' && !comment) { //Determine the tag type
                 if( hasBody && isEntity(xmlData, i)){
                     i += 7; 
+                    let entityName, val;
                     [entityName, val,i] = readEntityExp(xmlData,i+1);
                     if(val.indexOf("&") === -1) //Parameter entities are not supported
                         entities[ validateEntityName(entityName) ] = {

node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js

@@ -5,10 +5,11 @@ const util = require('../util');
 const xmlNode = require('./xmlNode');
 const readDocType = require("./DocTypeReader");
 const toNumber = require("strnum");
+const getIgnoreAttributesFn = require('../ignoreAttributes')
 
-const regx =
-  '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)'
-  .replace(/NAME/g, util.nameRegexp);
+// const regx =
+//   '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)'
+//   .replace(/NAME/g, util.nameRegexp);
 
 //const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g");
 //const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g");
@@ -40,6 +41,8 @@ class OrderedObjParser{
       "copyright" : { regex: /&(copy|#169);/g, val: "©" },
       "reg" : { regex: /&(reg|#174);/g, val: "®" },
       "inr" : { regex: /&(inr|#8377);/g, val: "₹" },
+      "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 10)) },
+      "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 16)) },
     };
     this.addExternalEntities = addExternalEntities;
     this.parseXml = parseXml;
@@ -51,6 +54,7 @@ class OrderedObjParser{
     this.readStopNodeData = readStopNodeData;
     this.saveTextToParentTag = saveTextToParentTag;
     this.addChild = addChild;
+    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)
   }
 
 }
@@ -123,7 +127,7 @@ function resolveNameSpace(tagname) {
 const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
 
 function buildAttributesMap(attrStr, jPath, tagName) {
-  if (!this.options.ignoreAttributes && typeof attrStr === 'string') {
+  if (this.options.ignoreAttributes !== true && typeof attrStr === 'string') {
     // attrStr = attrStr.replace(/\r?\n/g, ' ');
     //attrStr = attrStr || attrStr.trim();
 
@@ -132,6 +136,9 @@ function buildAttributesMap(attrStr, jPath, tagName) {
     const attrs = {};
     for (let i = 0; i < len; i++) {
       const attrName = this.resolveNameSpace(matches[i][1]);
+      if (this.ignoreAttributesFn(attrName, jPath)) {
+        continue
+      }
       let oldVal = matches[i][4];
       let aName = this.options.attributeNamePrefix + attrName;
       if (attrName.length) {
@@ -265,14 +272,13 @@ const parseXml = function(xmlData) {
 
         textData = this.saveTextToParentTag(textData, currentNode, jPath);
 
+        let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
+        if(val == undefined) val = "";
+
         //cdata should be set even if it is 0 length string
         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 = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true);
-          if(val == undefined) val = "";
           currentNode.add(this.options.textNodeName, val);
         }
         
@@ -280,6 +286,7 @@ const parseXml = function(xmlData) {
       }else {//Opening tag
         let result = readTagExp(xmlData,i, this.options.removeNSPrefix);
         let tagName= result.tagName;
+        const rawTagName = result.rawTagName;
         let tagExp = result.tagExp;
         let attrExpPresent = result.attrExpPresent;
         let closeIndex = result.closeIndex;
@@ -305,21 +312,29 @@ const parseXml = function(xmlData) {
         if(tagName !== xmlObj.tagname){
           jPath += jPath ? "." + tagName : tagName;
         }
-        if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) { //TODO: namespace
+        if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
           let tagContent = "";
           //self-closing tag
           if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){
+            if(tagName[tagName.length - 1] === "/"){ //remove trailing '/'
+              tagName = tagName.substr(0, tagName.length - 1);
+              jPath = jPath.substr(0, jPath.length - 1);
+              tagExp = tagName;
+            }else{
+              tagExp = tagExp.substr(0, tagExp.length - 1);
+            }
             i = result.closeIndex;
           }
           //unpaired tag
           else if(this.options.unpairedTags.indexOf(tagName) !== -1){
+            
             i = result.closeIndex;
           }
           //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}`);
+            const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
+            if(!result) throw new Error(`Unexpected end of ${rawTagName}`);
             i = result.i;
             tagContent = result.tagContent;
           }
@@ -414,7 +429,7 @@ const replaceEntitiesValue = function(val){
 }
 function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
   if (textData) { //store previously collected data as textNode
-    if(isLeafNode === undefined) isLeafNode = Object.keys(currentNode.child).length === 0
+    if(isLeafNode === undefined) isLeafNode = currentNode.child.length === 0
     
     textData = this.parseTextData(textData,
       currentNode.tagname,
@@ -500,10 +515,11 @@ function readTagExp(xmlData,i, removeNSPrefix, closingChar = ">"){
   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);
+    tagName = tagExp.substring(0, separatorIndex);
+    tagExp = tagExp.substring(separatorIndex + 1).trimStart();
   }
 
+  const rawTagName = tagName;
   if(removeNSPrefix){
     const colonIndex = tagName.indexOf(":");
     if(colonIndex !== -1){
@@ -517,6 +533,7 @@ function readTagExp(xmlData,i, removeNSPrefix, closingChar = ">"){
     tagExp: tagExp,
     closeIndex: closeIndex,
     attrExpPresent: attrExpPresent,
+    rawTagName: rawTagName,
   }
 }
 /**