lakutata 2.0.12 → 2.0.13

package/src/lib/helpers/IsXML.mjs

@@ -1,104 +1,104 @@
-import { g as e } from "../../../vendor/Package.5.mjs";
+import { g as t } from "../../../vendor/Package.5.mjs";
 
-var t = {};
+var e = {};
 
-var i = {};
+var n = {};
 
-(function(e) {
+(function(t) {
     "use strict";
-    const t = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
-    const i = t + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
-    const n = "[" + t + "][" + i + "]*";
-    const s = new RegExp("^" + n + "$");
-    const r = function(e, t) {
-        const i = [];
-        let n = t.exec(e);
-        while (n) {
+    const e = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
+    const n = e + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+    const i = "[" + e + "][" + n + "]*";
+    const s = new RegExp("^" + i + "$");
+    const r = function(t, e) {
+        const n = [];
+        let i = e.exec(t);
+        while (i) {
             const s = [];
-            s.startIndex = t.lastIndex - n[0].length;
-            const r = n.length;
-            for (let e = 0; e < r; e++) {
-                s.push(n[e]);
+            s.startIndex = e.lastIndex - i[0].length;
+            const r = i.length;
+            for (let t = 0; t < r; t++) {
+                s.push(i[t]);
             }
-            i.push(s);
-            n = t.exec(e);
+            n.push(s);
+            i = e.exec(t);
         }
-        return i;
+        return n;
     };
-    const o = function(e) {
-        const t = s.exec(e);
-        return !(t === null || typeof t === "undefined");
+    const o = function(t) {
+        const e = s.exec(t);
+        return !(e === null || typeof e === "undefined");
     };
-    e.isExist = function(e) {
-        return typeof e !== "undefined";
+    t.isExist = function(t) {
+        return typeof t !== "undefined";
     };
-    e.isEmptyObject = function(e) {
-        return Object.keys(e).length === 0;
+    t.isEmptyObject = function(t) {
+        return Object.keys(t).length === 0;
     };
-    e.merge = function(e, t, i) {
-        if (t) {
-            const n = Object.keys(t);
-            const s = n.length;
+    t.merge = function(t, e, n) {
+        if (e) {
+            const i = Object.keys(e);
+            const s = i.length;
             for (let r = 0; r < s; r++) {
-                if (i === "strict") {
-                    e[n[r]] = [ t[n[r]] ];
+                if (n === "strict") {
+                    t[i[r]] = [ e[i[r]] ];
                 } else {
-                    e[n[r]] = t[n[r]];
+                    t[i[r]] = e[i[r]];
                 }
             }
         }
     };
-    e.getValue = function(t) {
-        if (e.isExist(t)) {
-            return t;
+    t.getValue = function(e) {
+        if (t.isExist(e)) {
+            return e;
         } else {
             return "";
         }
     };
-    e.isName = o;
-    e.getAllMatches = r;
-    e.nameRegexp = n;
-})(i);
+    t.isName = o;
+    t.getAllMatches = r;
+    t.nameRegexp = i;
+})(n);
 
-const n = e(i);
+const i = t(n);
 
 "use strict";
 
-const s = i;
+const s = n;
 
 const r = {
     allowBooleanAttributes: false,
     unpairedTags: []
 };
 
-var o = t.validate = function(e, t) {
-    t = Object.assign({}, r, t);
-    const i = [];
-    let n = false;
+var o = e.validate = function(t, e) {
+    e = Object.assign({}, r, e);
+    const n = [];
+    let i = false;
     let s = false;
-    if (e[0] === "\ufeff") {
-        e = e.substr(1);
+    if (t[0] === "\ufeff") {
+        t = t.substr(1);
     }
-    for (let r = 0; r < e.length; r++) {
-        if (e[r] === "<" && e[r + 1] === "?") {
+    for (let r = 0; r < t.length; r++) {
+        if (t[r] === "<" && t[r + 1] === "?") {
             r += 2;
-            r = l(e, r);
+            r = l(t, r);
             if (r.err) return r;
-        } else if (e[r] === "<") {
+        } else if (t[r] === "<") {
             let o = r;
             r++;
-            if (e[r] === "!") {
-                r = u(e, r);
+            if (t[r] === "!") {
+                r = u(t, r);
                 continue;
             } else {
                 let f = false;
-                if (e[r] === "/") {
+                if (t[r] === "/") {
                     f = true;
                     r++;
                 }
                 let c = "";
-                for (;r < e.length && e[r] !== ">" && e[r] !== " " && e[r] !== "\t" && e[r] !== "\n" && e[r] !== "\r"; r++) {
-                    c += e[r];
+                for (;r < t.length && t[r] !== ">" && t[r] !== " " && t[r] !== "\t" && t[r] !== "\n" && t[r] !== "\r"; r++) {
+                    c += t[r];
                 }
                 c = c.trim();
                 if (c[c.length - 1] === "/") {
@@ -106,98 +106,100 @@ var o = t.validate = function(e, t) {
                     r--;
                 }
                 if (!b(c)) {
-                    let t;
+                    let e;
                     if (c.trim().length === 0) {
-                        t = "Invalid space after '<'.";
+                        e = "Invalid space after '<'.";
                     } else {
-                        t = "Tag '" + c + "' is an invalid name.";
+                        e = "Tag '" + c + "' is an invalid name.";
                     }
-                    return x("InvalidTag", t, E(e, r));
+                    return x("InvalidTag", e, E(t, r));
                 }
-                const h = d(e, r);
-                if (h === false) {
-                    return x("InvalidAttr", "Attributes for '" + c + "' have open quote.", E(e, r));
+                const d = h(t, r);
+                if (d === false) {
+                    return x("InvalidAttr", "Attributes for '" + c + "' have open quote.", E(t, r));
                 }
-                let g = h.value;
-                r = h.index;
+                let g = d.value;
+                r = d.index;
                 if (g[g.length - 1] === "/") {
-                    const i = r - g.length;
+                    const n = r - g.length;
                     g = g.substring(0, g.length - 1);
-                    const s = p(g, t);
+                    const s = p(g, e);
                     if (s === true) {
-                        n = true;
+                        i = true;
                     } else {
-                        return x(s.err.code, s.err.msg, E(e, i + s.err.line));
+                        return x(s.err.code, s.err.msg, E(t, n + s.err.line));
                     }
                 } else if (f) {
-                    if (!h.tagClosed) {
-                        return x("InvalidTag", "Closing tag '" + c + "' doesn't have proper closing.", E(e, r));
+                    if (!d.tagClosed) {
+                        return x("InvalidTag", "Closing tag '" + c + "' doesn't have proper closing.", E(t, r));
                     } else if (g.trim().length > 0) {
-                        return x("InvalidTag", "Closing tag '" + c + "' can't have attributes or invalid starting.", E(e, o));
+                        return x("InvalidTag", "Closing tag '" + c + "' can't have attributes or invalid starting.", E(t, o));
+                    } else if (n.length === 0) {
+                        return x("InvalidTag", "Closing tag '" + c + "' has not been opened.", E(t, o));
                     } else {
-                        const t = i.pop();
-                        if (c !== t.tagName) {
-                            let i = E(e, t.tagStartPos);
-                            return x("InvalidTag", "Expected closing tag '" + t.tagName + "' (opened in line " + i.line + ", col " + i.col + ") instead of closing tag '" + c + "'.", E(e, o));
+                        const e = n.pop();
+                        if (c !== e.tagName) {
+                            let n = E(t, e.tagStartPos);
+                            return x("InvalidTag", "Expected closing tag '" + e.tagName + "' (opened in line " + n.line + ", col " + n.col + ") instead of closing tag '" + c + "'.", E(t, o));
                         }
-                        if (i.length == 0) {
+                        if (n.length == 0) {
                             s = true;
                         }
                     }
                 } else {
-                    const a = p(g, t);
+                    const a = p(g, e);
                     if (a !== true) {
-                        return x(a.err.code, a.err.msg, E(e, r - g.length + a.err.line));
+                        return x(a.err.code, a.err.msg, E(t, r - g.length + a.err.line));
                     }
                     if (s === true) {
-                        return x("InvalidXml", "Multiple possible root nodes found.", E(e, r));
-                    } else if (t.unpairedTags.indexOf(c) !== -1) {} else {
-                        i.push({
+                        return x("InvalidXml", "Multiple possible root nodes found.", E(t, r));
+                    } else if (e.unpairedTags.indexOf(c) !== -1) {} else {
+                        n.push({
                             tagName: c,
                             tagStartPos: o
                         });
                     }
-                    n = true;
+                    i = true;
                 }
-                for (r++; r < e.length; r++) {
-                    if (e[r] === "<") {
-                        if (e[r + 1] === "!") {
+                for (r++; r < t.length; r++) {
+                    if (t[r] === "<") {
+                        if (t[r + 1] === "!") {
                             r++;
-                            r = u(e, r);
+                            r = u(t, r);
                             continue;
-                        } else if (e[r + 1] === "?") {
-                            r = l(e, ++r);
+                        } else if (t[r + 1] === "?") {
+                            r = l(t, ++r);
                             if (r.err) return r;
                         } else {
                             break;
                         }
-                    } else if (e[r] === "&") {
-                        const t = m(e, r);
-                        if (t == -1) return x("InvalidChar", "char '&' is not expected.", E(e, r));
-                        r = t;
+                    } else if (t[r] === "&") {
+                        const e = m(t, r);
+                        if (e == -1) return x("InvalidChar", "char '&' is not expected.", E(t, r));
+                        r = e;
                     } else {
-                        if (s === true && !a(e[r])) {
-                            return x("InvalidXml", "Extra text at the end", E(e, r));
+                        if (s === true && !a(t[r])) {
+                            return x("InvalidXml", "Extra text at the end", E(t, r));
                         }
                     }
                 }
-                if (e[r] === "<") {
+                if (t[r] === "<") {
                     r--;
                 }
             }
         } else {
-            if (a(e[r])) {
+            if (a(t[r])) {
                 continue;
             }
-            return x("InvalidChar", "char '" + e[r] + "' is not expected.", E(e, r));
+            return x("InvalidChar", "char '" + t[r] + "' is not expected.", E(t, r));
         }
     }
-    if (!n) {
+    if (!i) {
         return x("InvalidXml", "Start tag expected.", 1);
-    } else if (i.length == 1) {
-        return x("InvalidTag", "Unclosed tag '" + i[0].tagName + "'.", E(e, i[0].tagStartPos));
-    } else if (i.length > 0) {
-        return x("InvalidXml", "Invalid '" + JSON.stringify(i.map((e => e.tagName)), null, 4).replace(/\r?\n/g, "") + "' found.", {
+    } else if (n.length == 1) {
+        return x("InvalidTag", "Unclosed tag '" + n[0].tagName + "'.", E(t, n[0].tagStartPos));
+    } else if (n.length > 0) {
+        return x("InvalidXml", "Invalid '" + JSON.stringify(n.map((t => t.tagName)), null, 4).replace(/\r?\n/g, "") + "' found.", {
             line: 1,
             col: 1
         });
@@ -205,176 +207,176 @@ var o = t.validate = function(e, t) {
     return true;
 };
 
-function a(e) {
-    return e === " " || e === "\t" || e === "\n" || e === "\r";
+function a(t) {
+    return t === " " || t === "\t" || t === "\n" || t === "\r";
 }
 
-function l(e, t) {
-    const i = t;
-    for (;t < e.length; t++) {
-        if (e[t] == "?" || e[t] == " ") {
-            const n = e.substr(i, t - i);
-            if (t > 5 && n === "xml") {
-                return x("InvalidXml", "XML declaration allowed only at the start of the document.", E(e, t));
-            } else if (e[t] == "?" && e[t + 1] == ">") {
-                t++;
+function l(t, e) {
+    const n = e;
+    for (;e < t.length; e++) {
+        if (t[e] == "?" || t[e] == " ") {
+            const i = t.substr(n, e - n);
+            if (e > 5 && i === "xml") {
+                return x("InvalidXml", "XML declaration allowed only at the start of the document.", E(t, e));
+            } else if (t[e] == "?" && t[e + 1] == ">") {
+                e++;
                 break;
             } else {
                 continue;
             }
         }
     }
-    return t;
+    return e;
 }
 
-function u(e, t) {
-    if (e.length > t + 5 && e[t + 1] === "-" && e[t + 2] === "-") {
-        for (t += 3; t < e.length; t++) {
-            if (e[t] === "-" && e[t + 1] === "-" && e[t + 2] === ">") {
-                t += 2;
+function u(t, e) {
+    if (t.length > e + 5 && t[e + 1] === "-" && t[e + 2] === "-") {
+        for (e += 3; e < t.length; e++) {
+            if (t[e] === "-" && t[e + 1] === "-" && t[e + 2] === ">") {
+                e += 2;
                 break;
             }
         }
-    } else if (e.length > t + 8 && e[t + 1] === "D" && e[t + 2] === "O" && e[t + 3] === "C" && e[t + 4] === "T" && e[t + 5] === "Y" && e[t + 6] === "P" && e[t + 7] === "E") {
-        let i = 1;
-        for (t += 8; t < e.length; t++) {
-            if (e[t] === "<") {
-                i++;
-            } else if (e[t] === ">") {
-                i--;
-                if (i === 0) {
+    } else if (t.length > e + 8 && t[e + 1] === "D" && t[e + 2] === "O" && t[e + 3] === "C" && t[e + 4] === "T" && t[e + 5] === "Y" && t[e + 6] === "P" && t[e + 7] === "E") {
+        let n = 1;
+        for (e += 8; e < t.length; e++) {
+            if (t[e] === "<") {
+                n++;
+            } else if (t[e] === ">") {
+                n--;
+                if (n === 0) {
                     break;
                 }
             }
         }
-    } else if (e.length > t + 9 && e[t + 1] === "[" && e[t + 2] === "C" && e[t + 3] === "D" && e[t + 4] === "A" && e[t + 5] === "T" && e[t + 6] === "A" && e[t + 7] === "[") {
-        for (t += 8; t < e.length; t++) {
-            if (e[t] === "]" && e[t + 1] === "]" && e[t + 2] === ">") {
-                t += 2;
+    } else if (t.length > e + 9 && t[e + 1] === "[" && t[e + 2] === "C" && t[e + 3] === "D" && t[e + 4] === "A" && t[e + 5] === "T" && t[e + 6] === "A" && t[e + 7] === "[") {
+        for (e += 8; e < t.length; e++) {
+            if (t[e] === "]" && t[e + 1] === "]" && t[e + 2] === ">") {
+                e += 2;
                 break;
             }
         }
     }
-    return t;
+    return e;
 }
 
 const f = '"';
 
 const c = "'";
 
-function d(e, t) {
-    let i = "";
+function h(t, e) {
     let n = "";
+    let i = "";
     let s = false;
-    for (;t < e.length; t++) {
-        if (e[t] === f || e[t] === c) {
-            if (n === "") {
-                n = e[t];
-            } else if (n !== e[t]) {} else {
-                n = "";
+    for (;e < t.length; e++) {
+        if (t[e] === f || t[e] === c) {
+            if (i === "") {
+                i = t[e];
+            } else if (i !== t[e]) {} else {
+                i = "";
             }
-        } else if (e[t] === ">") {
-            if (n === "") {
+        } else if (t[e] === ">") {
+            if (i === "") {
                 s = true;
                 break;
             }
         }
-        i += e[t];
+        n += t[e];
     }
-    if (n !== "") {
+    if (i !== "") {
         return false;
     }
     return {
-        value: i,
-        index: t,
+        value: n,
+        index: e,
         tagClosed: s
     };
 }
 
-const h = new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?", "g");
+const d = new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?", "g");
 
-function p(e, t) {
-    const i = s.getAllMatches(e, h);
-    const n = {};
-    for (let e = 0; e < i.length; e++) {
-        if (i[e][1].length === 0) {
-            return x("InvalidAttr", "Attribute '" + i[e][2] + "' has no space in starting.", v(i[e]));
-        } else if (i[e][3] !== undefined && i[e][4] === undefined) {
-            return x("InvalidAttr", "Attribute '" + i[e][2] + "' is without value.", v(i[e]));
-        } else if (i[e][3] === undefined && !t.allowBooleanAttributes) {
-            return x("InvalidAttr", "boolean attribute '" + i[e][2] + "' is not allowed.", v(i[e]));
+function p(t, e) {
+    const n = s.getAllMatches(t, d);
+    const i = {};
+    for (let t = 0; t < n.length; t++) {
+        if (n[t][1].length === 0) {
+            return x("InvalidAttr", "Attribute '" + n[t][2] + "' has no space in starting.", v(n[t]));
+        } else if (n[t][3] !== undefined && n[t][4] === undefined) {
+            return x("InvalidAttr", "Attribute '" + n[t][2] + "' is without value.", v(n[t]));
+        } else if (n[t][3] === undefined && !e.allowBooleanAttributes) {
+            return x("InvalidAttr", "boolean attribute '" + n[t][2] + "' is not allowed.", v(n[t]));
         }
-        const s = i[e][2];
+        const s = n[t][2];
         if (!N(s)) {
-            return x("InvalidAttr", "Attribute '" + s + "' is an invalid name.", v(i[e]));
+            return x("InvalidAttr", "Attribute '" + s + "' is an invalid name.", v(n[t]));
         }
-        if (!n.hasOwnProperty(s)) {
-            n[s] = 1;
+        if (!i.hasOwnProperty(s)) {
+            i[s] = 1;
         } else {
-            return x("InvalidAttr", "Attribute '" + s + "' is repeated.", v(i[e]));
+            return x("InvalidAttr", "Attribute '" + s + "' is repeated.", v(n[t]));
         }
     }
     return true;
 }
 
-function g(e, t) {
-    let i = /\d/;
-    if (e[t] === "x") {
-        t++;
-        i = /[\da-fA-F]/;
+function g(t, e) {
+    let n = /\d/;
+    if (t[e] === "x") {
+        e++;
+        n = /[\da-fA-F]/;
     }
-    for (;t < e.length; t++) {
-        if (e[t] === ";") return t;
-        if (!e[t].match(i)) break;
+    for (;e < t.length; e++) {
+        if (t[e] === ";") return e;
+        if (!t[e].match(n)) break;
     }
     return -1;
 }
 
-function m(e, t) {
-    t++;
-    if (e[t] === ";") return -1;
-    if (e[t] === "#") {
-        t++;
-        return g(e, t);
-    }
-    let i = 0;
-    for (;t < e.length; t++, i++) {
-        if (e[t].match(/\w/) && i < 20) continue;
-        if (e[t] === ";") break;
+function m(t, e) {
+    e++;
+    if (t[e] === ";") return -1;
+    if (t[e] === "#") {
+        e++;
+        return g(t, e);
+    }
+    let n = 0;
+    for (;e < t.length; e++, n++) {
+        if (t[e].match(/\w/) && n < 20) continue;
+        if (t[e] === ";") break;
         return -1;
     }
-    return t;
+    return e;
 }
 
-function x(e, t, i) {
+function x(t, e, n) {
     return {
         err: {
-            code: e,
-            msg: t,
-            line: i.line || i,
-            col: i.col
+            code: t,
+            msg: e,
+            line: n.line || n,
+            col: n.col
         }
     };
 }
 
-function N(e) {
-    return s.isName(e);
+function N(t) {
+    return s.isName(t);
 }
 
-function b(e) {
-    return s.isName(e);
+function b(t) {
+    return s.isName(t);
 }
 
-function E(e, t) {
-    const i = e.substring(0, t).split(/\r?\n/);
+function E(t, e) {
+    const n = t.substring(0, e).split(/\r?\n/);
     return {
-        line: i.length,
-        col: i[i.length - 1].length + 1
+        line: n.length,
+        col: n[n.length - 1].length + 1
     };
 }
 
-function v(e) {
-    return e.startIndex + e[1].length;
+function v(t) {
+    return t.startIndex + t[1].length;
 }
 
 var y = {};
@@ -396,11 +398,11 @@ const T = {
         leadingZeros: true,
         eNotation: true
     },
-    tagValueProcessor: function(e, t) {
-        return t;
+    tagValueProcessor: function(t, e) {
+        return e;
     },
-    attributeValueProcessor: function(e, t) {
-        return t;
+    attributeValueProcessor: function(t, e) {
+        return e;
     },
     stopNodes: [],
     alwaysCreateTextNode: false,
@@ -413,150 +415,151 @@ const T = {
     ignorePiTags: false,
     transformTagName: false,
     transformAttributeName: false,
-    updateTag: function(e, t, i) {
-        return e;
+    updateTag: function(t, e, n) {
+        return t;
     }
 };
 
-const O = function(e) {
-    return Object.assign({}, T, e);
+const O = function(t) {
+    return Object.assign({}, T, t);
 };
 
-var w = y.buildOptions = O;
+var A = y.buildOptions = O;
 
 var P = y.defaultOptions = T;
 
 "use strict";
 
 class XmlNode {
-    constructor(e) {
-        this.tagname = e;
+    constructor(t) {
+        this.tagname = t;
         this.child = [];
         this[":@"] = {};
     }
-    add(e, t) {
-        if (e === "__proto__") e = "#__proto__";
+    add(t, e) {
+        if (t === "__proto__") t = "#__proto__";
         this.child.push({
-            [e]: t
+            [t]: e
         });
     }
-    addChild(e) {
-        if (e.tagname === "__proto__") e.tagname = "#__proto__";
-        if (e[":@"] && Object.keys(e[":@"]).length > 0) {
+    addChild(t) {
+        if (t.tagname === "__proto__") t.tagname = "#__proto__";
+        if (t[":@"] && Object.keys(t[":@"]).length > 0) {
             this.child.push({
-                [e.tagname]: e.child,
-                [":@"]: e[":@"]
+                [t.tagname]: t.child,
+                [":@"]: t[":@"]
             });
         } else {
             this.child.push({
-                [e.tagname]: e.child
+                [t.tagname]: t.child
             });
         }
     }
 }
 
-var A = XmlNode;
+var w = XmlNode;
 
-const I = e(A);
+const C = t(w);
 
-const C = i;
+const I = n;
 
-function j(e, t) {
-    const i = {};
-    if (e[t + 3] === "O" && e[t + 4] === "C" && e[t + 5] === "T" && e[t + 6] === "Y" && e[t + 7] === "P" && e[t + 8] === "E") {
-        t = t + 9;
-        let n = 1;
+function S(t, e) {
+    const n = {};
+    if (t[e + 3] === "O" && t[e + 4] === "C" && t[e + 5] === "T" && t[e + 6] === "Y" && t[e + 7] === "P" && t[e + 8] === "E") {
+        e = e + 9;
+        let i = 1;
         let s = false, r = false;
         let o = "";
-        for (;t < e.length; t++) {
-            if (e[t] === "<" && !r) {
-                if (s && k(e, t)) {
-                    t += 7;
-                    [entityName, val, t] = S(e, t + 1);
-                    if (val.indexOf("&") === -1) i[_(entityName)] = {
-                        regx: RegExp(`&${entityName};`, "g"),
-                        val: val
+        for (;e < t.length; e++) {
+            if (t[e] === "<" && !r) {
+                if (s && k(t, e)) {
+                    e += 7;
+                    let i, s;
+                    [i, s, e] = j(t, e + 1);
+                    if (s.indexOf("&") === -1) n[D(i)] = {
+                        regx: RegExp(`&${i};`, "g"),
+                        val: s
                     };
-                } else if (s && $(e, t)) t += 8; else if (s && F(e, t)) t += 8; else if (s && D(e, t)) t += 9; else if (V) r = true; else throw new Error("Invalid DOCTYPE");
-                n++;
+                } else if (s && F(t, e)) e += 8; else if (s && $(t, e)) e += 8; else if (s && _(t, e)) e += 9; else if (V) r = true; else throw new Error("Invalid DOCTYPE");
+                i++;
                 o = "";
-            } else if (e[t] === ">") {
+            } else if (t[e] === ">") {
                 if (r) {
-                    if (e[t - 1] === "-" && e[t - 2] === "-") {
+                    if (t[e - 1] === "-" && t[e - 2] === "-") {
                         r = false;
-                        n--;
+                        i--;
                     }
                 } else {
-                    n--;
+                    i--;
                 }
-                if (n === 0) {
+                if (i === 0) {
                     break;
                 }
-            } else if (e[t] === "[") {
+            } else if (t[e] === "[") {
                 s = true;
             } else {
-                o += e[t];
+                o += t[e];
             }
         }
-        if (n !== 0) {
+        if (i !== 0) {
             throw new Error(`Unclosed DOCTYPE`);
         }
     } else {
         throw new Error(`Invalid Tag instead of DOCTYPE`);
     }
     return {
-        entities: i,
-        i: t
+        entities: n,
+        i: e
     };
 }
 
-function S(e, t) {
-    let i = "";
-    for (;t < e.length && (e[t] !== "'" && e[t] !== '"'); t++) {
-        i += e[t];
+function j(t, e) {
+    let n = "";
+    for (;e < t.length && (t[e] !== "'" && t[e] !== '"'); e++) {
+        n += t[e];
     }
-    i = i.trim();
-    if (i.indexOf(" ") !== -1) throw new Error("External entites are not supported");
-    const n = e[t++];
+    n = n.trim();
+    if (n.indexOf(" ") !== -1) throw new Error("External entites are not supported");
+    const i = t[e++];
     let s = "";
-    for (;t < e.length && e[t] !== n; t++) {
-        s += e[t];
+    for (;e < t.length && t[e] !== i; e++) {
+        s += t[e];
     }
-    return [ i, s, t ];
+    return [ n, s, e ];
 }
 
-function V(e, t) {
-    if (e[t + 1] === "!" && e[t + 2] === "-" && e[t + 3] === "-") return true;
+function V(t, e) {
+    if (t[e + 1] === "!" && t[e + 2] === "-" && t[e + 3] === "-") return true;
     return false;
 }
 
-function k(e, t) {
-    if (e[t + 1] === "!" && e[t + 2] === "E" && e[t + 3] === "N" && e[t + 4] === "T" && e[t + 5] === "I" && e[t + 6] === "T" && e[t + 7] === "Y") return true;
+function k(t, e) {
+    if (t[e + 1] === "!" && t[e + 2] === "E" && t[e + 3] === "N" && t[e + 4] === "T" && t[e + 5] === "I" && t[e + 6] === "T" && t[e + 7] === "Y") return true;
     return false;
 }
 
-function $(e, t) {
-    if (e[t + 1] === "!" && e[t + 2] === "E" && e[t + 3] === "L" && e[t + 4] === "E" && e[t + 5] === "M" && e[t + 6] === "E" && e[t + 7] === "N" && e[t + 8] === "T") return true;
+function F(t, e) {
+    if (t[e + 1] === "!" && t[e + 2] === "E" && t[e + 3] === "L" && t[e + 4] === "E" && t[e + 5] === "M" && t[e + 6] === "E" && t[e + 7] === "N" && t[e + 8] === "T") return true;
     return false;
 }
 
-function F(e, t) {
-    if (e[t + 1] === "!" && e[t + 2] === "A" && e[t + 3] === "T" && e[t + 4] === "T" && e[t + 5] === "L" && e[t + 6] === "I" && e[t + 7] === "S" && e[t + 8] === "T") return true;
+function $(t, e) {
+    if (t[e + 1] === "!" && t[e + 2] === "A" && t[e + 3] === "T" && t[e + 4] === "T" && t[e + 5] === "L" && t[e + 6] === "I" && t[e + 7] === "S" && t[e + 8] === "T") return true;
     return false;
 }
 
-function D(e, t) {
-    if (e[t + 1] === "!" && e[t + 2] === "N" && e[t + 3] === "O" && e[t + 4] === "T" && e[t + 5] === "A" && e[t + 6] === "T" && e[t + 7] === "I" && e[t + 8] === "O" && e[t + 9] === "N") return true;
+function _(t, e) {
+    if (t[e + 1] === "!" && t[e + 2] === "N" && t[e + 3] === "O" && t[e + 4] === "T" && t[e + 5] === "A" && t[e + 6] === "T" && t[e + 7] === "I" && t[e + 8] === "O" && t[e + 9] === "N") return true;
     return false;
 }
 
-function _(e) {
-    if (C.isName(e)) return e; else throw new Error(`Invalid entity name ${e}`);
+function D(t) {
+    if (I.isName(t)) return t; else throw new Error(`Invalid entity name ${t}`);
 }
 
-var L = j;
+var L = S;
 
-const M = e(L);
+const M = t(L);
 
 const B = /^[-+]?0x[a-fA-F0-9]+$/;
 
@@ -570,74 +573,99 @@ if (!Number.parseFloat && window.parseFloat) {
     Number.parseFloat = window.parseFloat;
 }
 
-const R = {
+const G = {
     hex: true,
     leadingZeros: true,
     decimalPoint: ".",
     eNotation: true
 };
 
-function G(e, t = {}) {
-    t = Object.assign({}, R, t);
-    if (!e || typeof e !== "string") return e;
-    let i = e.trim();
-    if (t.skipLike !== undefined && t.skipLike.test(i)) return e; else if (t.hex && B.test(i)) {
-        return Number.parseInt(i, 16);
+function R(t, e = {}) {
+    e = Object.assign({}, G, e);
+    if (!t || typeof t !== "string") return t;
+    let n = t.trim();
+    if (e.skipLike !== undefined && e.skipLike.test(n)) return t; else if (e.hex && B.test(n)) {
+        return Number.parseInt(n, 16);
     } else {
-        const n = X.exec(i);
-        if (n) {
-            const s = n[1];
-            const r = n[2];
-            let o = U(n[3]);
-            const a = n[4] || n[6];
-            if (!t.leadingZeros && r.length > 0 && s && i[2] !== ".") return e; else if (!t.leadingZeros && r.length > 0 && !s && i[1] !== ".") return e; else {
-                const n = Number(i);
-                const l = "" + n;
+        const i = X.exec(n);
+        if (i) {
+            const s = i[1];
+            const r = i[2];
+            let o = U(i[3]);
+            const a = i[4] || i[6];
+            if (!e.leadingZeros && r.length > 0 && s && n[2] !== ".") return t; else if (!e.leadingZeros && r.length > 0 && !s && n[1] !== ".") return t; else {
+                const i = Number(n);
+                const l = "" + i;
                 if (l.search(/[eE]/) !== -1) {
-                    if (t.eNotation) return n; else return e;
+                    if (e.eNotation) return i; else return t;
                 } else if (a) {
-                    if (t.eNotation) return n; else return e;
-                } else if (i.indexOf(".") !== -1) {
-                    if (l === "0" && o === "") return n; else if (l === o) return n; else if (s && l === "-" + o) return n; else return e;
+                    if (e.eNotation) return i; else return t;
+                } else if (n.indexOf(".") !== -1) {
+                    if (l === "0" && o === "") return i; else if (l === o) return i; else if (s && l === "-" + o) return i; else return t;
                 }
                 if (r) {
-                    if (o === l) return n; else if (s + o === l) return n; else return e;
+                    if (o === l) return i; else if (s + o === l) return i; else return t;
                 }
-                if (i === l) return n; else if (i === s + l) return n;
-                return e;
+                if (n === l) return i; else if (n === s + l) return i;
+                return t;
             }
         } else {
-            return e;
+            return t;
         }
     }
 }
 
-function U(e) {
-    if (e && e.indexOf(".") !== -1) {
-        e = e.replace(/0+$/, "");
-        if (e === ".") e = "0"; else if (e[0] === ".") e = "0" + e; else if (e[e.length - 1] === ".") e = e.substr(0, e.length - 1);
-        return e;
+function U(t) {
+    if (t && t.indexOf(".") !== -1) {
+        t = t.replace(/0+$/, "");
+        if (t === ".") t = "0"; else if (t[0] === ".") t = "0" + t; else if (t[t.length - 1] === ".") t = t.substr(0, t.length - 1);
+        return t;
     }
-    return e;
+    return t;
+}
+
+var Y = R;
+
+const Z = t(Y);
+
+function q(t) {
+    if (typeof t === "function") {
+        return t;
+    }
+    if (Array.isArray(t)) {
+        return e => {
+            for (const n of t) {
+                if (typeof n === "string" && e === n) {
+                    return true;
+                }
+                if (n instanceof RegExp && n.test(e)) {
+                    return true;
+                }
+            }
+        };
+    }
+    return () => false;
 }
 
-var Y = G;
+var W = q;
 
-const Z = e(Y);
+const z = t(W);
 
 "use strict";
 
-const q = i;
+const J = n;
+
+const H = w;
 
-const W = A;
+const K = L;
 
-const z = L;
+const Q = Y;
 
-const J = Y;
+const tt = W;
 
-let H = class OrderedObjParser {
-    constructor(e) {
-        this.options = e;
+let et = class OrderedObjParser {
+    constructor(t) {
+        this.options = t;
         this.currentNode = null;
         this.tagsNodeStack = [];
         this.docTypeEntities = {};
@@ -695,84 +723,96 @@ let H = class OrderedObjParser {
             inr: {
                 regex: /&(inr|#8377);/g,
                 val: "₹"
+            },
+            num_dec: {
+                regex: /&#([0-9]{1,7});/g,
+                val: (t, e) => String.fromCharCode(Number.parseInt(e, 10))
+            },
+            num_hex: {
+                regex: /&#x([0-9a-fA-F]{1,6});/g,
+                val: (t, e) => String.fromCharCode(Number.parseInt(e, 16))
             }
         };
-        this.addExternalEntities = K;
-        this.parseXml = ne;
-        this.parseTextData = Q;
-        this.resolveNameSpace = ee;
-        this.buildAttributesMap = ie;
-        this.isItStopNode = ae;
-        this.replaceEntitiesValue = re;
-        this.readStopNodeData = ce;
-        this.saveTextToParentTag = oe;
-        this.addChild = se;
+        this.addExternalEntities = nt;
+        this.parseXml = at;
+        this.parseTextData = it;
+        this.resolveNameSpace = st;
+        this.buildAttributesMap = ot;
+        this.isItStopNode = ct;
+        this.replaceEntitiesValue = ut;
+        this.readStopNodeData = gt;
+        this.saveTextToParentTag = ft;
+        this.addChild = lt;
+        this.ignoreAttributesFn = tt(this.options.ignoreAttributes);
     }
 };
 
-function K(e) {
-    const t = Object.keys(e);
-    for (let i = 0; i < t.length; i++) {
-        const n = t[i];
-        this.lastEntities[n] = {
-            regex: new RegExp("&" + n + ";", "g"),
-            val: e[n]
+function nt(t) {
+    const e = Object.keys(t);
+    for (let n = 0; n < e.length; n++) {
+        const i = e[n];
+        this.lastEntities[i] = {
+            regex: new RegExp("&" + i + ";", "g"),
+            val: t[i]
         };
     }
 }
 
-function Q(e, t, i, n, s, r, o) {
-    if (e !== undefined) {
-        if (this.options.trimValues && !n) {
-            e = e.trim();
+function it(t, e, n, i, s, r, o) {
+    if (t !== undefined) {
+        if (this.options.trimValues && !i) {
+            t = t.trim();
         }
-        if (e.length > 0) {
-            if (!o) e = this.replaceEntitiesValue(e);
-            const n = this.options.tagValueProcessor(t, e, i, s, r);
-            if (n === null || n === undefined) {
-                return e;
-            } else if (typeof n !== typeof e || n !== e) {
-                return n;
+        if (t.length > 0) {
+            if (!o) t = this.replaceEntitiesValue(t);
+            const i = this.options.tagValueProcessor(e, t, n, s, r);
+            if (i === null || i === undefined) {
+                return t;
+            } else if (typeof i !== typeof t || i !== t) {
+                return i;
             } else if (this.options.trimValues) {
-                return de(e, this.options.parseTagValue, this.options.numberParseOptions);
+                return mt(t, this.options.parseTagValue, this.options.numberParseOptions);
             } else {
-                const t = e.trim();
-                if (t === e) {
-                    return de(e, this.options.parseTagValue, this.options.numberParseOptions);
+                const e = t.trim();
+                if (e === t) {
+                    return mt(t, this.options.parseTagValue, this.options.numberParseOptions);
                 } else {
-                    return e;
+                    return t;
                 }
             }
         }
     }
 }
 
-function ee(e) {
+function st(t) {
     if (this.options.removeNSPrefix) {
-        const t = e.split(":");
-        const i = e.charAt(0) === "/" ? "/" : "";
-        if (t[0] === "xmlns") {
+        const e = t.split(":");
+        const n = t.charAt(0) === "/" ? "/" : "";
+        if (e[0] === "xmlns") {
             return "";
         }
-        if (t.length === 2) {
-            e = i + t[1];
+        if (e.length === 2) {
+            t = n + e[1];
         }
     }
-    return e;
+    return t;
 }
 
-const te = new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?", "gm");
+const rt = new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?", "gm");
 
-function ie(e, t, i) {
-    if (!this.options.ignoreAttributes && typeof e === "string") {
-        const i = q.getAllMatches(e, te);
-        const n = i.length;
+function ot(t, e, n) {
+    if (this.options.ignoreAttributes !== true && typeof t === "string") {
+        const n = J.getAllMatches(t, rt);
+        const i = n.length;
         const s = {};
-        for (let e = 0; e < n; e++) {
-            const n = this.resolveNameSpace(i[e][1]);
-            let r = i[e][4];
-            let o = this.options.attributeNamePrefix + n;
-            if (n.length) {
+        for (let t = 0; t < i; t++) {
+            const i = this.resolveNameSpace(n[t][1]);
+            if (this.ignoreAttributesFn(i, e)) {
+                continue;
+            }
+            let r = n[t][4];
+            let o = this.options.attributeNamePrefix + i;
+            if (i.length) {
                 if (this.options.transformAttributeName) {
                     o = this.options.transformAttributeName(o);
                 }
@@ -782,13 +822,13 @@ function ie(e, t, i) {
                         r = r.trim();
                     }
                     r = this.replaceEntitiesValue(r);
-                    const e = this.options.attributeValueProcessor(n, r, t);
-                    if (e === null || e === undefined) {
+                    const t = this.options.attributeValueProcessor(i, r, e);
+                    if (t === null || t === undefined) {
                         s[o] = r;
-                    } else if (typeof e !== typeof r || e !== r) {
-                        s[o] = e;
+                    } else if (typeof t !== typeof r || t !== r) {
+                        s[o] = t;
                     } else {
-                        s[o] = de(r, this.options.parseAttributeValue, this.options.numberParseOptions);
+                        s[o] = mt(r, this.options.parseAttributeValue, this.options.numberParseOptions);
                     }
                 } else if (this.options.allowBooleanAttributes) {
                     s[o] = true;
@@ -799,37 +839,37 @@ function ie(e, t, i) {
             return;
         }
         if (this.options.attributesGroupName) {
-            const e = {};
-            e[this.options.attributesGroupName] = s;
-            return e;
+            const t = {};
+            t[this.options.attributesGroupName] = s;
+            return t;
         }
         return s;
     }
 }
 
-const ne = function(e) {
-    e = e.replace(/\r\n?/g, "\n");
-    const t = new W("!xml");
-    let i = t;
-    let n = "";
+const at = function(t) {
+    t = t.replace(/\r\n?/g, "\n");
+    const e = new H("!xml");
+    let n = e;
+    let i = "";
     let s = "";
-    for (let r = 0; r < e.length; r++) {
-        const o = e[r];
+    for (let r = 0; r < t.length; r++) {
+        const o = t[r];
         if (o === "<") {
-            if (e[r + 1] === "/") {
-                const t = ue(e, ">", r, "Closing Tag is not closed.");
-                let o = e.substring(r + 2, t).trim();
+            if (t[r + 1] === "/") {
+                const e = dt(t, ">", r, "Closing Tag is not closed.");
+                let o = t.substring(r + 2, e).trim();
                 if (this.options.removeNSPrefix) {
-                    const e = o.indexOf(":");
-                    if (e !== -1) {
-                        o = o.substr(e + 1);
+                    const t = o.indexOf(":");
+                    if (t !== -1) {
+                        o = o.substr(t + 1);
                     }
                 }
                 if (this.options.transformTagName) {
                     o = this.options.transformTagName(o);
                 }
-                if (i) {
-                    n = this.saveTextToParentTag(n, i, s);
+                if (n) {
+                    i = this.saveTextToParentTag(i, n, s);
                 }
                 const a = s.substring(s.lastIndexOf(".") + 1);
                 if (o && this.options.unpairedTags.indexOf(o) !== -1) {
@@ -843,52 +883,52 @@ const ne = function(e) {
                     l = s.lastIndexOf(".");
                 }
                 s = s.substring(0, l);
-                i = this.tagsNodeStack.pop();
-                n = "";
-                r = t;
-            } else if (e[r + 1] === "?") {
-                let t = fe(e, r, false, "?>");
-                if (!t) throw new Error("Pi Tag is not closed.");
-                n = this.saveTextToParentTag(n, i, s);
-                if (this.options.ignoreDeclaration && t.tagName === "?xml" || this.options.ignorePiTags) {} else {
-                    const e = new W(t.tagName);
-                    e.add(this.options.textNodeName, "");
-                    if (t.tagName !== t.tagExp && t.attrExpPresent) {
-                        e[":@"] = this.buildAttributesMap(t.tagExp, s, t.tagName);
+                n = this.tagsNodeStack.pop();
+                i = "";
+                r = e;
+            } else if (t[r + 1] === "?") {
+                let e = pt(t, r, false, "?>");
+                if (!e) throw new Error("Pi Tag is not closed.");
+                i = this.saveTextToParentTag(i, n, s);
+                if (this.options.ignoreDeclaration && e.tagName === "?xml" || this.options.ignorePiTags) {} else {
+                    const t = new H(e.tagName);
+                    t.add(this.options.textNodeName, "");
+                    if (e.tagName !== e.tagExp && e.attrExpPresent) {
+                        t[":@"] = this.buildAttributesMap(e.tagExp, s, e.tagName);
                     }
-                    this.addChild(i, e, s);
+                    this.addChild(n, t, s);
                 }
-                r = t.closeIndex + 1;
-            } else if (e.substr(r + 1, 3) === "!--") {
-                const t = ue(e, "--\x3e", r + 4, "Comment is not closed.");
+                r = e.closeIndex + 1;
+            } else if (t.substr(r + 1, 3) === "!--") {
+                const e = dt(t, "--\x3e", r + 4, "Comment is not closed.");
                 if (this.options.commentPropName) {
-                    const o = e.substring(r + 4, t - 2);
-                    n = this.saveTextToParentTag(n, i, s);
-                    i.add(this.options.commentPropName, [ {
+                    const o = t.substring(r + 4, e - 2);
+                    i = this.saveTextToParentTag(i, n, s);
+                    n.add(this.options.commentPropName, [ {
                         [this.options.textNodeName]: o
                     } ]);
                 }
-                r = t;
-            } else if (e.substr(r + 1, 2) === "!D") {
-                const t = z(e, r);
-                this.docTypeEntities = t.entities;
-                r = t.i;
-            } else if (e.substr(r + 1, 2) === "![") {
-                const t = ue(e, "]]>", r, "CDATA is not closed.") - 2;
-                const o = e.substring(r + 9, t);
-                n = this.saveTextToParentTag(n, i, s);
-                let a = this.parseTextData(o, i.tagname, s, true, false, true, true);
+                r = e;
+            } else if (t.substr(r + 1, 2) === "!D") {
+                const e = K(t, r);
+                this.docTypeEntities = e.entities;
+                r = e.i;
+            } else if (t.substr(r + 1, 2) === "![") {
+                const e = dt(t, "]]>", r, "CDATA is not closed.") - 2;
+                const o = t.substring(r + 9, e);
+                i = this.saveTextToParentTag(i, n, s);
+                let a = this.parseTextData(o, n.tagname, s, true, false, true, true);
                 if (a == undefined) a = "";
                 if (this.options.cdataPropName) {
-                    i.add(this.options.cdataPropName, [ {
+                    n.add(this.options.cdataPropName, [ {
                         [this.options.textNodeName]: o
                     } ]);
                 } else {
-                    i.add(this.options.textNodeName, a);
+                    n.add(this.options.textNodeName, a);
                 }
-                r = t + 2;
+                r = e + 2;
             } else {
-                let o = fe(e, r, this.options.removeNSPrefix);
+                let o = pt(t, r, this.options.removeNSPrefix);
                 let a = o.tagName;
                 const l = o.rawTagName;
                 let u = o.tagExp;
@@ -897,41 +937,48 @@ const ne = function(e) {
                 if (this.options.transformTagName) {
                     a = this.options.transformTagName(a);
                 }
-                if (i && n) {
-                    if (i.tagname !== "!xml") {
-                        n = this.saveTextToParentTag(n, i, s, false);
+                if (n && i) {
+                    if (n.tagname !== "!xml") {
+                        i = this.saveTextToParentTag(i, n, s, false);
                     }
                 }
-                const d = i;
-                if (d && this.options.unpairedTags.indexOf(d.tagname) !== -1) {
-                    i = this.tagsNodeStack.pop();
+                const h = n;
+                if (h && this.options.unpairedTags.indexOf(h.tagname) !== -1) {
+                    n = this.tagsNodeStack.pop();
                     s = s.substring(0, s.lastIndexOf("."));
                 }
-                if (a !== t.tagname) {
+                if (a !== e.tagname) {
                     s += s ? "." + a : a;
                 }
                 if (this.isItStopNode(this.options.stopNodes, s, a)) {
-                    let t = "";
+                    let e = "";
                     if (u.length > 0 && u.lastIndexOf("/") === u.length - 1) {
+                        if (a[a.length - 1] === "/") {
+                            a = a.substr(0, a.length - 1);
+                            s = s.substr(0, s.length - 1);
+                            u = a;
+                        } else {
+                            u = u.substr(0, u.length - 1);
+                        }
                         r = o.closeIndex;
                     } else if (this.options.unpairedTags.indexOf(a) !== -1) {
                         r = o.closeIndex;
                     } else {
-                        const i = this.readStopNodeData(e, l, c + 1);
-                        if (!i) throw new Error(`Unexpected end of ${l}`);
-                        r = i.i;
-                        t = i.tagContent;
+                        const n = this.readStopNodeData(t, l, c + 1);
+                        if (!n) throw new Error(`Unexpected end of ${l}`);
+                        r = n.i;
+                        e = n.tagContent;
                     }
-                    const n = new W(a);
+                    const i = new H(a);
                     if (a !== u && f) {
-                        n[":@"] = this.buildAttributesMap(u, s, a);
+                        i[":@"] = this.buildAttributesMap(u, s, a);
                     }
-                    if (t) {
-                        t = this.parseTextData(t, a, s, true, f, true, true);
+                    if (e) {
+                        e = this.parseTextData(e, a, s, true, f, true, true);
                     }
                     s = s.substr(0, s.lastIndexOf("."));
-                    n.add(this.options.textNodeName, t);
-                    this.addChild(i, n, s);
+                    i.add(this.options.textNodeName, e);
+                    this.addChild(n, i, s);
                 } else {
                     if (u.length > 0 && u.lastIndexOf("/") === u.length - 1) {
                         if (a[a.length - 1] === "/") {
@@ -944,94 +991,94 @@ const ne = function(e) {
                         if (this.options.transformTagName) {
                             a = this.options.transformTagName(a);
                         }
-                        const e = new W(a);
+                        const t = new H(a);
                         if (a !== u && f) {
-                            e[":@"] = this.buildAttributesMap(u, s, a);
+                            t[":@"] = this.buildAttributesMap(u, s, a);
                         }
-                        this.addChild(i, e, s);
+                        this.addChild(n, t, s);
                         s = s.substr(0, s.lastIndexOf("."));
                     } else {
-                        const e = new W(a);
-                        this.tagsNodeStack.push(i);
+                        const t = new H(a);
+                        this.tagsNodeStack.push(n);
                         if (a !== u && f) {
-                            e[":@"] = this.buildAttributesMap(u, s, a);
+                            t[":@"] = this.buildAttributesMap(u, s, a);
                         }
-                        this.addChild(i, e, s);
-                        i = e;
+                        this.addChild(n, t, s);
+                        n = t;
                     }
-                    n = "";
+                    i = "";
                     r = c;
                 }
             }
         } else {
-            n += e[r];
+            i += t[r];
         }
     }
-    return t.child;
+    return e.child;
 };
 
-function se(e, t, i) {
-    const n = this.options.updateTag(t.tagname, i, t[":@"]);
-    if (n === false) {} else if (typeof n === "string") {
-        t.tagname = n;
-        e.addChild(t);
+function lt(t, e, n) {
+    const i = this.options.updateTag(e.tagname, n, e[":@"]);
+    if (i === false) {} else if (typeof i === "string") {
+        e.tagname = i;
+        t.addChild(e);
     } else {
-        e.addChild(t);
+        t.addChild(e);
     }
 }
 
-const re = function(e) {
+const ut = function(t) {
     if (this.options.processEntities) {
-        for (let t in this.docTypeEntities) {
-            const i = this.docTypeEntities[t];
-            e = e.replace(i.regx, i.val);
+        for (let e in this.docTypeEntities) {
+            const n = this.docTypeEntities[e];
+            t = t.replace(n.regx, n.val);
         }
-        for (let t in this.lastEntities) {
-            const i = this.lastEntities[t];
-            e = e.replace(i.regex, i.val);
+        for (let e in this.lastEntities) {
+            const n = this.lastEntities[e];
+            t = t.replace(n.regex, n.val);
         }
         if (this.options.htmlEntities) {
-            for (let t in this.htmlEntities) {
-                const i = this.htmlEntities[t];
-                e = e.replace(i.regex, i.val);
+            for (let e in this.htmlEntities) {
+                const n = this.htmlEntities[e];
+                t = t.replace(n.regex, n.val);
             }
         }
-        e = e.replace(this.ampEntity.regex, this.ampEntity.val);
+        t = t.replace(this.ampEntity.regex, this.ampEntity.val);
     }
-    return e;
+    return t;
 };
 
-function oe(e, t, i, n) {
-    if (e) {
-        if (n === undefined) n = Object.keys(t.child).length === 0;
-        e = this.parseTextData(e, t.tagname, i, false, t[":@"] ? Object.keys(t[":@"]).length !== 0 : false, n);
-        if (e !== undefined && e !== "") t.add(this.options.textNodeName, e);
-        e = "";
+function ft(t, e, n, i) {
+    if (t) {
+        if (i === undefined) i = Object.keys(e.child).length === 0;
+        t = this.parseTextData(t, e.tagname, n, false, e[":@"] ? Object.keys(e[":@"]).length !== 0 : false, i);
+        if (t !== undefined && t !== "") e.add(this.options.textNodeName, t);
+        t = "";
     }
-    return e;
+    return t;
 }
 
-function ae(e, t, i) {
-    const n = "*." + i;
-    for (const i in e) {
-        const s = e[i];
-        if (n === s || t === s) return true;
+function ct(t, e, n) {
+    const i = "*." + n;
+    for (const n in t) {
+        const s = t[n];
+        if (i === s || e === s) return true;
     }
     return false;
 }
 
-function le(e, t, i = ">") {
-    let n;
+function ht(t, e, n = ">") {
+    let i;
     let s = "";
-    for (let r = t; r < e.length; r++) {
-        let t = e[r];
-        if (n) {
-            if (t === n) n = "";
-        } else if (t === '"' || t === "'") {
-            n = t;
-        } else if (t === i[0]) {
-            if (i[1]) {
-                if (e[r + 1] === i[1]) {
+    for (let r = e; r < t.length; r++) {
+        let e = t[r];
+        if (i) {
+            if (e === i) i = "";
+        } else if (e === '"' || e === "'") {
+            i = e;
+        } else if (e === n[0]) {
+            if (n[1]) {
+                if (t[r + 1] === n[1]) {
                     return {
                         data: s,
                         index: r
@@ -1043,24 +1090,24 @@ function le(e, t, i = ">") {
                     index: r
                 };
             }
-        } else if (t === "\t") {
-            t = " ";
+        } else if (e === "\t") {
+            e = " ";
         }
-        s += t;
+        s += e;
     }
 }
 
-function ue(e, t, i, n) {
-    const s = e.indexOf(t, i);
+function dt(t, e, n, i) {
+    const s = t.indexOf(e, n);
     if (s === -1) {
-        throw new Error(n);
+        throw new Error(i);
     } else {
-        return s + t.length - 1;
+        return s + e.length - 1;
     }
 }
 
-function fe(e, t, i, n = ">") {
-    const s = le(e, t + 1, n);
+function pt(t, e, n, i = ">") {
+    const s = ht(t, e + 1, i);
     if (!s) return;
     let r = s.data;
     const o = s.index;
@@ -1072,11 +1119,11 @@ function fe(e, t, i, n = ">") {
         r = r.substring(a + 1).trimStart();
     }
     const f = l;
-    if (i) {
-        const e = l.indexOf(":");
-        if (e !== -1) {
-            l = l.substr(e + 1);
-            u = l !== s.data.substr(e + 1);
+    if (n) {
+        const t = l.indexOf(":");
+        if (t !== -1) {
+            l = l.substr(t + 1);
+            u = l !== s.data.substr(t + 1);
         }
     }
     return {
@@ -1088,269 +1135,269 @@ function fe(e, t, i, n = ">") {
     };
 }
 
-function ce(e, t, i) {
-    const n = i;
+function gt(t, e, n) {
+    const i = n;
     let s = 1;
-    for (;i < e.length; i++) {
-        if (e[i] === "<") {
-            if (e[i + 1] === "/") {
-                const r = ue(e, ">", i, `${t} is not closed`);
-                let o = e.substring(i + 2, r).trim();
-                if (o === t) {
+    for (;n < t.length; n++) {
+        if (t[n] === "<") {
+            if (t[n + 1] === "/") {
+                const r = dt(t, ">", n, `${e} is not closed`);
+                let o = t.substring(n + 2, r).trim();
+                if (o === e) {
                     s--;
                     if (s === 0) {
                         return {
-                            tagContent: e.substring(n, i),
+                            tagContent: t.substring(i, n),
                             i: r
                         };
                     }
                 }
-                i = r;
-            } else if (e[i + 1] === "?") {
-                const t = ue(e, "?>", i + 1, "StopNode is not closed.");
-                i = t;
-            } else if (e.substr(i + 1, 3) === "!--") {
-                const t = ue(e, "--\x3e", i + 3, "StopNode is not closed.");
-                i = t;
-            } else if (e.substr(i + 1, 2) === "![") {
-                const t = ue(e, "]]>", i, "StopNode is not closed.") - 2;
-                i = t;
+                n = r;
+            } else if (t[n + 1] === "?") {
+                const e = dt(t, "?>", n + 1, "StopNode is not closed.");
+                n = e;
+            } else if (t.substr(n + 1, 3) === "!--") {
+                const e = dt(t, "--\x3e", n + 3, "StopNode is not closed.");
+                n = e;
+            } else if (t.substr(n + 1, 2) === "![") {
+                const e = dt(t, "]]>", n, "StopNode is not closed.") - 2;
+                n = e;
             } else {
-                const n = fe(e, i, ">");
-                if (n) {
-                    const e = n && n.tagName;
-                    if (e === t && n.tagExp[n.tagExp.length - 1] !== "/") {
+                const i = pt(t, n, ">");
+                if (i) {
+                    const t = i && i.tagName;
+                    if (t === e && i.tagExp[i.tagExp.length - 1] !== "/") {
                         s++;
                     }
-                    i = n.closeIndex;
+                    n = i.closeIndex;
                 }
             }
         }
     }
 }
 
-function de(e, t, i) {
-    if (t && typeof e === "string") {
-        const t = e.trim();
-        if (t === "true") return true; else if (t === "false") return false; else return J(e, i);
+function mt(t, e, n) {
+    if (e && typeof t === "string") {
+        const e = t.trim();
+        if (e === "true") return true; else if (e === "false") return false; else return Q(t, n);
     } else {
-        if (q.isExist(e)) {
-            return e;
+        if (J.isExist(t)) {
+            return t;
         } else {
             return "";
         }
     }
 }
 
-var he = H;
+var xt = et;
 
-const pe = e(he);
+const Nt = t(xt);
 
-var ge = {};
+var bt = {};
 
 "use strict";
 
-function me(e, t) {
-    return xe(e, t);
+function Et(t, e) {
+    return vt(t, e);
 }
 
-function xe(e, t, i) {
-    let n;
+function vt(t, e, n) {
+    let i;
     const s = {};
-    for (let r = 0; r < e.length; r++) {
-        const o = e[r];
-        const a = Ne(o);
+    for (let r = 0; r < t.length; r++) {
+        const o = t[r];
+        const a = yt(o);
         let l = "";
-        if (i === undefined) l = a; else l = i + "." + a;
-        if (a === t.textNodeName) {
-            if (n === undefined) n = o[a]; else n += "" + o[a];
+        if (n === undefined) l = a; else l = n + "." + a;
+        if (a === e.textNodeName) {
+            if (i === undefined) i = o[a]; else i += "" + o[a];
         } else if (a === undefined) {
             continue;
         } else if (o[a]) {
-            let e = xe(o[a], t, l);
-            const i = Ee(e, t);
+            let t = vt(o[a], e, l);
+            const n = Ot(t, e);
             if (o[":@"]) {
-                be(e, o[":@"], l, t);
-            } else if (Object.keys(e).length === 1 && e[t.textNodeName] !== undefined && !t.alwaysCreateTextNode) {
-                e = e[t.textNodeName];
-            } else if (Object.keys(e).length === 0) {
-                if (t.alwaysCreateTextNode) e[t.textNodeName] = ""; else e = "";
+                Tt(t, o[":@"], l, e);
+            } else if (Object.keys(t).length === 1 && t[e.textNodeName] !== undefined && !e.alwaysCreateTextNode) {
+                t = t[e.textNodeName];
+            } else if (Object.keys(t).length === 0) {
+                if (e.alwaysCreateTextNode) t[e.textNodeName] = ""; else t = "";
             }
             if (s[a] !== undefined && s.hasOwnProperty(a)) {
                 if (!Array.isArray(s[a])) {
                     s[a] = [ s[a] ];
                 }
-                s[a].push(e);
+                s[a].push(t);
             } else {
-                if (t.isArray(a, l, i)) {
-                    s[a] = [ e ];
+                if (e.isArray(a, l, n)) {
+                    s[a] = [ t ];
                 } else {
-                    s[a] = e;
+                    s[a] = t;
                 }
             }
         }
     }
-    if (typeof n === "string") {
-        if (n.length > 0) s[t.textNodeName] = n;
-    } else if (n !== undefined) s[t.textNodeName] = n;
+    if (typeof i === "string") {
+        if (i.length > 0) s[e.textNodeName] = i;
+    } else if (i !== undefined) s[e.textNodeName] = i;
     return s;
 }
 
-function Ne(e) {
-    const t = Object.keys(e);
-    for (let e = 0; e < t.length; e++) {
-        const i = t[e];
-        if (i !== ":@") return i;
+function yt(t) {
+    const e = Object.keys(t);
+    for (let t = 0; t < e.length; t++) {
+        const n = e[t];
+        if (n !== ":@") return n;
     }
 }
 
-function be(e, t, i, n) {
-    if (t) {
-        const s = Object.keys(t);
+function Tt(t, e, n, i) {
+    if (e) {
+        const s = Object.keys(e);
         const r = s.length;
         for (let o = 0; o < r; o++) {
             const r = s[o];
-            if (n.isArray(r, i + "." + r, true, true)) {
-                e[r] = [ t[r] ];
+            if (i.isArray(r, n + "." + r, true, true)) {
+                t[r] = [ e[r] ];
             } else {
-                e[r] = t[r];
+                t[r] = e[r];
             }
         }
     }
 }
 
-function Ee(e, t) {
-    const {textNodeName: i} = t;
-    const n = Object.keys(e).length;
-    if (n === 0) {
+function Ot(t, e) {
+    const {textNodeName: n} = e;
+    const i = Object.keys(t).length;
+    if (i === 0) {
         return true;
     }
-    if (n === 1 && (e[i] || typeof e[i] === "boolean" || e[i] === 0)) {
+    if (i === 1 && (t[n] || typeof t[n] === "boolean" || t[n] === 0)) {
         return true;
     }
     return false;
 }
 
-var ve = ge.prettify = me;
+var At = bt.prettify = Et;
 
-const {buildOptions: ye} = y;
+const {buildOptions: Pt} = y;
 
-const Te = he;
+const wt = xt;
 
-const {prettify: Oe} = ge;
+const {prettify: Ct} = bt;
 
-const we = t;
+const It = e;
 
-let Pe = class XMLParser {
-    constructor(e) {
+let St = class XMLParser {
+    constructor(t) {
         this.externalEntities = {};
-        this.options = ye(e);
+        this.options = Pt(t);
     }
-    parse(e, t) {
-        if (typeof e === "string") {} else if (e.toString) {
-            e = e.toString();
+    parse(t, e) {
+        if (typeof t === "string") {} else if (t.toString) {
+            t = t.toString();
         } else {
             throw new Error("XML data is accepted in String or Bytes[] form.");
         }
-        if (t) {
-            if (t === true) t = {};
-            const i = we.validate(e, t);
-            if (i !== true) {
-                throw Error(`${i.err.msg}:${i.err.line}:${i.err.col}`);
+        if (e) {
+            if (e === true) e = {};
+            const n = It.validate(t, e);
+            if (n !== true) {
+                throw Error(`${n.err.msg}:${n.err.line}:${n.err.col}`);
             }
         }
-        const i = new Te(this.options);
-        i.addExternalEntities(this.externalEntities);
-        const n = i.parseXml(e);
-        if (this.options.preserveOrder || n === undefined) return n; else return Oe(n, this.options);
+        const n = new wt(this.options);
+        n.addExternalEntities(this.externalEntities);
+        const i = n.parseXml(t);
+        if (this.options.preserveOrder || i === undefined) return i; else return Ct(i, this.options);
     }
-    addEntity(e, t) {
-        if (t.indexOf("&") !== -1) {
+    addEntity(t, e) {
+        if (e.indexOf("&") !== -1) {
             throw new Error("Entity value can't have '&'");
-        } else if (e.indexOf("&") !== -1 || e.indexOf(";") !== -1) {
+        } else if (t.indexOf("&") !== -1 || t.indexOf(";") !== -1) {
             throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
-        } else if (t === "&") {
+        } else if (e === "&") {
             throw new Error("An entity with value '&' is not permitted");
         } else {
-            this.externalEntities[e] = t;
+            this.externalEntities[t] = e;
         }
     }
 };
 
-var Ae = Pe;
+var jt = St;
 
-const Ie = e(Ae);
+const Vt = t(jt);
 
-const Ce = "\n";
+const kt = "\n";
 
-function je(e, t) {
-    let i = "";
-    if (t.format && t.indentBy.length > 0) {
-        i = Ce;
+function Ft(t, e) {
+    let n = "";
+    if (e.format && e.indentBy.length > 0) {
+        n = kt;
     }
-    return Se(e, t, "", i);
+    return $t(t, e, "", n);
 }
 
-function Se(e, t, i, n) {
+function $t(t, e, n, i) {
     let s = "";
     let r = false;
-    for (let o = 0; o < e.length; o++) {
-        const a = e[o];
-        const l = Ve(a);
+    for (let o = 0; o < t.length; o++) {
+        const a = t[o];
+        const l = _t(a);
         if (l === undefined) continue;
         let u = "";
-        if (i.length === 0) u = l; else u = `${i}.${l}`;
-        if (l === t.textNodeName) {
-            let e = a[l];
-            if (!$e(u, t)) {
-                e = t.tagValueProcessor(l, e);
-                e = Fe(e, t);
+        if (n.length === 0) u = l; else u = `${n}.${l}`;
+        if (l === e.textNodeName) {
+            let t = a[l];
+            if (!Lt(u, e)) {
+                t = e.tagValueProcessor(l, t);
+                t = Mt(t, e);
             }
             if (r) {
-                s += n;
+                s += i;
             }
-            s += e;
+            s += t;
             r = false;
             continue;
-        } else if (l === t.cdataPropName) {
+        } else if (l === e.cdataPropName) {
             if (r) {
-                s += n;
+                s += i;
             }
-            s += `<![CDATA[${a[l][0][t.textNodeName]}]]>`;
+            s += `<![CDATA[${a[l][0][e.textNodeName]}]]>`;
             r = false;
             continue;
-        } else if (l === t.commentPropName) {
-            s += n + `\x3c!--${a[l][0][t.textNodeName]}--\x3e`;
+        } else if (l === e.commentPropName) {
+            s += i + `\x3c!--${a[l][0][e.textNodeName]}--\x3e`;
             r = true;
             continue;
         } else if (l[0] === "?") {
-            const e = ke(a[":@"], t);
-            const i = l === "?xml" ? "" : n;
-            let o = a[l][0][t.textNodeName];
+            const t = Dt(a[":@"], e);
+            const n = l === "?xml" ? "" : i;
+            let o = a[l][0][e.textNodeName];
             o = o.length !== 0 ? " " + o : "";
-            s += i + `<${l}${o}${e}?>`;
+            s += n + `<${l}${o}${t}?>`;
             r = true;
             continue;
         }
-        let f = n;
+        let f = i;
         if (f !== "") {
-            f += t.indentBy;
+            f += e.indentBy;
         }
-        const c = ke(a[":@"], t);
-        const d = n + `<${l}${c}`;
-        const h = Se(a[l], t, u, f);
-        if (t.unpairedTags.indexOf(l) !== -1) {
-            if (t.suppressUnpairedNode) s += d + ">"; else s += d + "/>";
-        } else if ((!h || h.length === 0) && t.suppressEmptyNode) {
-            s += d + "/>";
-        } else if (h && h.endsWith(">")) {
-            s += d + `>${h}${n}</${l}>`;
+        const c = Dt(a[":@"], e);
+        const h = i + `<${l}${c}`;
+        const d = $t(a[l], e, u, f);
+        if (e.unpairedTags.indexOf(l) !== -1) {
+            if (e.suppressUnpairedNode) s += h + ">"; else s += h + "/>";
+        } else if ((!d || d.length === 0) && e.suppressEmptyNode) {
+            s += h + "/>";
+        } else if (d && d.endsWith(">")) {
+            s += h + `>${d}${i}</${l}>`;
         } else {
-            s += d + ">";
-            if (h && n !== "" && (h.includes("/>") || h.includes("</"))) {
-                s += n + t.indentBy + h + n;
+            s += h + ">";
+            if (d && i !== "" && (d.includes("/>") || d.includes("</"))) {
+                s += i + e.indentBy + d + i;
             } else {
-                s += h;
+                s += d;
             }
             s += `</${l}>`;
         }
@@ -1359,60 +1406,62 @@ function Se(e, t, i, n) {
     return s;
 }
 
-function Ve(e) {
-    const t = Object.keys(e);
-    for (let i = 0; i < t.length; i++) {
-        const n = t[i];
-        if (!e.hasOwnProperty(n)) continue;
-        if (n !== ":@") return n;
+function _t(t) {
+    const e = Object.keys(t);
+    for (let n = 0; n < e.length; n++) {
+        const i = e[n];
+        if (!t.hasOwnProperty(i)) continue;
+        if (i !== ":@") return i;
     }
 }
 
-function ke(e, t) {
-    let i = "";
-    if (e && !t.ignoreAttributes) {
-        for (let n in e) {
-            if (!e.hasOwnProperty(n)) continue;
-            let s = t.attributeValueProcessor(n, e[n]);
-            s = Fe(s, t);
-            if (s === true && t.suppressBooleanAttributes) {
-                i += ` ${n.substr(t.attributeNamePrefix.length)}`;
+function Dt(t, e) {
+    let n = "";
+    if (t && !e.ignoreAttributes) {
+        for (let i in t) {
+            if (!t.hasOwnProperty(i)) continue;
+            let s = e.attributeValueProcessor(i, t[i]);
+            s = Mt(s, e);
+            if (s === true && e.suppressBooleanAttributes) {
+                n += ` ${i.substr(e.attributeNamePrefix.length)}`;
             } else {
-                i += ` ${n.substr(t.attributeNamePrefix.length)}="${s}"`;
+                n += ` ${i.substr(e.attributeNamePrefix.length)}="${s}"`;
             }
         }
     }
-    return i;
+    return n;
 }
 
-function $e(e, t) {
-    e = e.substr(0, e.length - t.textNodeName.length - 1);
-    let i = e.substr(e.lastIndexOf(".") + 1);
-    for (let n in t.stopNodes) {
-        if (t.stopNodes[n] === e || t.stopNodes[n] === "*." + i) return true;
+function Lt(t, e) {
+    t = t.substr(0, t.length - e.textNodeName.length - 1);
+    let n = t.substr(t.lastIndexOf(".") + 1);
+    for (let i in e.stopNodes) {
+        if (e.stopNodes[i] === t || e.stopNodes[i] === "*." + n) return true;
     }
     return false;
 }
 
-function Fe(e, t) {
-    if (e && e.length > 0 && t.processEntities) {
-        for (let i = 0; i < t.entities.length; i++) {
-            const n = t.entities[i];
-            e = e.replace(n.regex, n.val);
+function Mt(t, e) {
+    if (t && t.length > 0 && e.processEntities) {
+        for (let n = 0; n < e.entities.length; n++) {
+            const i = e.entities[n];
+            t = t.replace(i.regex, i.val);
         }
     }
-    return e;
+    return t;
 }
 
-var De = je;
+var Bt = Ft;
 
-const _e = e(De);
+const Xt = t(Bt);
 
 "use strict";
 
-const Le = De;
+const Gt = Bt;
+
+const Rt = W;
 
-const Me = {
+const Ut = {
     attributeNamePrefix: "@_",
     attributesGroupName: false,
     textNodeName: "#text",
@@ -1423,11 +1472,11 @@ const Me = {
     suppressEmptyNode: false,
     suppressUnpairedNode: true,
     suppressBooleanAttributes: true,
-    tagValueProcessor: function(e, t) {
-        return t;
+    tagValueProcessor: function(t, e) {
+        return e;
     },
-    attributeValueProcessor: function(e, t) {
-        return t;
+    attributeValueProcessor: function(t, e) {
+        return e;
     },
     preserveOrder: false,
     commentPropName: false,
@@ -1453,19 +1502,20 @@ const Me = {
     oneListGroup: false
 };
 
-function Be(e) {
-    this.options = Object.assign({}, Me, e);
-    if (this.options.ignoreAttributes || this.options.attributesGroupName) {
+function Yt(t) {
+    this.options = Object.assign({}, Ut, t);
+    if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {
         this.isAttribute = function() {
             return false;
         };
     } else {
+        this.ignoreAttributesFn = Rt(this.options.ignoreAttributes);
         this.attrPrefixLen = this.options.attributeNamePrefix.length;
-        this.isAttribute = Ue;
+        this.isAttribute = zt;
     }
-    this.processTextOrObjNode = Xe;
+    this.processTextOrObjNode = Zt;
     if (this.options.format) {
-        this.indentate = Ge;
+        this.indentate = Wt;
         this.tagEndChar = ">\n";
         this.newLine = "\n";
     } else {
@@ -1477,219 +1527,231 @@ function Be(e) {
     }
 }
 
-Be.prototype.build = function(e) {
+Yt.prototype.build = function(t) {
     if (this.options.preserveOrder) {
-        return Le(e, this.options);
+        return Gt(t, this.options);
     } else {
-        if (Array.isArray(e) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {
-            e = {
-                [this.options.arrayNodeName]: e
+        if (Array.isArray(t) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {
+            t = {
+                [this.options.arrayNodeName]: t
             };
         }
-        return this.j2x(e, 0).val;
+        return this.j2x(t, 0, []).val;
     }
 };
 
-Be.prototype.j2x = function(e, t) {
+Yt.prototype.j2x = function(t, e, n) {
     let i = "";
-    let n = "";
-    for (let s in e) {
-        if (!Object.prototype.hasOwnProperty.call(e, s)) continue;
-        if (typeof e[s] === "undefined") {
-            if (this.isAttribute(s)) {
-                n += "";
+    let s = "";
+    const r = n.join(".");
+    for (let o in t) {
+        if (!Object.prototype.hasOwnProperty.call(t, o)) continue;
+        if (typeof t[o] === "undefined") {
+            if (this.isAttribute(o)) {
+                s += "";
             }
-        } else if (e[s] === null) {
-            if (this.isAttribute(s)) {
-                n += "";
-            } else if (s[0] === "?") {
-                n += this.indentate(t) + "<" + s + "?" + this.tagEndChar;
+        } else if (t[o] === null) {
+            if (this.isAttribute(o)) {
+                s += "";
+            } else if (o[0] === "?") {
+                s += this.indentate(e) + "<" + o + "?" + this.tagEndChar;
             } else {
-                n += this.indentate(t) + "<" + s + "/" + this.tagEndChar;
+                s += this.indentate(e) + "<" + o + "/" + this.tagEndChar;
             }
-        } else if (e[s] instanceof Date) {
-            n += this.buildTextValNode(e[s], s, "", t);
-        } else if (typeof e[s] !== "object") {
-            const r = this.isAttribute(s);
-            if (r) {
-                i += this.buildAttrPairStr(r, "" + e[s]);
-            } else {
-                if (s === this.options.textNodeName) {
-                    let t = this.options.tagValueProcessor(s, "" + e[s]);
-                    n += this.replaceEntitiesValue(t);
+        } else if (t[o] instanceof Date) {
+            s += this.buildTextValNode(t[o], o, "", e);
+        } else if (typeof t[o] !== "object") {
+            const n = this.isAttribute(o);
+            if (n && !this.ignoreAttributesFn(n, r)) {
+                i += this.buildAttrPairStr(n, "" + t[o]);
+            } else if (!n) {
+                if (o === this.options.textNodeName) {
+                    let e = this.options.tagValueProcessor(o, "" + t[o]);
+                    s += this.replaceEntitiesValue(e);
                 } else {
-                    n += this.buildTextValNode(e[s], s, "", t);
+                    s += this.buildTextValNode(t[o], o, "", e);
                 }
             }
-        } else if (Array.isArray(e[s])) {
-            const i = e[s].length;
+        } else if (Array.isArray(t[o])) {
+            const i = t[o].length;
             let r = "";
-            for (let o = 0; o < i; o++) {
-                const i = e[s][o];
+            let a = "";
+            for (let l = 0; l < i; l++) {
+                const i = t[o][l];
                 if (typeof i === "undefined") {} else if (i === null) {
-                    if (s[0] === "?") n += this.indentate(t) + "<" + s + "?" + this.tagEndChar; else n += this.indentate(t) + "<" + s + "/" + this.tagEndChar;
+                    if (o[0] === "?") s += this.indentate(e) + "<" + o + "?" + this.tagEndChar; else s += this.indentate(e) + "<" + o + "/" + this.tagEndChar;
                 } else if (typeof i === "object") {
                     if (this.options.oneListGroup) {
-                        r += this.j2x(i, t + 1).val;
+                        const t = this.j2x(i, e + 1, n.concat(o));
+                        r += t.val;
+                        if (this.options.attributesGroupName && i.hasOwnProperty(this.options.attributesGroupName)) {
+                            a += t.attrStr;
+                        }
                     } else {
-                        r += this.processTextOrObjNode(i, s, t);
+                        r += this.processTextOrObjNode(i, o, e, n);
                     }
                 } else {
-                    r += this.buildTextValNode(i, s, "", t);
+                    if (this.options.oneListGroup) {
+                        let t = this.options.tagValueProcessor(o, i);
+                        t = this.replaceEntitiesValue(t);
+                        r += t;
+                    } else {
+                        r += this.buildTextValNode(i, o, "", e);
+                    }
                 }
             }
             if (this.options.oneListGroup) {
-                r = this.buildObjectNode(r, s, "", t);
+                r = this.buildObjectNode(r, o, a, e);
             }
-            n += r;
+            s += r;
         } else {
-            if (this.options.attributesGroupName && s === this.options.attributesGroupName) {
-                const t = Object.keys(e[s]);
-                const n = t.length;
-                for (let r = 0; r < n; r++) {
-                    i += this.buildAttrPairStr(t[r], "" + e[s][t[r]]);
+            if (this.options.attributesGroupName && o === this.options.attributesGroupName) {
+                const e = Object.keys(t[o]);
+                const n = e.length;
+                for (let s = 0; s < n; s++) {
+                    i += this.buildAttrPairStr(e[s], "" + t[o][e[s]]);
                 }
             } else {
-                n += this.processTextOrObjNode(e[s], s, t);
+                s += this.processTextOrObjNode(t[o], o, e, n);
             }
         }
     }
     return {
         attrStr: i,
-        val: n
+        val: s
     };
 };
 
-Be.prototype.buildAttrPairStr = function(e, t) {
-    t = this.options.attributeValueProcessor(e, "" + t);
-    t = this.replaceEntitiesValue(t);
-    if (this.options.suppressBooleanAttributes && t === "true") {
-        return " " + e;
-    } else return " " + e + '="' + t + '"';
+Yt.prototype.buildAttrPairStr = function(t, e) {
+    e = this.options.attributeValueProcessor(t, "" + e);
+    e = this.replaceEntitiesValue(e);
+    if (this.options.suppressBooleanAttributes && e === "true") {
+        return " " + t;
+    } else return " " + t + '="' + e + '"';
 };
 
-function Xe(e, t, i) {
-    const n = this.j2x(e, i + 1);
-    if (e[this.options.textNodeName] !== undefined && Object.keys(e).length === 1) {
-        return this.buildTextValNode(e[this.options.textNodeName], t, n.attrStr, i);
+function Zt(t, e, n, i) {
+    const s = this.j2x(t, n + 1, i.concat(e));
+    if (t[this.options.textNodeName] !== undefined && Object.keys(t).length === 1) {
+        return this.buildTextValNode(t[this.options.textNodeName], e, s.attrStr, n);
     } else {
-        return this.buildObjectNode(n.val, t, n.attrStr, i);
+        return this.buildObjectNode(s.val, e, s.attrStr, n);
     }
 }
 
-Be.prototype.buildObjectNode = function(e, t, i, n) {
-    if (e === "") {
-        if (t[0] === "?") return this.indentate(n) + "<" + t + i + "?" + this.tagEndChar; else {
-            return this.indentate(n) + "<" + t + i + this.closeTag(t) + this.tagEndChar;
+Yt.prototype.buildObjectNode = function(t, e, n, i) {
+    if (t === "") {
+        if (e[0] === "?") return this.indentate(i) + "<" + e + n + "?" + this.tagEndChar; else {
+            return this.indentate(i) + "<" + e + n + this.closeTag(e) + this.tagEndChar;
         }
     } else {
-        let s = "</" + t + this.tagEndChar;
+        let s = "</" + e + this.tagEndChar;
         let r = "";
-        if (t[0] === "?") {
+        if (e[0] === "?") {
             r = "?";
             s = "";
         }
-        if ((i || i === "") && e.indexOf("<") === -1) {
-            return this.indentate(n) + "<" + t + i + r + ">" + e + s;
-        } else if (this.options.commentPropName !== false && t === this.options.commentPropName && r.length === 0) {
-            return this.indentate(n) + `\x3c!--${e}--\x3e` + this.newLine;
+        if ((n || n === "") && t.indexOf("<") === -1) {
+            return this.indentate(i) + "<" + e + n + r + ">" + t + s;
+        } else if (this.options.commentPropName !== false && e === this.options.commentPropName && r.length === 0) {
+            return this.indentate(i) + `\x3c!--${t}--\x3e` + this.newLine;
         } else {
-            return this.indentate(n) + "<" + t + i + r + this.tagEndChar + e + this.indentate(n) + s;
+            return this.indentate(i) + "<" + e + n + r + this.tagEndChar + t + this.indentate(i) + s;
         }
     }
 };
 
-Be.prototype.closeTag = function(e) {
-    let t = "";
-    if (this.options.unpairedTags.indexOf(e) !== -1) {
-        if (!this.options.suppressUnpairedNode) t = "/";
+Yt.prototype.closeTag = function(t) {
+    let e = "";
+    if (this.options.unpairedTags.indexOf(t) !== -1) {
+        if (!this.options.suppressUnpairedNode) e = "/";
     } else if (this.options.suppressEmptyNode) {
-        t = "/";
+        e = "/";
     } else {
-        t = `></${e}`;
+        e = `></${t}`;
     }
-    return t;
+    return e;
 };
 
-function Re(e, t, i, n) {
-    if (e !== "") {
-        return this.buildObjectNode(e, t, i, n);
+function qt(t, e, n, i) {
+    if (t !== "") {
+        return this.buildObjectNode(t, e, n, i);
     } else {
-        if (t[0] === "?") return this.indentate(n) + "<" + t + i + "?" + this.tagEndChar; else {
-            return this.indentate(n) + "<" + t + i + "/" + this.tagEndChar;
+        if (e[0] === "?") return this.indentate(i) + "<" + e + n + "?" + this.tagEndChar; else {
+            return this.indentate(i) + "<" + e + n + "/" + this.tagEndChar;
         }
     }
 }
 
-Be.prototype.buildTextValNode = function(e, t, i, n) {
-    if (this.options.cdataPropName !== false && t === this.options.cdataPropName) {
-        return this.indentate(n) + `<![CDATA[${e}]]>` + this.newLine;
-    } else if (this.options.commentPropName !== false && t === this.options.commentPropName) {
-        return this.indentate(n) + `\x3c!--${e}--\x3e` + this.newLine;
-    } else if (t[0] === "?") {
-        return this.indentate(n) + "<" + t + i + "?" + this.tagEndChar;
+Yt.prototype.buildTextValNode = function(t, e, n, i) {
+    if (this.options.cdataPropName !== false && e === this.options.cdataPropName) {
+        return this.indentate(i) + `<![CDATA[${t}]]>` + this.newLine;
+    } else if (this.options.commentPropName !== false && e === this.options.commentPropName) {
+        return this.indentate(i) + `\x3c!--${t}--\x3e` + this.newLine;
+    } else if (e[0] === "?") {
+        return this.indentate(i) + "<" + e + n + "?" + this.tagEndChar;
     } else {
-        let s = this.options.tagValueProcessor(t, e);
+        let s = this.options.tagValueProcessor(e, t);
         s = this.replaceEntitiesValue(s);
         if (s === "") {
-            return this.indentate(n) + "<" + t + i + this.closeTag(t) + this.tagEndChar;
+            return this.indentate(i) + "<" + e + n + this.closeTag(e) + this.tagEndChar;
         } else {
-            return this.indentate(n) + "<" + t + i + ">" + s + "</" + t + this.tagEndChar;
+            return this.indentate(i) + "<" + e + n + ">" + s + "</" + e + this.tagEndChar;
         }
     }
 };
 
-Be.prototype.replaceEntitiesValue = function(e) {
-    if (e && e.length > 0 && this.options.processEntities) {
-        for (let t = 0; t < this.options.entities.length; t++) {
-            const i = this.options.entities[t];
-            e = e.replace(i.regex, i.val);
+Yt.prototype.replaceEntitiesValue = function(t) {
+    if (t && t.length > 0 && this.options.processEntities) {
+        for (let e = 0; e < this.options.entities.length; e++) {
+            const n = this.options.entities[e];
+            t = t.replace(n.regex, n.val);
         }
     }
-    return e;
+    return t;
 };
 
-function Ge(e) {
-    return this.options.indentBy.repeat(e);
+function Wt(t) {
+    return this.options.indentBy.repeat(t);
 }
 
-function Ue(e) {
-    if (e.startsWith(this.options.attributeNamePrefix) && e !== this.options.textNodeName) {
-        return e.substr(this.attrPrefixLen);
+function zt(t) {
+    if (t.startsWith(this.options.attributeNamePrefix) && t !== this.options.textNodeName) {
+        return t.substr(this.attrPrefixLen);
     } else {
         return false;
     }
 }
 
-var Ye = Be;
+var Jt = Yt;
 
-const Ze = e(Ye);
+const Ht = t(Jt);
 
 "use strict";
 
-const qe = t;
+const Kt = e;
 
-const We = Ae;
+const Qt = jt;
 
-const ze = Ye;
+const te = Jt;
 
-var Je = {
-    XMLParser: We,
-    XMLValidator: qe,
-    XMLBuilder: ze
+var ee = {
+    XMLParser: Qt,
+    XMLValidator: Kt,
+    XMLBuilder: te
 };
 
-const He = e(Je);
+const ne = t(ee);
 
-function Ke(e) {
+function ie(t) {
     try {
-        Je.XMLValidator.validate(e, {
+        ee.XMLValidator.validate(t, {
             allowBooleanAttributes: true
         });
         return true;
-    } catch (e) {
+    } catch (t) {
         return false;
     }
 }
 
-export { Ke as IsXML };
+export { ie as IsXML };