lakutata 2.0.81 → 2.0.82

package/src/lib/helpers/IsXML.mjs

@@ -1,521 +1,516 @@
-"use strict";
-
-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 t = e + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
-
-const i = "[" + e + "][" + t + "]*";
-
-const n = new RegExp("^" + i + "$");
-
-function s(e, t) {
-    const i = [];
-    let n = t.exec(e);
-    while (n) {
-        const s = [];
-        s.startIndex = t.lastIndex - n[0].length;
-        const r = n.length;
-        for (let e = 0; e < r; e++) {
-            s.push(n[e]);
-        }
-        i.push(s);
-        n = t.exec(e);
-    }
-    return i;
-}
-
-const r = function(e) {
-    const t = n.exec(e);
-    return !(t === null || typeof t === "undefined");
-};
-
-function o(e) {
-    return typeof e !== "undefined";
-}
-
-function a(e) {
-    return Object.keys(e).length === 0;
-}
-
-function l(e, t, i) {
-    if (t) {
-        const n = Object.keys(t);
-        const s = n.length;
-        for (let r = 0; r < s; r++) {
-            if (i === "strict") {
-                e[n[r]] = [ t[n[r]] ];
+import { g as e } from "../../../vendor/Package.5.mjs";
+
+var t = {};
+
+var i = {};
+
+var r;
+
+function requireUtil() {
+    if (r) return i;
+    r = 1;
+    (function(e) {
+        "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 r = "[" + t + "][" + i + "]*";
+        const n = new RegExp("^" + r + "$");
+        const getAllMatches = function(e, t) {
+            const i = [];
+            let r = t.exec(e);
+            while (r) {
+                const n = [];
+                n.startIndex = t.lastIndex - r[0].length;
+                const s = r.length;
+                for (let e = 0; e < s; e++) {
+                    n.push(r[e]);
+                }
+                i.push(n);
+                r = t.exec(e);
+            }
+            return i;
+        };
+        const isName = function(e) {
+            const t = n.exec(e);
+            return !(t === null || typeof t === "undefined");
+        };
+        e.isExist = function(e) {
+            return typeof e !== "undefined";
+        };
+        e.isEmptyObject = function(e) {
+            return Object.keys(e).length === 0;
+        };
+        e.merge = function(e, t, i) {
+            if (t) {
+                const r = Object.keys(t);
+                const n = r.length;
+                for (let s = 0; s < n; s++) {
+                    if (i === "strict") {
+                        e[r[s]] = [ t[r[s]] ];
+                    } else {
+                        e[r[s]] = t[r[s]];
+                    }
+                }
+            }
+        };
+        e.getValue = function(t) {
+            if (e.isExist(t)) {
+                return t;
             } else {
-                e[n[r]] = t[n[r]];
+                return "";
             }
-        }
-    }
-}
-
-function u(e) {
-    if (exports.isExist(e)) {
-        return e;
-    } else {
-        return "";
-    }
+        };
+        e.isName = isName;
+        e.getAllMatches = getAllMatches;
+        e.nameRegexp = r;
+    })(i);
+    return i;
 }
 
-"use strict";
-
-const f = {
-    allowBooleanAttributes: false,
-    unpairedTags: []
-};
+var n;
 
-function d(e, t) {
-    t = Object.assign({}, f, t);
-    const i = [];
-    let n = false;
-    let s = false;
-    if (e[0] === "\ufeff") {
-        e = e.substr(1);
-    }
-    for (let r = 0; r < e.length; r++) {
-        if (e[r] === "<" && e[r + 1] === "?") {
-            r += 2;
-            r = c(e, r);
-            if (r.err) return r;
-        } else if (e[r] === "<") {
-            let o = r;
-            r++;
-            if (e[r] === "!") {
-                r = p(e, r);
-                continue;
-            } else {
-                let a = false;
-                if (e[r] === "/") {
-                    a = true;
-                    r++;
-                }
-                let l = "";
-                for (;r < e.length && e[r] !== ">" && e[r] !== " " && e[r] !== "\t" && e[r] !== "\n" && e[r] !== "\r"; r++) {
-                    l += e[r];
-                }
-                l = l.trim();
-                if (l[l.length - 1] === "/") {
-                    l = l.substring(0, l.length - 1);
-                    r--;
-                }
-                if (!I(l)) {
-                    let t;
-                    if (l.trim().length === 0) {
-                        t = "Invalid space after '<'.";
-                    } else {
-                        t = "Tag '" + l + "' is an invalid name.";
+function requireValidator() {
+    if (n) return t;
+    n = 1;
+    "use strict";
+    const e = requireUtil();
+    const i = {
+        allowBooleanAttributes: false,
+        unpairedTags: []
+    };
+    t.validate = function(e, t) {
+        t = Object.assign({}, i, t);
+        const r = [];
+        let n = false;
+        let s = false;
+        if (e[0] === "\ufeff") {
+            e = e.substr(1);
+        }
+        for (let i = 0; i < e.length; i++) {
+            if (e[i] === "<" && e[i + 1] === "?") {
+                i += 2;
+                i = readPI(e, i);
+                if (i.err) return i;
+            } else if (e[i] === "<") {
+                let o = i;
+                i++;
+                if (e[i] === "!") {
+                    i = readCommentAndCDATA(e, i);
+                    continue;
+                } else {
+                    let a = false;
+                    if (e[i] === "/") {
+                        a = true;
+                        i++;
                     }
-                    return T("InvalidTag", t, v(e, r));
-                }
-                const u = x(e, r);
-                if (u === false) {
-                    return T("InvalidAttr", "Attributes for '" + l + "' have open quote.", v(e, r));
-                }
-                let f = u.value;
-                r = u.index;
-                if (f[f.length - 1] === "/") {
-                    const i = r - f.length;
-                    f = f.substring(0, f.length - 1);
-                    const s = b(f, t);
-                    if (s === true) {
-                        n = true;
-                    } else {
-                        return T(s.err.code, s.err.msg, v(e, i + s.err.line));
+                    let l = "";
+                    for (;i < e.length && e[i] !== ">" && e[i] !== " " && e[i] !== "\t" && e[i] !== "\n" && e[i] !== "\r"; i++) {
+                        l += e[i];
                     }
-                } else if (a) {
-                    if (!u.tagClosed) {
-                        return T("InvalidTag", "Closing tag '" + l + "' doesn't have proper closing.", v(e, r));
-                    } else if (f.trim().length > 0) {
-                        return T("InvalidTag", "Closing tag '" + l + "' can't have attributes or invalid starting.", v(e, o));
-                    } else if (i.length === 0) {
-                        return T("InvalidTag", "Closing tag '" + l + "' has not been opened.", v(e, o));
-                    } else {
-                        const t = i.pop();
-                        if (l !== t.tagName) {
-                            let i = v(e, t.tagStartPos);
-                            return T("InvalidTag", "Expected closing tag '" + t.tagName + "' (opened in line " + i.line + ", col " + i.col + ") instead of closing tag '" + l + "'.", v(e, o));
-                        }
-                        if (i.length == 0) {
-                            s = true;
-                        }
+                    l = l.trim();
+                    if (l[l.length - 1] === "/") {
+                        l = l.substring(0, l.length - 1);
+                        i--;
                     }
-                } else {
-                    const a = b(f, t);
-                    if (a !== true) {
-                        return T(a.err.code, a.err.msg, v(e, r - f.length + a.err.line));
+                    if (!validateTagName(l)) {
+                        let t;
+                        if (l.trim().length === 0) {
+                            t = "Invalid space after '<'.";
+                        } else {
+                            t = "Tag '" + l + "' is an invalid name.";
+                        }
+                        return getErrorObject("InvalidTag", t, getLineNumberForPosition(e, i));
                     }
-                    if (s === true) {
-                        return T("InvalidXml", "Multiple possible root nodes found.", v(e, r));
-                    } else if (t.unpairedTags.indexOf(l) !== -1) {} else {
-                        i.push({
-                            tagName: l,
-                            tagStartPos: o
-                        });
+                    const u = readAttributeStr(e, i);
+                    if (u === false) {
+                        return getErrorObject("InvalidAttr", "Attributes for '" + l + "' have open quote.", getLineNumberForPosition(e, i));
                     }
-                    n = true;
-                }
-                for (r++; r < e.length; r++) {
-                    if (e[r] === "<") {
-                        if (e[r + 1] === "!") {
-                            r++;
-                            r = p(e, r);
-                            continue;
-                        } else if (e[r + 1] === "?") {
-                            r = c(e, ++r);
-                            if (r.err) return r;
+                    let f = u.value;
+                    i = u.index;
+                    if (f[f.length - 1] === "/") {
+                        const r = i - f.length;
+                        f = f.substring(0, f.length - 1);
+                        const s = validateAttributeString(f, t);
+                        if (s === true) {
+                            n = true;
                         } else {
-                            break;
+                            return getErrorObject(s.err.code, s.err.msg, getLineNumberForPosition(e, r + s.err.line));
+                        }
+                    } else if (a) {
+                        if (!u.tagClosed) {
+                            return getErrorObject("InvalidTag", "Closing tag '" + l + "' doesn't have proper closing.", getLineNumberForPosition(e, i));
+                        } else if (f.trim().length > 0) {
+                            return getErrorObject("InvalidTag", "Closing tag '" + l + "' can't have attributes or invalid starting.", getLineNumberForPosition(e, o));
+                        } else if (r.length === 0) {
+                            return getErrorObject("InvalidTag", "Closing tag '" + l + "' has not been opened.", getLineNumberForPosition(e, o));
+                        } else {
+                            const t = r.pop();
+                            if (l !== t.tagName) {
+                                let i = getLineNumberForPosition(e, t.tagStartPos);
+                                return getErrorObject("InvalidTag", "Expected closing tag '" + t.tagName + "' (opened in line " + i.line + ", col " + i.col + ") instead of closing tag '" + l + "'.", getLineNumberForPosition(e, o));
+                            }
+                            if (r.length == 0) {
+                                s = true;
+                            }
                         }
-                    } else if (e[r] === "&") {
-                        const t = w(e, r);
-                        if (t == -1) return T("InvalidChar", "char '&' is not expected.", v(e, r));
-                        r = t;
                     } else {
-                        if (s === true && !h(e[r])) {
-                            return T("InvalidXml", "Extra text at the end", v(e, r));
+                        const a = validateAttributeString(f, t);
+                        if (a !== true) {
+                            return getErrorObject(a.err.code, a.err.msg, getLineNumberForPosition(e, i - f.length + a.err.line));
+                        }
+                        if (s === true) {
+                            return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(e, i));
+                        } else if (t.unpairedTags.indexOf(l) !== -1) {} else {
+                            r.push({
+                                tagName: l,
+                                tagStartPos: o
+                            });
                         }
+                        n = true;
+                    }
+                    for (i++; i < e.length; i++) {
+                        if (e[i] === "<") {
+                            if (e[i + 1] === "!") {
+                                i++;
+                                i = readCommentAndCDATA(e, i);
+                                continue;
+                            } else if (e[i + 1] === "?") {
+                                i = readPI(e, ++i);
+                                if (i.err) return i;
+                            } else {
+                                break;
+                            }
+                        } else if (e[i] === "&") {
+                            const t = validateAmpersand(e, i);
+                            if (t == -1) return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(e, i));
+                            i = t;
+                        } else {
+                            if (s === true && !isWhiteSpace(e[i])) {
+                                return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(e, i));
+                            }
+                        }
+                    }
+                    if (e[i] === "<") {
+                        i--;
                     }
                 }
-                if (e[r] === "<") {
-                    r--;
+            } else {
+                if (isWhiteSpace(e[i])) {
+                    continue;
                 }
+                return getErrorObject("InvalidChar", "char '" + e[i] + "' is not expected.", getLineNumberForPosition(e, i));
             }
-        } else {
-            if (h(e[r])) {
-                continue;
-            }
-            return T("InvalidChar", "char '" + e[r] + "' is not expected.", v(e, r));
         }
-    }
-    if (!n) {
-        return T("InvalidXml", "Start tag expected.", 1);
-    } else if (i.length == 1) {
-        return T("InvalidTag", "Unclosed tag '" + i[0].tagName + "'.", v(e, i[0].tagStartPos));
-    } else if (i.length > 0) {
-        return T("InvalidXml", "Invalid '" + JSON.stringify(i.map((e => e.tagName)), null, 4).replace(/\r?\n/g, "") + "' found.", {
-            line: 1,
-            col: 1
-        });
-    }
-    return true;
-}
-
-function h(e) {
-    return e === " " || e === "\t" || e === "\n" || e === "\r";
-}
-
-function c(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 T("InvalidXml", "XML declaration allowed only at the start of the document.", v(e, t));
-            } else if (e[t] == "?" && e[t + 1] == ">") {
-                t++;
-                break;
-            } else {
-                continue;
+        if (!n) {
+            return getErrorObject("InvalidXml", "Start tag expected.", 1);
+        } else if (r.length == 1) {
+            return getErrorObject("InvalidTag", "Unclosed tag '" + r[0].tagName + "'.", getLineNumberForPosition(e, r[0].tagStartPos));
+        } else if (r.length > 0) {
+            return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(r.map((e => e.tagName)), null, 4).replace(/\r?\n/g, "") + "' found.", {
+                line: 1,
+                col: 1
+            });
+        }
+        return true;
+    };
+    function isWhiteSpace(e) {
+        return e === " " || e === "\t" || e === "\n" || e === "\r";
+    }
+    function readPI(e, t) {
+        const i = t;
+        for (;t < e.length; t++) {
+            if (e[t] == "?" || e[t] == " ") {
+                const r = e.substr(i, t - i);
+                if (t > 5 && r === "xml") {
+                    return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(e, t));
+                } else if (e[t] == "?" && e[t + 1] == ">") {
+                    t++;
+                    break;
+                } else {
+                    continue;
+                }
             }
         }
+        return t;
     }
-    return t;
-}
-
-function p(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;
-                break;
+    function readCommentAndCDATA(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;
+                    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) {
+                        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;
+                    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++;
+        return t;
+    }
+    const r = '"';
+    const s = "'";
+    function readAttributeStr(e, t) {
+        let i = "";
+        let n = "";
+        let o = false;
+        for (;t < e.length; t++) {
+            if (e[t] === r || e[t] === s) {
+                if (n === "") {
+                    n = e[t];
+                } else if (n !== e[t]) {} else {
+                    n = "";
+                }
             } else if (e[t] === ">") {
-                i--;
-                if (i === 0) {
+                if (n === "") {
+                    o = true;
                     break;
                 }
             }
+            i += e[t];
         }
-    } 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;
-                break;
-            }
+        if (n !== "") {
+            return false;
         }
+        return {
+            value: i,
+            index: t,
+            tagClosed: o
+        };
     }
-    return t;
-}
-
-const g = '"';
-
-const m = "'";
-
-function x(e, t) {
-    let i = "";
-    let n = "";
-    let s = false;
-    for (;t < e.length; t++) {
-        if (e[t] === g || e[t] === m) {
-            if (n === "") {
-                n = e[t];
-            } else if (n !== e[t]) {} else {
-                n = "";
+    const o = new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?", "g");
+    function validateAttributeString(t, i) {
+        const r = e.getAllMatches(t, o);
+        const n = {};
+        for (let e = 0; e < r.length; e++) {
+            if (r[e][1].length === 0) {
+                return getErrorObject("InvalidAttr", "Attribute '" + r[e][2] + "' has no space in starting.", getPositionFromMatch(r[e]));
+            } else if (r[e][3] !== undefined && r[e][4] === undefined) {
+                return getErrorObject("InvalidAttr", "Attribute '" + r[e][2] + "' is without value.", getPositionFromMatch(r[e]));
+            } else if (r[e][3] === undefined && !i.allowBooleanAttributes) {
+                return getErrorObject("InvalidAttr", "boolean attribute '" + r[e][2] + "' is not allowed.", getPositionFromMatch(r[e]));
             }
-        } else if (e[t] === ">") {
-            if (n === "") {
-                s = true;
-                break;
+            const t = r[e][2];
+            if (!validateAttrName(t)) {
+                return getErrorObject("InvalidAttr", "Attribute '" + t + "' is an invalid name.", getPositionFromMatch(r[e]));
+            }
+            if (!n.hasOwnProperty(t)) {
+                n[t] = 1;
+            } else {
+                return getErrorObject("InvalidAttr", "Attribute '" + t + "' is repeated.", getPositionFromMatch(r[e]));
             }
         }
-        i += e[t];
-    }
-    if (n !== "") {
-        return false;
+        return true;
     }
-    return {
-        value: i,
-        index: t,
-        tagClosed: s
-    };
-}
-
-const N = new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?", "g");
-
-function b(e, t) {
-    const i = s(e, N);
-    const n = {};
-    for (let e = 0; e < i.length; e++) {
-        if (i[e][1].length === 0) {
-            return T("InvalidAttr", "Attribute '" + i[e][2] + "' has no space in starting.", O(i[e]));
-        } else if (i[e][3] !== undefined && i[e][4] === undefined) {
-            return T("InvalidAttr", "Attribute '" + i[e][2] + "' is without value.", O(i[e]));
-        } else if (i[e][3] === undefined && !t.allowBooleanAttributes) {
-            return T("InvalidAttr", "boolean attribute '" + i[e][2] + "' is not allowed.", O(i[e]));
-        }
-        const s = i[e][2];
-        if (!y(s)) {
-            return T("InvalidAttr", "Attribute '" + s + "' is an invalid name.", O(i[e]));
-        }
-        if (!n.hasOwnProperty(s)) {
-            n[s] = 1;
-        } else {
-            return T("InvalidAttr", "Attribute '" + s + "' is repeated.", O(i[e]));
+    function validateNumberAmpersand(e, t) {
+        let i = /\d/;
+        if (e[t] === "x") {
+            t++;
+            i = /[\da-fA-F]/;
+        }
+        for (;t < e.length; t++) {
+            if (e[t] === ";") return t;
+            if (!e[t].match(i)) break;
         }
+        return -1;
     }
-    return true;
-}
-
-function E(e, t) {
-    let i = /\d/;
-    if (e[t] === "x") {
+    function validateAmpersand(e, t) {
         t++;
-        i = /[\da-fA-F]/;
+        if (e[t] === ";") return -1;
+        if (e[t] === "#") {
+            t++;
+            return validateNumberAmpersand(e, t);
+        }
+        let i = 0;
+        for (;t < e.length; t++, i++) {
+            if (e[t].match(/\w/) && i < 20) continue;
+            if (e[t] === ";") break;
+            return -1;
+        }
+        return t;
+    }
+    function getErrorObject(e, t, i) {
+        return {
+            err: {
+                code: e,
+                msg: t,
+                line: i.line || i,
+                col: i.col
+            }
+        };
     }
-    for (;t < e.length; t++) {
-        if (e[t] === ";") return t;
-        if (!e[t].match(i)) break;
+    function validateAttrName(t) {
+        return e.isName(t);
     }
-    return -1;
-}
-
-function w(e, t) {
-    t++;
-    if (e[t] === ";") return -1;
-    if (e[t] === "#") {
-        t++;
-        return E(e, t);
+    function validateTagName(t) {
+        return e.isName(t);
     }
-    let i = 0;
-    for (;t < e.length; t++, i++) {
-        if (e[t].match(/\w/) && i < 20) continue;
-        if (e[t] === ";") break;
-        return -1;
+    function getLineNumberForPosition(e, t) {
+        const i = e.substring(0, t).split(/\r?\n/);
+        return {
+            line: i.length,
+            col: i[i.length - 1].length + 1
+        };
+    }
+    function getPositionFromMatch(e) {
+        return e.startIndex + e[1].length;
     }
     return t;
 }
 
-function T(e, t, i) {
-    return {
-        err: {
-            code: e,
-            msg: t,
-            line: i.line || i,
-            col: i.col
+var s = {};
+
+var o;
+
+function requireOptionsBuilder() {
+    if (o) return s;
+    o = 1;
+    const e = {
+        preserveOrder: false,
+        attributeNamePrefix: "@_",
+        attributesGroupName: false,
+        textNodeName: "#text",
+        ignoreAttributes: true,
+        removeNSPrefix: false,
+        allowBooleanAttributes: false,
+        parseTagValue: true,
+        parseAttributeValue: false,
+        trimValues: true,
+        cdataPropName: false,
+        numberParseOptions: {
+            hex: true,
+            leadingZeros: true,
+            eNotation: true
+        },
+        tagValueProcessor: function(e, t) {
+            return t;
+        },
+        attributeValueProcessor: function(e, t) {
+            return t;
+        },
+        stopNodes: [],
+        alwaysCreateTextNode: false,
+        isArray: () => false,
+        commentPropName: false,
+        unpairedTags: [],
+        processEntities: true,
+        htmlEntities: false,
+        ignoreDeclaration: false,
+        ignorePiTags: false,
+        transformTagName: false,
+        transformAttributeName: false,
+        updateTag: function(e, t, i) {
+            return e;
         }
     };
-}
-
-function y(e) {
-    return r(e);
-}
-
-function I(e) {
-    return r(e);
-}
-
-function v(e, t) {
-    const i = e.substring(0, t).split(/\r?\n/);
-    return {
-        line: i.length,
-        col: i[i.length - 1].length + 1
+    const buildOptions = function(t) {
+        return Object.assign({}, e, t);
     };
+    s.buildOptions = buildOptions;
+    s.defaultOptions = e;
+    return s;
 }
 
-function O(e) {
-    return e.startIndex + e[1].length;
-}
+var a;
 
-const P = {
-    preserveOrder: false,
-    attributeNamePrefix: "@_",
-    attributesGroupName: false,
-    textNodeName: "#text",
-    ignoreAttributes: true,
-    removeNSPrefix: false,
-    allowBooleanAttributes: false,
-    parseTagValue: true,
-    parseAttributeValue: false,
-    trimValues: true,
-    cdataPropName: false,
-    numberParseOptions: {
-        hex: true,
-        leadingZeros: true,
-        eNotation: true
-    },
-    tagValueProcessor: function(e, t) {
-        return t;
-    },
-    attributeValueProcessor: function(e, t) {
-        return t;
-    },
-    stopNodes: [],
-    alwaysCreateTextNode: false,
-    isArray: () => false,
-    commentPropName: false,
-    unpairedTags: [],
-    processEntities: true,
-    htmlEntities: false,
-    ignoreDeclaration: false,
-    ignorePiTags: false,
-    transformTagName: false,
-    transformAttributeName: false,
-    updateTag: function(e, t, i) {
-        return e;
-    },
-    captureMetaData: false
-};
-
-const A = function(e) {
-    return Object.assign({}, P, e);
-};
-
-"use strict";
+var l;
 
-let C;
-
-if (typeof Symbol !== "function") {
-    C = "@@xmlMetadata";
-} else {
-    C = Symbol("XML Node Metadata");
-}
-
-class XmlNode {
-    constructor(e) {
-        this.tagname = e;
-        this.child = [];
-        this[":@"] = {};
-    }
-    add(e, t) {
-        if (e === "__proto__") e = "#__proto__";
-        this.child.push({
-            [e]: t
-        });
-    }
-    addChild(e, t) {
-        if (e.tagname === "__proto__") e.tagname = "#__proto__";
-        if (e[":@"] && Object.keys(e[":@"]).length > 0) {
-            this.child.push({
-                [e.tagname]: e.child,
-                [":@"]: e[":@"]
-            });
-        } else {
+function requireXmlNode() {
+    if (l) return a;
+    l = 1;
+    "use strict";
+    class XmlNode {
+        constructor(e) {
+            this.tagname = e;
+            this.child = [];
+            this[":@"] = {};
+        }
+        add(e, t) {
+            if (e === "__proto__") e = "#__proto__";
             this.child.push({
-                [e.tagname]: e.child
+                [e]: t
             });
         }
-        if (t !== undefined) {
-            this.child[this.child.length - 1][C] = {
-                startIndex: t
-            };
+        addChild(e) {
+            if (e.tagname === "__proto__") e.tagname = "#__proto__";
+            if (e[":@"] && Object.keys(e[":@"]).length > 0) {
+                this.child.push({
+                    [e.tagname]: e.child,
+                    [":@"]: e[":@"]
+                });
+            } else {
+                this.child.push({
+                    [e.tagname]: e.child
+                });
+            }
         }
     }
-    static getMetaDataSymbol() {
-        return C;
-    }
+    a = XmlNode;
+    return a;
 }
 
-class DocTypeReader {
-    constructor(e) {
-        this.suppressValidationErr = !e;
-    }
-    readDocType(e, t) {
+var u;
+
+var f;
+
+function requireDocTypeReader() {
+    if (f) return u;
+    f = 1;
+    const e = requireUtil();
+    function readDocType(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;
-            let s = false, r = false;
+            let r = 1;
+            let n = false, s = false;
             let o = "";
             for (;t < e.length; t++) {
-                if (e[t] === "<" && !r) {
-                    if (s && V(e, "!ENTITY", t)) {
+                if (e[t] === "<" && !s) {
+                    if (n && isEntity(e, t)) {
                         t += 7;
-                        let n, s;
-                        [n, s, t] = this.readEntityExp(e, t + 1, this.suppressValidationErr);
-                        if (s.indexOf("&") === -1) i[n] = {
-                            regx: RegExp(`&${n};`, "g"),
-                            val: s
+                        let r, n;
+                        [r, n, t] = readEntityExp(e, t + 1);
+                        if (n.indexOf("&") === -1) i[validateEntityName(r)] = {
+                            regx: RegExp(`&${r};`, "g"),
+                            val: n
                         };
-                    } else if (s && V(e, "!ELEMENT", t)) {
-                        t += 8;
-                        const {index: i} = this.readElementExp(e, t + 1);
-                        t = i;
-                    } else if (s && V(e, "!ATTLIST", t)) {
-                        t += 8;
-                    } else if (s && V(e, "!NOTATION", t)) {
-                        t += 9;
-                        const {index: i} = this.readNotationExp(e, t + 1, this.suppressValidationErr);
-                        t = i;
-                    } else if (V(e, "!--", t)) r = true; else throw new Error(`Invalid DOCTYPE`);
-                    n++;
+                    } else if (n && isElement(e, t)) t += 8; else if (n && isAttlist(e, t)) t += 8; else if (n && isNotation(e, t)) t += 9; else if (isComment) s = true; else throw new Error("Invalid DOCTYPE");
+                    r++;
                     o = "";
                 } else if (e[t] === ">") {
-                    if (r) {
+                    if (s) {
                         if (e[t - 1] === "-" && e[t - 2] === "-") {
-                            r = false;
-                            n--;
+                            s = false;
+                            r--;
                         }
                     } else {
-                        n--;
+                        r--;
                     }
-                    if (n === 0) {
+                    if (r === 0) {
                         break;
                     }
                 } else if (e[t] === "[") {
-                    s = true;
+                    n = true;
                 } else {
                     o += e[t];
                 }
             }
-            if (n !== 0) {
+            if (r !== 0) {
                 throw new Error(`Unclosed DOCTYPE`);
             }
         } else {
@@ -526,1377 +521,1234 @@ class DocTypeReader {
             i: t
         };
     }
-    readEntityExp(e, t) {
-        t = S(e, t);
+    function readEntityExp(e, t) {
         let i = "";
-        while (t < e.length && !/\s/.test(e[t]) && e[t] !== '"' && e[t] !== "'") {
+        for (;t < e.length && (e[t] !== "'" && e[t] !== '"'); t++) {
             i += e[t];
-            t++;
-        }
-        D(i);
-        t = S(e, t);
-        if (!this.suppressValidationErr) {
-            if (e.substring(t, t + 6).toUpperCase() === "SYSTEM") {
-                throw new Error("External entities are not supported");
-            } else if (e[t] === "%") {
-                throw new Error("Parameter entities are not supported");
-            }
         }
+        i = i.trim();
+        if (i.indexOf(" ") !== -1) throw new Error("External entites are not supported");
+        const r = e[t++];
         let n = "";
-        [t, n] = this.readIdentifierVal(e, t, "entity");
-        t--;
+        for (;t < e.length && e[t] !== r; t++) {
+            n += e[t];
+        }
         return [ i, n, t ];
     }
-    readNotationExp(e, t) {
-        t = S(e, t);
-        let i = "";
-        while (t < e.length && !/\s/.test(e[t])) {
-            i += e[t];
-            t++;
-        }
-        !this.suppressValidationErr && D(i);
-        t = S(e, t);
-        const n = e.substring(t, t + 6).toUpperCase();
-        if (!this.suppressValidationErr && n !== "SYSTEM" && n !== "PUBLIC") {
-            throw new Error(`Expected SYSTEM or PUBLIC, found "${n}"`);
-        }
-        t += n.length;
-        t = S(e, t);
-        let s = null;
-        let r = null;
-        if (n === "PUBLIC") {
-            [t, s] = this.readIdentifierVal(e, t, "publicIdentifier");
-            t = S(e, t);
-            if (e[t] === '"' || e[t] === "'") {
-                [t, r] = this.readIdentifierVal(e, t, "systemIdentifier");
-            }
-        } else if (n === "SYSTEM") {
-            [t, r] = this.readIdentifierVal(e, t, "systemIdentifier");
-            if (!this.suppressValidationErr && !r) {
-                throw new Error("Missing mandatory system identifier for SYSTEM notation");
-            }
-        }
-        return {
-            notationName: i,
-            publicIdentifier: s,
-            systemIdentifier: r,
-            index: --t
-        };
+    function isComment(e, t) {
+        if (e[t + 1] === "!" && e[t + 2] === "-" && e[t + 3] === "-") return true;
+        return false;
     }
-    readIdentifierVal(e, t, i) {
-        let n = "";
-        const s = e[t];
-        if (s !== '"' && s !== "'") {
-            throw new Error(`Expected quoted string, found "${s}"`);
-        }
-        t++;
-        while (t < e.length && e[t] !== s) {
-            n += e[t];
-            t++;
-        }
-        if (e[t] !== s) {
-            throw new Error(`Unterminated ${i} value`);
-        }
-        t++;
-        return [ t, n ];
+    function isEntity(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;
+        return false;
     }
-    readElementExp(e, t) {
-        t = S(e, t);
-        let i = "";
-        while (t < e.length && !/\s/.test(e[t])) {
-            i += e[t];
-            t++;
-        }
-        if (!this.suppressValidationErr && !r(i)) {
-            throw new Error(`Invalid element name: "${i}"`);
-        }
-        t = S(e, t);
-        let n = "";
-        if (e[t] === "E" && V(e, "MPTY", t)) t += 4; else if (e[t] === "A" && V(e, "NY", t)) t += 2; else if (e[t] === "(") {
-            t++;
-            while (t < e.length && e[t] !== ")") {
-                n += e[t];
-                t++;
-            }
-            if (e[t] !== ")") {
-                throw new Error("Unterminated content model");
-            }
-        } else if (!this.suppressValidationErr) {
-            throw new Error(`Invalid Element Expression, found "${e[t]}"`);
-        }
-        return {
-            elementName: i,
-            contentModel: n.trim(),
-            index: t
-        };
+    function isElement(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;
+        return false;
     }
-    readAttlistExp(e, t) {
-        t = S(e, t);
-        let i = "";
-        while (t < e.length && !/\s/.test(e[t])) {
-            i += e[t];
-            t++;
-        }
-        D(i);
-        t = S(e, t);
-        let n = "";
-        while (t < e.length && !/\s/.test(e[t])) {
-            n += e[t];
-            t++;
-        }
-        if (!D(n)) {
-            throw new Error(`Invalid attribute name: "${n}"`);
-        }
-        t = S(e, t);
-        let s = "";
-        if (e.substring(t, t + 8).toUpperCase() === "NOTATION") {
-            s = "NOTATION";
-            t += 8;
-            t = S(e, t);
-            if (e[t] !== "(") {
-                throw new Error(`Expected '(', found "${e[t]}"`);
-            }
-            t++;
-            let i = [];
-            while (t < e.length && e[t] !== ")") {
-                let n = "";
-                while (t < e.length && e[t] !== "|" && e[t] !== ")") {
-                    n += e[t];
-                    t++;
-                }
-                n = n.trim();
-                if (!D(n)) {
-                    throw new Error(`Invalid notation name: "${n}"`);
-                }
-                i.push(n);
-                if (e[t] === "|") {
-                    t++;
-                    t = S(e, t);
-                }
-            }
-            if (e[t] !== ")") {
-                throw new Error("Unterminated list of notations");
-            }
-            t++;
-            s += " (" + i.join("|") + ")";
-        } else {
-            while (t < e.length && !/\s/.test(e[t])) {
-                s += e[t];
-                t++;
-            }
-            const i = [ "CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS" ];
-            if (!this.suppressValidationErr && !i.includes(s.toUpperCase())) {
-                throw new Error(`Invalid attribute type: "${s}"`);
-            }
-        }
-        t = S(e, t);
-        let r = "";
-        if (e.substring(t, t + 8).toUpperCase() === "#REQUIRED") {
-            r = "#REQUIRED";
-            t += 8;
-        } else if (e.substring(t, t + 7).toUpperCase() === "#IMPLIED") {
-            r = "#IMPLIED";
-            t += 7;
-        } else {
-            [t, r] = this.readIdentifierVal(e, t, "ATTLIST");
-        }
-        return {
-            elementName: i,
-            attributeName: n,
-            attributeType: s,
-            defaultValue: r,
-            index: t
-        };
+    function isAttlist(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;
+        return false;
     }
-}
-
-const S = (e, t) => {
-    while (t < e.length && /\s/.test(e[t])) {
-        t++;
+    function isNotation(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;
+        return false;
     }
-    return t;
-};
-
-function V(e, t, i) {
-    for (let n = 0; n < t.length; n++) {
-        if (t[n] !== e[i + n + 1]) return false;
+    function validateEntityName(t) {
+        if (e.isName(t)) return t; else throw new Error(`Invalid entity name ${t}`);
     }
-    return true;
+    u = readDocType;
+    return u;
 }
 
-function D(e) {
-    if (r(e)) return e; else throw new Error(`Invalid entity name ${e}`);
-}
-
-const $ = /^[-+]?0x[a-fA-F0-9]+$/;
-
-const j = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
+var d;
 
-const k = {
-    hex: true,
-    leadingZeros: true,
-    decimalPoint: ".",
-    eNotation: true
-};
+var c;
 
-function F(e, t = {}) {
-    t = Object.assign({}, k, t);
-    if (!e || typeof e !== "string") return e;
-    let i = e.trim();
-    if (t.skipLike !== undefined && t.skipLike.test(i)) return e; else if (e === "0") return 0; else if (t.hex && $.test(i)) {
-        return U(i, 16);
-    } else if (i.search(/.+[eE].+/) !== -1) {
-        return _(e, i, t);
-    } else {
-        const n = j.exec(i);
-        if (n) {
-            const s = n[1] || "";
-            const r = n[2];
-            let o = L(n[3]);
-            const a = s ? e[r.length + 1] === "." : e[r.length] === ".";
-            if (!t.leadingZeros && (r.length > 1 || r.length === 1 && !a)) {
-                return e;
-            } else {
-                const n = Number(i);
-                const a = String(n);
-                if (n === 0) return n;
-                if (a.search(/[eE]/) !== -1) {
-                    if (t.eNotation) return n; else return e;
-                } else if (i.indexOf(".") !== -1) {
-                    if (a === "0") return n; else if (a === o) return n; else if (a === `${s}${o}`) return n; else return e;
-                }
-                let l = r ? o : i;
-                if (r) {
-                    return l === a || s + l === a ? n : e;
+function requireStrnum() {
+    if (c) return d;
+    c = 1;
+    const e = /^[-+]?0x[a-fA-F0-9]+$/;
+    const t = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
+    const i = {
+        hex: true,
+        leadingZeros: true,
+        decimalPoint: ".",
+        eNotation: true
+    };
+    function toNumber(r, n = {}) {
+        n = Object.assign({}, i, n);
+        if (!r || typeof r !== "string") return r;
+        let s = r.trim();
+        if (n.skipLike !== undefined && n.skipLike.test(s)) return r; else if (r === "0") return 0; else if (n.hex && e.test(s)) {
+            return parse_int(s, 16);
+        } else if (s.search(/[eE]/) !== -1) {
+            const e = s.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)$/);
+            if (e) {
+                if (n.leadingZeros) {
+                    s = (e[1] || "") + e[3];
                 } else {
-                    return l === a || l === s + a ? n : e;
+                    if (e[2] === "0" && e[3][0] === ".") {} else {
+                        return r;
+                    }
                 }
+                return n.eNotation ? Number(s) : r;
+            } else {
+                return r;
             }
         } else {
-            return e;
+            const e = t.exec(s);
+            if (e) {
+                const t = e[1];
+                const i = e[2];
+                let o = trimZeros(e[3]);
+                if (!n.leadingZeros && i.length > 0 && t && s[2] !== ".") return r; else if (!n.leadingZeros && i.length > 0 && !t && s[1] !== ".") return r; else if (n.leadingZeros && i === r) return 0; else {
+                    const e = Number(s);
+                    const a = "" + e;
+                    if (a.search(/[eE]/) !== -1) {
+                        if (n.eNotation) return e; else return r;
+                    } else if (s.indexOf(".") !== -1) {
+                        if (a === "0" && o === "") return e; else if (a === o) return e; else if (t && a === "-" + o) return e; else return r;
+                    }
+                    if (i) {
+                        return o === a || t + o === a ? e : r;
+                    } else {
+                        return s === a || s === t + a ? e : r;
+                    }
+                }
+            } else {
+                return r;
+            }
         }
     }
-}
-
-const M = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
-
-function _(e, t, i) {
-    if (!i.eNotation) return e;
-    const n = t.match(M);
-    if (n) {
-        let s = n[1] || "";
-        const r = n[3].indexOf("e") === -1 ? "E" : "e";
-        const o = n[2];
-        const a = s ? e[o.length + 1] === r : e[o.length] === r;
-        if (o.length > 1 && a) return e; else if (o.length === 1 && (n[3].startsWith(`.${r}`) || n[3][0] === r)) {
-            return Number(t);
-        } else if (i.leadingZeros && !a) {
-            t = (n[1] || "") + n[3];
-            return Number(t);
-        } else return e;
-    } else {
+    function trimZeros(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;
+        }
         return e;
     }
-}
-
-function L(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.substring(0, e.length - 1);
-        return e;
+    function parse_int(e, t) {
+        if (parseInt) return parseInt(e, t); else if (Number.parseInt) return Number.parseInt(e, t); else if (window && window.parseInt) return window.parseInt(e, t); else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
     }
-    return e;
+    d = toNumber;
+    return d;
 }
 
-function U(e, t) {
-    if (parseInt) return parseInt(e, t); else if (Number.parseInt) return Number.parseInt(e, t); else if (window && window.parseInt) return window.parseInt(e, t); else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
-}
+var g;
 
-function R(e) {
-    if (typeof e === "function") {
-        return e;
-    }
-    if (Array.isArray(e)) {
-        return t => {
-            for (const i of e) {
-                if (typeof i === "string" && t === i) {
-                    return true;
-                }
-                if (i instanceof RegExp && i.test(t)) {
-                    return true;
-                }
-            }
-        };
-    }
-    return () => false;
-}
-
-"use strict";
+var h;
 
-class OrderedObjParser {
-    constructor(e) {
-        this.options = e;
-        this.currentNode = null;
-        this.tagsNodeStack = [];
-        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: '"'
-            }
-        };
-        this.ampEntity = {
-            regex: /&(amp|#38|#x26);/g,
-            val: "&"
-        };
-        this.htmlEntities = {
-            space: {
-                regex: /&(nbsp|#160);/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: (e, t) => String.fromCodePoint(Number.parseInt(t, 10))
-            },
-            num_hex: {
-                regex: /&#x([0-9a-fA-F]{1,6});/g,
-                val: (e, t) => String.fromCodePoint(Number.parseInt(t, 16))
-            }
-        };
-        this.addExternalEntities = X;
-        this.parseXml = q;
-        this.parseTextData = B;
-        this.resolveNameSpace = Y;
-        this.buildAttributesMap = W;
-        this.isItStopNode = z;
-        this.replaceEntitiesValue = K;
-        this.readStopNodeData = te;
-        this.saveTextToParentTag = Q;
-        this.addChild = Z;
-        this.ignoreAttributesFn = R(this.options.ignoreAttributes);
-        if (this.options.stopNodes && this.options.stopNodes.length > 0) {
-            this.stopNodesExact = new Set;
-            this.stopNodesWildcard = new Set;
-            for (let e = 0; e < this.options.stopNodes.length; e++) {
-                const t = this.options.stopNodes[e];
-                if (typeof t !== "string") continue;
-                if (t.startsWith("*.")) {
-                    this.stopNodesWildcard.add(t.substring(2));
-                } else {
-                    this.stopNodesExact.add(t);
+function requireIgnoreAttributes() {
+    if (h) return g;
+    h = 1;
+    function getIgnoreAttributesFn(e) {
+        if (typeof e === "function") {
+            return e;
+        }
+        if (Array.isArray(e)) {
+            return t => {
+                for (const i of e) {
+                    if (typeof i === "string" && t === i) {
+                        return true;
+                    }
+                    if (i instanceof RegExp && i.test(t)) {
+                        return true;
+                    }
                 }
-            }
+            };
         }
+        return () => false;
     }
+    g = getIgnoreAttributesFn;
+    return g;
 }
 
-function X(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]
-        };
+var p;
+
+var m;
+
+function requireOrderedObjParser() {
+    if (m) return p;
+    m = 1;
+    "use strict";
+    const e = requireUtil();
+    const t = requireXmlNode();
+    const i = requireDocTypeReader();
+    const r = requireStrnum();
+    const n = requireIgnoreAttributes();
+    class OrderedObjParser {
+        constructor(e) {
+            this.options = e;
+            this.currentNode = null;
+            this.tagsNodeStack = [];
+            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: '"'
+                }
+            };
+            this.ampEntity = {
+                regex: /&(amp|#38|#x26);/g,
+                val: "&"
+            };
+            this.htmlEntities = {
+                space: {
+                    regex: /&(nbsp|#160);/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: (e, t) => String.fromCharCode(Number.parseInt(t, 10))
+                },
+                num_hex: {
+                    regex: /&#x([0-9a-fA-F]{1,6});/g,
+                    val: (e, t) => String.fromCharCode(Number.parseInt(t, 16))
+                }
+            };
+            this.addExternalEntities = addExternalEntities;
+            this.parseXml = parseXml;
+            this.parseTextData = parseTextData;
+            this.resolveNameSpace = resolveNameSpace;
+            this.buildAttributesMap = buildAttributesMap;
+            this.isItStopNode = isItStopNode;
+            this.replaceEntitiesValue = replaceEntitiesValue;
+            this.readStopNodeData = readStopNodeData;
+            this.saveTextToParentTag = saveTextToParentTag;
+            this.addChild = addChild;
+            this.ignoreAttributesFn = n(this.options.ignoreAttributes);
+        }
+    }
+    function addExternalEntities(e) {
+        const t = Object.keys(e);
+        for (let i = 0; i < t.length; i++) {
+            const r = t[i];
+            this.lastEntities[r] = {
+                regex: new RegExp("&" + r + ";", "g"),
+                val: e[r]
+            };
+        }
     }
-}
-
-function B(e, t, i, n, s, r, o) {
-    if (e !== undefined) {
-        if (this.options.trimValues && !n) {
-            e = e.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;
-            } else if (this.options.trimValues) {
-                return ie(e, this.options.parseTagValue, this.options.numberParseOptions);
-            } else {
-                const t = e.trim();
-                if (t === e) {
-                    return ie(e, this.options.parseTagValue, this.options.numberParseOptions);
-                } else {
+    function parseTextData(e, t, i, r, n, s, o) {
+        if (e !== undefined) {
+            if (this.options.trimValues && !r) {
+                e = e.trim();
+            }
+            if (e.length > 0) {
+                if (!o) e = this.replaceEntitiesValue(e);
+                const r = this.options.tagValueProcessor(t, e, i, n, s);
+                if (r === null || r === undefined) {
                     return e;
+                } else if (typeof r !== typeof e || r !== e) {
+                    return r;
+                } else if (this.options.trimValues) {
+                    return parseValue(e, this.options.parseTagValue, this.options.numberParseOptions);
+                } else {
+                    const t = e.trim();
+                    if (t === e) {
+                        return parseValue(e, this.options.parseTagValue, this.options.numberParseOptions);
+                    } else {
+                        return e;
+                    }
                 }
             }
         }
     }
-}
-
-function Y(e) {
-    if (this.options.removeNSPrefix) {
-        const t = e.split(":");
-        const i = e.charAt(0) === "/" ? "/" : "";
-        if (t[0] === "xmlns") {
-            return "";
-        }
-        if (t.length === 2) {
-            e = i + t[1];
+    function resolveNameSpace(e) {
+        if (this.options.removeNSPrefix) {
+            const t = e.split(":");
+            const i = e.charAt(0) === "/" ? "/" : "";
+            if (t[0] === "xmlns") {
+                return "";
+            }
+            if (t.length === 2) {
+                e = i + t[1];
+            }
         }
+        return e;
     }
-    return e;
-}
-
-const G = new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?", "gm");
-
-function W(e, t, i) {
-    if (this.options.ignoreAttributes !== true && typeof e === "string") {
-        const i = s(e, G);
-        const n = i.length;
-        const r = {};
-        for (let e = 0; e < n; e++) {
-            const n = this.resolveNameSpace(i[e][1]);
-            if (this.ignoreAttributesFn(n, t)) {
-                continue;
-            }
-            let s = i[e][4];
-            let o = this.options.attributeNamePrefix + n;
-            if (n.length) {
-                if (this.options.transformAttributeName) {
-                    o = this.options.transformAttributeName(o);
+    const s = new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?", "gm");
+    function buildAttributesMap(t, i, r) {
+        if (this.options.ignoreAttributes !== true && typeof t === "string") {
+            const r = e.getAllMatches(t, s);
+            const n = r.length;
+            const o = {};
+            for (let e = 0; e < n; e++) {
+                const t = this.resolveNameSpace(r[e][1]);
+                if (this.ignoreAttributesFn(t, i)) {
+                    continue;
                 }
-                if (o === "__proto__") o = "#__proto__";
-                if (s !== undefined) {
-                    if (this.options.trimValues) {
-                        s = s.trim();
+                let n = r[e][4];
+                let s = this.options.attributeNamePrefix + t;
+                if (t.length) {
+                    if (this.options.transformAttributeName) {
+                        s = this.options.transformAttributeName(s);
                     }
-                    s = this.replaceEntitiesValue(s);
-                    const e = this.options.attributeValueProcessor(n, s, t);
-                    if (e === null || e === undefined) {
-                        r[o] = s;
-                    } else if (typeof e !== typeof s || e !== s) {
-                        r[o] = e;
-                    } else {
-                        r[o] = ie(s, this.options.parseAttributeValue, this.options.numberParseOptions);
+                    if (s === "__proto__") s = "#__proto__";
+                    if (n !== undefined) {
+                        if (this.options.trimValues) {
+                            n = n.trim();
+                        }
+                        n = this.replaceEntitiesValue(n);
+                        const e = this.options.attributeValueProcessor(t, n, i);
+                        if (e === null || e === undefined) {
+                            o[s] = n;
+                        } else if (typeof e !== typeof n || e !== n) {
+                            o[s] = e;
+                        } else {
+                            o[s] = parseValue(n, this.options.parseAttributeValue, this.options.numberParseOptions);
+                        }
+                    } else if (this.options.allowBooleanAttributes) {
+                        o[s] = true;
                     }
-                } else if (this.options.allowBooleanAttributes) {
-                    r[o] = true;
                 }
             }
+            if (!Object.keys(o).length) {
+                return;
+            }
+            if (this.options.attributesGroupName) {
+                const e = {};
+                e[this.options.attributesGroupName] = o;
+                return e;
+            }
+            return o;
         }
-        if (!Object.keys(r).length) {
-            return;
-        }
-        if (this.options.attributesGroupName) {
-            const e = {};
-            e[this.options.attributesGroupName] = r;
-            return e;
-        }
-        return r;
     }
-}
-
-const q = function(e) {
-    e = e.replace(/\r\n?/g, "\n");
-    const t = new XmlNode("!xml");
-    let i = t;
-    let n = "";
-    let s = "";
-    const r = new DocTypeReader(this.options.processEntities);
-    for (let o = 0; o < e.length; o++) {
-        const a = e[o];
-        if (a === "<") {
-            if (e[o + 1] === "/") {
-                const t = H(e, ">", o, "Closing Tag is not closed.");
-                let r = e.substring(o + 2, t).trim();
-                if (this.options.removeNSPrefix) {
-                    const e = r.indexOf(":");
-                    if (e !== -1) {
-                        r = r.substr(e + 1);
+    const parseXml = function(e) {
+        e = e.replace(/\r\n?/g, "\n");
+        const r = new t("!xml");
+        let n = r;
+        let s = "";
+        let o = "";
+        for (let a = 0; a < e.length; a++) {
+            const l = e[a];
+            if (l === "<") {
+                if (e[a + 1] === "/") {
+                    const t = findClosingIndex(e, ">", a, "Closing Tag is not closed.");
+                    let i = e.substring(a + 2, t).trim();
+                    if (this.options.removeNSPrefix) {
+                        const e = i.indexOf(":");
+                        if (e !== -1) {
+                            i = i.substr(e + 1);
+                        }
                     }
-                }
-                if (this.options.transformTagName) {
-                    r = this.options.transformTagName(r);
-                }
-                if (i) {
-                    n = this.saveTextToParentTag(n, i, s);
-                }
-                const a = s.substring(s.lastIndexOf(".") + 1);
-                if (r && this.options.unpairedTags.indexOf(r) !== -1) {
-                    throw new Error(`Unpaired tag can not be used as closing tag: </${r}>`);
-                }
-                let l = 0;
-                if (a && this.options.unpairedTags.indexOf(a) !== -1) {
-                    l = s.lastIndexOf(".", s.lastIndexOf(".") - 1);
-                    this.tagsNodeStack.pop();
-                } else {
-                    l = s.lastIndexOf(".");
-                }
-                s = s.substring(0, l);
-                i = this.tagsNodeStack.pop();
-                n = "";
-                o = t;
-            } else if (e[o + 1] === "?") {
-                let t = ee(e, o, 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 XmlNode(t.tagName);
-                    e.add(this.options.textNodeName, "");
-                    if (t.tagName !== t.tagExp && t.attrExpPresent) {
-                        e[":@"] = this.buildAttributesMap(t.tagExp, s, t.tagName);
+                    if (this.options.transformTagName) {
+                        i = this.options.transformTagName(i);
                     }
-                    this.addChild(i, e, s, o);
-                }
-                o = t.closeIndex + 1;
-            } else if (e.substr(o + 1, 3) === "!--") {
-                const t = H(e, "--\x3e", o + 4, "Comment is not closed.");
-                if (this.options.commentPropName) {
-                    const r = e.substring(o + 4, t - 2);
-                    n = this.saveTextToParentTag(n, i, s);
-                    i.add(this.options.commentPropName, [ {
-                        [this.options.textNodeName]: r
-                    } ]);
-                }
-                o = t;
-            } else if (e.substr(o + 1, 2) === "!D") {
-                const t = r.readDocType(e, o);
-                this.docTypeEntities = t.entities;
-                o = t.i;
-            } else if (e.substr(o + 1, 2) === "![") {
-                const t = H(e, "]]>", o, "CDATA is not closed.") - 2;
-                const r = e.substring(o + 9, t);
-                n = this.saveTextToParentTag(n, i, s);
-                let a = this.parseTextData(r, i.tagname, s, true, false, true, true);
-                if (a == undefined) a = "";
-                if (this.options.cdataPropName) {
-                    i.add(this.options.cdataPropName, [ {
-                        [this.options.textNodeName]: r
-                    } ]);
-                } else {
-                    i.add(this.options.textNodeName, a);
-                }
-                o = t + 2;
-            } else {
-                let r = ee(e, o, this.options.removeNSPrefix);
-                let a = r.tagName;
-                const l = r.rawTagName;
-                let u = r.tagExp;
-                let f = r.attrExpPresent;
-                let d = r.closeIndex;
-                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) {
+                        s = this.saveTextToParentTag(s, n, o);
                     }
-                }
-                const h = i;
-                if (h && this.options.unpairedTags.indexOf(h.tagname) !== -1) {
-                    i = this.tagsNodeStack.pop();
-                    s = s.substring(0, s.lastIndexOf("."));
-                }
-                if (a !== t.tagname) {
-                    s += s ? "." + a : a;
-                }
-                const c = o;
-                if (this.isItStopNode(this.stopNodesExact, this.stopNodesWildcard, s, a)) {
-                    let t = "";
-                    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);
-                        }
-                        o = r.closeIndex;
-                    } else if (this.options.unpairedTags.indexOf(a) !== -1) {
-                        o = r.closeIndex;
+                    const r = o.substring(o.lastIndexOf(".") + 1);
+                    if (i && this.options.unpairedTags.indexOf(i) !== -1) {
+                        throw new Error(`Unpaired tag can not be used as closing tag: </${i}>`);
+                    }
+                    let l = 0;
+                    if (r && this.options.unpairedTags.indexOf(r) !== -1) {
+                        l = o.lastIndexOf(".", o.lastIndexOf(".") - 1);
+                        this.tagsNodeStack.pop();
                     } else {
-                        const i = this.readStopNodeData(e, l, d + 1);
-                        if (!i) throw new Error(`Unexpected end of ${l}`);
-                        o = i.i;
-                        t = i.tagContent;
+                        l = o.lastIndexOf(".");
+                    }
+                    o = o.substring(0, l);
+                    n = this.tagsNodeStack.pop();
+                    s = "";
+                    a = t;
+                } else if (e[a + 1] === "?") {
+                    let i = readTagExp(e, a, false, "?>");
+                    if (!i) throw new Error("Pi Tag is not closed.");
+                    s = this.saveTextToParentTag(s, n, o);
+                    if (this.options.ignoreDeclaration && i.tagName === "?xml" || this.options.ignorePiTags) {} else {
+                        const e = new t(i.tagName);
+                        e.add(this.options.textNodeName, "");
+                        if (i.tagName !== i.tagExp && i.attrExpPresent) {
+                            e[":@"] = this.buildAttributesMap(i.tagExp, o, i.tagName);
+                        }
+                        this.addChild(n, e, o);
                     }
-                    const n = new XmlNode(a);
-                    if (a !== u && f) {
-                        n[":@"] = this.buildAttributesMap(u, s, a);
+                    a = i.closeIndex + 1;
+                } else if (e.substr(a + 1, 3) === "!--") {
+                    const t = findClosingIndex(e, "--\x3e", a + 4, "Comment is not closed.");
+                    if (this.options.commentPropName) {
+                        const i = e.substring(a + 4, t - 2);
+                        s = this.saveTextToParentTag(s, n, o);
+                        n.add(this.options.commentPropName, [ {
+                            [this.options.textNodeName]: i
+                        } ]);
                     }
-                    if (t) {
-                        t = this.parseTextData(t, a, s, true, f, true, true);
+                    a = t;
+                } else if (e.substr(a + 1, 2) === "!D") {
+                    const t = i(e, a);
+                    this.docTypeEntities = t.entities;
+                    a = t.i;
+                } else if (e.substr(a + 1, 2) === "![") {
+                    const t = findClosingIndex(e, "]]>", a, "CDATA is not closed.") - 2;
+                    const i = e.substring(a + 9, t);
+                    s = this.saveTextToParentTag(s, n, o);
+                    let r = this.parseTextData(i, n.tagname, o, true, false, true, true);
+                    if (r == undefined) r = "";
+                    if (this.options.cdataPropName) {
+                        n.add(this.options.cdataPropName, [ {
+                            [this.options.textNodeName]: i
+                        } ]);
+                    } else {
+                        n.add(this.options.textNodeName, r);
                     }
-                    s = s.substr(0, s.lastIndexOf("."));
-                    n.add(this.options.textNodeName, t);
-                    this.addChild(i, n, s, c);
+                    a = t + 2;
                 } else {
-                    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;
+                    let i = readTagExp(e, a, this.options.removeNSPrefix);
+                    let l = i.tagName;
+                    const u = i.rawTagName;
+                    let f = i.tagExp;
+                    let d = i.attrExpPresent;
+                    let c = i.closeIndex;
+                    if (this.options.transformTagName) {
+                        l = this.options.transformTagName(l);
+                    }
+                    if (n && s) {
+                        if (n.tagname !== "!xml") {
+                            s = this.saveTextToParentTag(s, n, o, false);
+                        }
+                    }
+                    const g = n;
+                    if (g && this.options.unpairedTags.indexOf(g.tagname) !== -1) {
+                        n = this.tagsNodeStack.pop();
+                        o = o.substring(0, o.lastIndexOf("."));
+                    }
+                    if (l !== r.tagname) {
+                        o += o ? "." + l : l;
+                    }
+                    if (this.isItStopNode(this.options.stopNodes, o, l)) {
+                        let r = "";
+                        if (f.length > 0 && f.lastIndexOf("/") === f.length - 1) {
+                            if (l[l.length - 1] === "/") {
+                                l = l.substr(0, l.length - 1);
+                                o = o.substr(0, o.length - 1);
+                                f = l;
+                            } else {
+                                f = f.substr(0, f.length - 1);
+                            }
+                            a = i.closeIndex;
+                        } else if (this.options.unpairedTags.indexOf(l) !== -1) {
+                            a = i.closeIndex;
                         } else {
-                            u = u.substr(0, u.length - 1);
+                            const t = this.readStopNodeData(e, u, c + 1);
+                            if (!t) throw new Error(`Unexpected end of ${u}`);
+                            a = t.i;
+                            r = t.tagContent;
                         }
-                        if (this.options.transformTagName) {
-                            a = this.options.transformTagName(a);
+                        const s = new t(l);
+                        if (l !== f && d) {
+                            s[":@"] = this.buildAttributesMap(f, o, l);
                         }
-                        const e = new XmlNode(a);
-                        if (a !== u && f) {
-                            e[":@"] = this.buildAttributesMap(u, s, a);
+                        if (r) {
+                            r = this.parseTextData(r, l, o, true, d, true, true);
                         }
-                        this.addChild(i, e, s, c);
-                        s = s.substr(0, s.lastIndexOf("."));
+                        o = o.substr(0, o.lastIndexOf("."));
+                        s.add(this.options.textNodeName, r);
+                        this.addChild(n, s, o);
                     } else {
-                        const e = new XmlNode(a);
-                        this.tagsNodeStack.push(i);
-                        if (a !== u && f) {
-                            e[":@"] = this.buildAttributesMap(u, s, a);
+                        if (f.length > 0 && f.lastIndexOf("/") === f.length - 1) {
+                            if (l[l.length - 1] === "/") {
+                                l = l.substr(0, l.length - 1);
+                                o = o.substr(0, o.length - 1);
+                                f = l;
+                            } else {
+                                f = f.substr(0, f.length - 1);
+                            }
+                            if (this.options.transformTagName) {
+                                l = this.options.transformTagName(l);
+                            }
+                            const e = new t(l);
+                            if (l !== f && d) {
+                                e[":@"] = this.buildAttributesMap(f, o, l);
+                            }
+                            this.addChild(n, e, o);
+                            o = o.substr(0, o.lastIndexOf("."));
+                        } else {
+                            const e = new t(l);
+                            this.tagsNodeStack.push(n);
+                            if (l !== f && d) {
+                                e[":@"] = this.buildAttributesMap(f, o, l);
+                            }
+                            this.addChild(n, e, o);
+                            n = e;
                         }
-                        this.addChild(i, e, s, c);
-                        i = e;
+                        s = "";
+                        a = c;
                     }
-                    n = "";
-                    o = d;
                 }
+            } else {
+                s += e[a];
             }
+        }
+        return r.child;
+    };
+    function addChild(e, t, i) {
+        const r = this.options.updateTag(t.tagname, i, t[":@"]);
+        if (r === false) {} else if (typeof r === "string") {
+            t.tagname = r;
+            e.addChild(t);
         } else {
-            n += e[o];
+            e.addChild(t);
         }
     }
-    return t.child;
-};
-
-function Z(e, t, i, n) {
-    if (!this.options.captureMetaData) n = undefined;
-    const s = this.options.updateTag(t.tagname, i, t[":@"]);
-    if (s === false) {} else if (typeof s === "string") {
-        t.tagname = s;
-        e.addChild(t, n);
-    } else {
-        e.addChild(t, n);
-    }
-}
-
-const K = function(e) {
-    if (this.options.processEntities) {
-        for (let t in this.docTypeEntities) {
-            const i = this.docTypeEntities[t];
-            e = e.replace(i.regx, i.val);
-        }
-        for (let t in this.lastEntities) {
-            const i = this.lastEntities[t];
-            e = e.replace(i.regex, i.val);
-        }
-        if (this.options.htmlEntities) {
-            for (let t in this.htmlEntities) {
-                const i = this.htmlEntities[t];
+    const replaceEntitiesValue = function(e) {
+        if (this.options.processEntities) {
+            for (let t in this.docTypeEntities) {
+                const i = this.docTypeEntities[t];
+                e = e.replace(i.regx, i.val);
+            }
+            for (let t in this.lastEntities) {
+                const i = this.lastEntities[t];
                 e = e.replace(i.regex, i.val);
             }
+            if (this.options.htmlEntities) {
+                for (let t in this.htmlEntities) {
+                    const i = this.htmlEntities[t];
+                    e = e.replace(i.regex, i.val);
+                }
+            }
+            e = e.replace(this.ampEntity.regex, this.ampEntity.val);
+        }
+        return e;
+    };
+    function saveTextToParentTag(e, t, i, r) {
+        if (e) {
+            if (r === undefined) r = t.child.length === 0;
+            e = this.parseTextData(e, t.tagname, i, false, t[":@"] ? Object.keys(t[":@"]).length !== 0 : false, r);
+            if (e !== undefined && e !== "") t.add(this.options.textNodeName, e);
+            e = "";
         }
-        e = e.replace(this.ampEntity.regex, this.ampEntity.val);
+        return e;
     }
-    return e;
-};
-
-function Q(e, t, i, n) {
-    if (e) {
-        if (n === undefined) n = 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 isItStopNode(e, t, i) {
+        const r = "*." + i;
+        for (const i in e) {
+            const n = e[i];
+            if (r === n || t === n) return true;
+        }
+        return false;
     }
-    return e;
-}
-
-function z(e, t, i, n) {
-    if (t && t.has(n)) return true;
-    if (e && e.has(i)) return true;
-    return false;
-}
-
-function J(e, t, i = ">") {
-    let n;
-    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]) {
+    function tagExpWithClosingIndex(e, t, i = ">") {
+        let r;
+        let n = "";
+        for (let s = t; s < e.length; s++) {
+            let t = e[s];
+            if (r) {
+                if (t === r) r = "";
+            } else if (t === '"' || t === "'") {
+                r = t;
+            } else if (t === i[0]) {
+                if (i[1]) {
+                    if (e[s + 1] === i[1]) {
+                        return {
+                            data: n,
+                            index: s
+                        };
+                    }
+                } else {
                     return {
-                        data: s,
-                        index: r
+                        data: n,
+                        index: s
                     };
                 }
-            } else {
-                return {
-                    data: s,
-                    index: r
-                };
+            } else if (t === "\t") {
+                t = " ";
             }
-        } else if (t === "\t") {
-            t = " ";
+            n += t;
         }
-        s += t;
-    }
-}
-
-function H(e, t, i, n) {
-    const s = e.indexOf(t, i);
-    if (s === -1) {
-        throw new Error(n);
-    } else {
-        return s + t.length - 1;
-    }
-}
-
-function ee(e, t, i, n = ">") {
-    const s = J(e, t + 1, n);
-    if (!s) return;
-    let r = s.data;
-    const o = s.index;
-    const a = r.search(/\s/);
-    let l = r;
-    let u = true;
-    if (a !== -1) {
-        l = r.substring(0, a);
-        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);
+    function findClosingIndex(e, t, i, r) {
+        const n = e.indexOf(t, i);
+        if (n === -1) {
+            throw new Error(r);
+        } else {
+            return n + t.length - 1;
+        }
+    }
+    function readTagExp(e, t, i, r = ">") {
+        const n = tagExpWithClosingIndex(e, t + 1, r);
+        if (!n) return;
+        let s = n.data;
+        const o = n.index;
+        const a = s.search(/\s/);
+        let l = s;
+        let u = true;
+        if (a !== -1) {
+            l = s.substring(0, a);
+            s = s.substring(a + 1).trimStart();
+        }
+        const f = l;
+        if (i) {
+            const e = l.indexOf(":");
+            if (e !== -1) {
+                l = l.substr(e + 1);
+                u = l !== n.data.substr(e + 1);
+            }
         }
+        return {
+            tagName: l,
+            tagExp: s,
+            closeIndex: o,
+            attrExpPresent: u,
+            rawTagName: f
+        };
     }
-    return {
-        tagName: l,
-        tagExp: r,
-        closeIndex: o,
-        attrExpPresent: u,
-        rawTagName: f
-    };
-}
-
-function te(e, t, i) {
-    const n = i;
-    let s = 1;
-    for (;i < e.length; i++) {
-        if (e[i] === "<") {
-            if (e[i + 1] === "/") {
-                const r = H(e, ">", i, `${t} is not closed`);
-                let o = e.substring(i + 2, r).trim();
-                if (o === t) {
-                    s--;
-                    if (s === 0) {
-                        return {
-                            tagContent: e.substring(n, i),
-                            i: r
-                        };
+    function readStopNodeData(e, t, i) {
+        const r = i;
+        let n = 1;
+        for (;i < e.length; i++) {
+            if (e[i] === "<") {
+                if (e[i + 1] === "/") {
+                    const s = findClosingIndex(e, ">", i, `${t} is not closed`);
+                    let o = e.substring(i + 2, s).trim();
+                    if (o === t) {
+                        n--;
+                        if (n === 0) {
+                            return {
+                                tagContent: e.substring(r, i),
+                                i: s
+                            };
+                        }
                     }
-                }
-                i = r;
-            } else if (e[i + 1] === "?") {
-                const t = H(e, "?>", i + 1, "StopNode is not closed.");
-                i = t;
-            } else if (e.substr(i + 1, 3) === "!--") {
-                const t = H(e, "--\x3e", i + 3, "StopNode is not closed.");
-                i = t;
-            } else if (e.substr(i + 1, 2) === "![") {
-                const t = H(e, "]]>", i, "StopNode is not closed.") - 2;
-                i = t;
-            } else {
-                const n = ee(e, i, ">");
-                if (n) {
-                    const e = n && n.tagName;
-                    if (e === t && n.tagExp[n.tagExp.length - 1] !== "/") {
-                        s++;
+                    i = s;
+                } else if (e[i + 1] === "?") {
+                    const t = findClosingIndex(e, "?>", i + 1, "StopNode is not closed.");
+                    i = t;
+                } else if (e.substr(i + 1, 3) === "!--") {
+                    const t = findClosingIndex(e, "--\x3e", i + 3, "StopNode is not closed.");
+                    i = t;
+                } else if (e.substr(i + 1, 2) === "![") {
+                    const t = findClosingIndex(e, "]]>", i, "StopNode is not closed.") - 2;
+                    i = t;
+                } else {
+                    const r = readTagExp(e, i, ">");
+                    if (r) {
+                        const e = r && r.tagName;
+                        if (e === t && r.tagExp[r.tagExp.length - 1] !== "/") {
+                            n++;
+                        }
+                        i = r.closeIndex;
                     }
-                    i = n.closeIndex;
                 }
             }
         }
     }
-}
-
-function ie(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 F(e, i);
-    } else {
-        if (o(e)) {
-            return e;
+    function parseValue(t, i, n) {
+        if (i && typeof t === "string") {
+            const e = t.trim();
+            if (e === "true") return true; else if (e === "false") return false; else return r(t, n);
         } else {
-            return "";
+            if (e.isExist(t)) {
+                return t;
+            } else {
+                return "";
+            }
         }
     }
+    p = OrderedObjParser;
+    return p;
 }
 
-"use strict";
-
-const ne = XmlNode.getMetaDataSymbol();
-
-function se(e, t) {
-    return re(e, t);
-}
-
-function re(e, t, i) {
-    let n;
-    const s = {};
-    for (let r = 0; r < e.length; r++) {
-        const o = e[r];
-        const a = oe(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];
-        } else if (a === undefined) {
-            continue;
-        } else if (o[a]) {
-            let e = re(o[a], t, l);
-            const i = le(e, t);
-            if (o[ne] !== undefined) {
-                e[ne] = o[ne];
-            }
-            if (o[":@"]) {
-                ae(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 = "";
-            }
-            if (s[a] !== undefined && s.hasOwnProperty(a)) {
-                if (!Array.isArray(s[a])) {
-                    s[a] = [ s[a] ];
+var b = {};
+
+var x;
+
+function requireNode2json() {
+    if (x) return b;
+    x = 1;
+    "use strict";
+    function prettify(e, t) {
+        return compress(e, t);
+    }
+    function compress(e, t, i) {
+        let r;
+        const n = {};
+        for (let s = 0; s < e.length; s++) {
+            const o = e[s];
+            const a = propName(o);
+            let l = "";
+            if (i === undefined) l = a; else l = i + "." + a;
+            if (a === t.textNodeName) {
+                if (r === undefined) r = o[a]; else r += "" + o[a];
+            } else if (a === undefined) {
+                continue;
+            } else if (o[a]) {
+                let e = compress(o[a], t, l);
+                const i = isLeafTag(e, t);
+                if (o[":@"]) {
+                    assignAttributes(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 = "";
                 }
-                s[a].push(e);
-            } else {
-                if (t.isArray(a, l, i)) {
-                    s[a] = [ e ];
+                if (n[a] !== undefined && n.hasOwnProperty(a)) {
+                    if (!Array.isArray(n[a])) {
+                        n[a] = [ n[a] ];
+                    }
+                    n[a].push(e);
                 } else {
-                    s[a] = e;
+                    if (t.isArray(a, l, i)) {
+                        n[a] = [ e ];
+                    } else {
+                        n[a] = e;
+                    }
                 }
             }
         }
+        if (typeof r === "string") {
+            if (r.length > 0) n[t.textNodeName] = r;
+        } else if (r !== undefined) n[t.textNodeName] = r;
+        return n;
     }
-    if (typeof n === "string") {
-        if (n.length > 0) s[t.textNodeName] = n;
-    } else if (n !== undefined) s[t.textNodeName] = n;
-    return s;
-}
-
-function oe(e) {
-    const t = Object.keys(e);
-    for (let e = 0; e < t.length; e++) {
-        const i = t[e];
-        if (i !== ":@") return i;
-    }
-}
-
-function ae(e, t, i, n) {
-    if (t) {
-        const s = Object.keys(t);
-        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] ];
-            } else {
-                e[r] = t[r];
-            }
+    function propName(e) {
+        const t = Object.keys(e);
+        for (let e = 0; e < t.length; e++) {
+            const i = t[e];
+            if (i !== ":@") return i;
         }
     }
-}
-
-function le(e, t) {
-    const {textNodeName: i} = t;
-    const n = Object.keys(e).length;
-    if (n === 0) {
-        return true;
-    }
-    if (n === 1 && (e[i] || typeof e[i] === "boolean" || e[i] === 0)) {
-        return true;
-    }
-    return false;
-}
-
-class XMLParser {
-    constructor(e) {
-        this.externalEntities = {};
-        this.options = A(e);
-    }
-    parse(e, t) {
-        if (typeof e !== "string" && e.toString) {
-            e = e.toString();
-        } else if (typeof e !== "string") {
-            throw new Error("XML data is accepted in String or Bytes[] form.");
-        }
+    function assignAttributes(e, t, i, r) {
         if (t) {
-            if (t === true) t = {};
-            const i = d(e, t);
-            if (i !== true) {
-                throw Error(`${i.err.msg}:${i.err.line}:${i.err.col}`);
+            const n = Object.keys(t);
+            const s = n.length;
+            for (let o = 0; o < s; o++) {
+                const s = n[o];
+                if (r.isArray(s, i + "." + s, true, true)) {
+                    e[s] = [ t[s] ];
+                } else {
+                    e[s] = t[s];
+                }
             }
         }
-        const i = new OrderedObjParser(this.options);
-        i.addExternalEntities(this.externalEntities);
-        const n = i.parseXml(e);
-        if (this.options.preserveOrder || n === undefined) return n; else return se(n, this.options);
     }
-    addEntity(e, t) {
-        if (t.indexOf("&") !== -1) {
-            throw new Error("Entity value can't have '&'");
-        } else if (e.indexOf("&") !== -1 || e.indexOf(";") !== -1) {
-            throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
-        } else if (t === "&") {
-            throw new Error("An entity with value '&' is not permitted");
-        } else {
-            this.externalEntities[e] = t;
+    function isLeafTag(e, t) {
+        const {textNodeName: i} = t;
+        const r = Object.keys(e).length;
+        if (r === 0) {
+            return true;
         }
+        if (r === 1 && (e[i] || typeof e[i] === "boolean" || e[i] === 0)) {
+            return true;
+        }
+        return false;
     }
-    static getMetaDataSymbol() {
-        return XmlNode.getMetaDataSymbol();
-    }
-}
-
-const ue = "\n";
-
-function fe(e, t) {
-    let i = "";
-    if (t.format && t.indentBy.length > 0) {
-        i = ue;
-    }
-    return de(e, t, "", i);
+    b.prettify = prettify;
+    return b;
 }
 
-function de(e, t, i, n) {
-    let s = "";
-    let r = false;
-    for (let o = 0; o < e.length; o++) {
-        const a = e[o];
-        const l = he(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 (!pe(u, t)) {
-                e = t.tagValueProcessor(l, e);
-                e = ge(e, t);
-            }
-            if (r) {
-                s += n;
+var N;
+
+var E;
+
+function requireXMLParser() {
+    if (E) return N;
+    E = 1;
+    const {buildOptions: e} = requireOptionsBuilder();
+    const t = requireOrderedObjParser();
+    const {prettify: i} = requireNode2json();
+    const r = requireValidator();
+    class XMLParser {
+        constructor(t) {
+            this.externalEntities = {};
+            this.options = e(t);
+        }
+        parse(e, n) {
+            if (typeof e === "string") {} else if (e.toString) {
+                e = e.toString();
+            } else {
+                throw new Error("XML data is accepted in String or Bytes[] form.");
             }
-            s += e;
-            r = false;
-            continue;
-        } else if (l === t.cdataPropName) {
-            if (r) {
-                s += n;
+            if (n) {
+                if (n === true) n = {};
+                const t = r.validate(e, n);
+                if (t !== true) {
+                    throw Error(`${t.err.msg}:${t.err.line}:${t.err.col}`);
+                }
             }
-            s += `<![CDATA[${a[l][0][t.textNodeName]}]]>`;
-            r = false;
-            continue;
-        } else if (l === t.commentPropName) {
-            s += n + `\x3c!--${a[l][0][t.textNodeName]}--\x3e`;
-            r = true;
-            continue;
-        } else if (l[0] === "?") {
-            const e = ce(a[":@"], t);
-            const i = l === "?xml" ? "" : n;
-            let o = a[l][0][t.textNodeName];
-            o = o.length !== 0 ? " " + o : "";
-            s += i + `<${l}${o}${e}?>`;
-            r = true;
-            continue;
-        }
-        let f = n;
-        if (f !== "") {
-            f += t.indentBy;
-        }
-        const d = ce(a[":@"], t);
-        const h = n + `<${l}${d}`;
-        const c = de(a[l], t, u, f);
-        if (t.unpairedTags.indexOf(l) !== -1) {
-            if (t.suppressUnpairedNode) s += h + ">"; else s += h + "/>";
-        } else if ((!c || c.length === 0) && t.suppressEmptyNode) {
-            s += h + "/>";
-        } else if (c && c.endsWith(">")) {
-            s += h + `>${c}${n}</${l}>`;
-        } else {
-            s += h + ">";
-            if (c && n !== "" && (c.includes("/>") || c.includes("</"))) {
-                s += n + t.indentBy + c + n;
+            const s = new t(this.options);
+            s.addExternalEntities(this.externalEntities);
+            const o = s.parseXml(e);
+            if (this.options.preserveOrder || o === undefined) return o; else return i(o, this.options);
+        }
+        addEntity(e, t) {
+            if (t.indexOf("&") !== -1) {
+                throw new Error("Entity value can't have '&'");
+            } else if (e.indexOf("&") !== -1 || e.indexOf(";") !== -1) {
+                throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
+            } else if (t === "&") {
+                throw new Error("An entity with value '&' is not permitted");
             } else {
-                s += c;
+                this.externalEntities[e] = t;
             }
-            s += `</${l}>`;
         }
-        r = true;
     }
-    return s;
+    N = XMLParser;
+    return N;
 }
 
-function he(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;
-    }
-}
+var v;
+
+var O;
 
-function ce(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 = ge(s, t);
-            if (s === true && t.suppressBooleanAttributes) {
-                i += ` ${n.substr(t.attributeNamePrefix.length)}`;
+function requireOrderedJs2Xml() {
+    if (O) return v;
+    O = 1;
+    const e = "\n";
+    function toXml(t, i) {
+        let r = "";
+        if (i.format && i.indentBy.length > 0) {
+            r = e;
+        }
+        return arrToStr(t, i, "", r);
+    }
+    function arrToStr(e, t, i, r) {
+        let n = "";
+        let s = false;
+        for (let o = 0; o < e.length; o++) {
+            const a = e[o];
+            const l = propName(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 (!isStopNode(u, t)) {
+                    e = t.tagValueProcessor(l, e);
+                    e = replaceEntitiesValue(e, t);
+                }
+                if (s) {
+                    n += r;
+                }
+                n += e;
+                s = false;
+                continue;
+            } else if (l === t.cdataPropName) {
+                if (s) {
+                    n += r;
+                }
+                n += `<![CDATA[${a[l][0][t.textNodeName]}]]>`;
+                s = false;
+                continue;
+            } else if (l === t.commentPropName) {
+                n += r + `\x3c!--${a[l][0][t.textNodeName]}--\x3e`;
+                s = true;
+                continue;
+            } else if (l[0] === "?") {
+                const e = attr_to_str(a[":@"], t);
+                const i = l === "?xml" ? "" : r;
+                let o = a[l][0][t.textNodeName];
+                o = o.length !== 0 ? " " + o : "";
+                n += i + `<${l}${o}${e}?>`;
+                s = true;
+                continue;
+            }
+            let f = r;
+            if (f !== "") {
+                f += t.indentBy;
+            }
+            const d = attr_to_str(a[":@"], t);
+            const c = r + `<${l}${d}`;
+            const g = arrToStr(a[l], t, u, f);
+            if (t.unpairedTags.indexOf(l) !== -1) {
+                if (t.suppressUnpairedNode) n += c + ">"; else n += c + "/>";
+            } else if ((!g || g.length === 0) && t.suppressEmptyNode) {
+                n += c + "/>";
+            } else if (g && g.endsWith(">")) {
+                n += c + `>${g}${r}</${l}>`;
             } else {
-                i += ` ${n.substr(t.attributeNamePrefix.length)}="${s}"`;
+                n += c + ">";
+                if (g && r !== "" && (g.includes("/>") || g.includes("</"))) {
+                    n += r + t.indentBy + g + r;
+                } else {
+                    n += g;
+                }
+                n += `</${l}>`;
             }
+            s = true;
         }
+        return n;
     }
-    return i;
-}
-
-function pe(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 propName(e) {
+        const t = Object.keys(e);
+        for (let i = 0; i < t.length; i++) {
+            const r = t[i];
+            if (!e.hasOwnProperty(r)) continue;
+            if (r !== ":@") return r;
+        }
     }
-    return false;
-}
-
-function ge(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 attr_to_str(e, t) {
+        let i = "";
+        if (e && !t.ignoreAttributes) {
+            for (let r in e) {
+                if (!e.hasOwnProperty(r)) continue;
+                let n = t.attributeValueProcessor(r, e[r]);
+                n = replaceEntitiesValue(n, t);
+                if (n === true && t.suppressBooleanAttributes) {
+                    i += ` ${r.substr(t.attributeNamePrefix.length)}`;
+                } else {
+                    i += ` ${r.substr(t.attributeNamePrefix.length)}="${n}"`;
+                }
+            }
         }
+        return i;
     }
-    return e;
-}
-
-"use strict";
-
-const me = {
-    attributeNamePrefix: "@_",
-    attributesGroupName: false,
-    textNodeName: "#text",
-    ignoreAttributes: true,
-    cdataPropName: false,
-    format: false,
-    indentBy: "  ",
-    suppressEmptyNode: false,
-    suppressUnpairedNode: true,
-    suppressBooleanAttributes: true,
-    tagValueProcessor: function(e, t) {
-        return t;
-    },
-    attributeValueProcessor: function(e, t) {
-        return t;
-    },
-    preserveOrder: false,
-    commentPropName: false,
-    unpairedTags: [],
-    entities: [ {
-        regex: new RegExp("&", "g"),
-        val: "&amp;"
-    }, {
-        regex: new RegExp(">", "g"),
-        val: "&gt;"
-    }, {
-        regex: new RegExp("<", "g"),
-        val: "&lt;"
-    }, {
-        regex: new RegExp("'", "g"),
-        val: "&apos;"
-    }, {
-        regex: new RegExp('"', "g"),
-        val: "&quot;"
-    } ],
-    processEntities: true,
-    stopNodes: [],
-    oneListGroup: false
-};
-
-function xe(e) {
-    this.options = Object.assign({}, me, e);
-    if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {
-        this.isAttribute = function() {
-            return false;
-        };
-    } else {
-        this.ignoreAttributesFn = R(this.options.ignoreAttributes);
-        this.attrPrefixLen = this.options.attributeNamePrefix.length;
-        this.isAttribute = we;
+    function isStopNode(e, t) {
+        e = e.substr(0, e.length - t.textNodeName.length - 1);
+        let i = e.substr(e.lastIndexOf(".") + 1);
+        for (let r in t.stopNodes) {
+            if (t.stopNodes[r] === e || t.stopNodes[r] === "*." + i) return true;
+        }
+        return false;
     }
-    this.processTextOrObjNode = Ne;
-    if (this.options.format) {
-        this.indentate = Ee;
-        this.tagEndChar = ">\n";
-        this.newLine = "\n";
-    } else {
-        this.indentate = function() {
-            return "";
-        };
-        this.tagEndChar = ">";
-        this.newLine = "";
+    function replaceEntitiesValue(e, t) {
+        if (e && e.length > 0 && t.processEntities) {
+            for (let i = 0; i < t.entities.length; i++) {
+                const r = t.entities[i];
+                e = e.replace(r.regex, r.val);
+            }
+        }
+        return e;
     }
+    v = toXml;
+    return v;
 }
 
-xe.prototype.build = function(e) {
-    if (this.options.preserveOrder) {
-        return fe(e, this.options);
-    } else {
-        if (Array.isArray(e) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {
-            e = {
-                [this.options.arrayNodeName]: e
+var T;
+
+var P;
+
+function requireJson2xml() {
+    if (P) return T;
+    P = 1;
+    "use strict";
+    const e = requireOrderedJs2Xml();
+    const t = requireIgnoreAttributes();
+    const i = {
+        attributeNamePrefix: "@_",
+        attributesGroupName: false,
+        textNodeName: "#text",
+        ignoreAttributes: true,
+        cdataPropName: false,
+        format: false,
+        indentBy: "  ",
+        suppressEmptyNode: false,
+        suppressUnpairedNode: true,
+        suppressBooleanAttributes: true,
+        tagValueProcessor: function(e, t) {
+            return t;
+        },
+        attributeValueProcessor: function(e, t) {
+            return t;
+        },
+        preserveOrder: false,
+        commentPropName: false,
+        unpairedTags: [],
+        entities: [ {
+            regex: new RegExp("&", "g"),
+            val: "&amp;"
+        }, {
+            regex: new RegExp(">", "g"),
+            val: "&gt;"
+        }, {
+            regex: new RegExp("<", "g"),
+            val: "&lt;"
+        }, {
+            regex: new RegExp("'", "g"),
+            val: "&apos;"
+        }, {
+            regex: new RegExp('"', "g"),
+            val: "&quot;"
+        } ],
+        processEntities: true,
+        stopNodes: [],
+        oneListGroup: false
+    };
+    function Builder(e) {
+        this.options = Object.assign({}, i, e);
+        if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {
+            this.isAttribute = function() {
+                return false;
             };
+        } else {
+            this.ignoreAttributesFn = t(this.options.ignoreAttributes);
+            this.attrPrefixLen = this.options.attributeNamePrefix.length;
+            this.isAttribute = isAttribute;
+        }
+        this.processTextOrObjNode = processTextOrObjNode;
+        if (this.options.format) {
+            this.indentate = indentate;
+            this.tagEndChar = ">\n";
+            this.newLine = "\n";
+        } else {
+            this.indentate = function() {
+                return "";
+            };
+            this.tagEndChar = ">";
+            this.newLine = "";
         }
-        return this.j2x(e, 0, []).val;
     }
-};
-
-xe.prototype.j2x = function(e, t, i) {
-    let n = "";
-    let s = "";
-    const r = i.join(".");
-    for (let o in e) {
-        if (!Object.prototype.hasOwnProperty.call(e, o)) continue;
-        if (typeof e[o] === "undefined") {
-            if (this.isAttribute(o)) {
-                s += "";
-            }
-        } else if (e[o] === null) {
-            if (this.isAttribute(o)) {
-                s += "";
-            } else if (o === this.options.cdataPropName) {
-                s += "";
-            } else if (o[0] === "?") {
-                s += this.indentate(t) + "<" + o + "?" + this.tagEndChar;
-            } else {
-                s += this.indentate(t) + "<" + o + "/" + this.tagEndChar;
+    Builder.prototype.build = function(t) {
+        if (this.options.preserveOrder) {
+            return e(t, this.options);
+        } else {
+            if (Array.isArray(t) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {
+                t = {
+                    [this.options.arrayNodeName]: t
+                };
             }
-        } else if (e[o] instanceof Date) {
-            s += this.buildTextValNode(e[o], o, "", t);
-        } else if (typeof e[o] !== "object") {
-            const i = this.isAttribute(o);
-            if (i && !this.ignoreAttributesFn(i, r)) {
-                n += this.buildAttrPairStr(i, "" + e[o]);
-            } else if (!i) {
-                if (o === this.options.textNodeName) {
-                    let t = this.options.tagValueProcessor(o, "" + e[o]);
-                    s += this.replaceEntitiesValue(t);
+            return this.j2x(t, 0, []).val;
+        }
+    };
+    Builder.prototype.j2x = function(e, t, i) {
+        let r = "";
+        let n = "";
+        const s = i.join(".");
+        for (let o in e) {
+            if (!Object.prototype.hasOwnProperty.call(e, o)) continue;
+            if (typeof e[o] === "undefined") {
+                if (this.isAttribute(o)) {
+                    n += "";
+                }
+            } else if (e[o] === null) {
+                if (this.isAttribute(o)) {
+                    n += "";
+                } else if (o === this.options.cdataPropName) {
+                    n += "";
+                } else if (o[0] === "?") {
+                    n += this.indentate(t) + "<" + o + "?" + this.tagEndChar;
                 } else {
-                    s += this.buildTextValNode(e[o], o, "", t);
+                    n += this.indentate(t) + "<" + o + "/" + this.tagEndChar;
                 }
-            }
-        } else if (Array.isArray(e[o])) {
-            const n = e[o].length;
-            let r = "";
-            let a = "";
-            for (let l = 0; l < n; l++) {
-                const n = e[o][l];
-                if (typeof n === "undefined") {} else if (n === null) {
-                    if (o[0] === "?") s += this.indentate(t) + "<" + o + "?" + this.tagEndChar; else s += this.indentate(t) + "<" + o + "/" + this.tagEndChar;
-                } else if (typeof n === "object") {
-                    if (this.options.oneListGroup) {
-                        const e = this.j2x(n, t + 1, i.concat(o));
-                        r += e.val;
-                        if (this.options.attributesGroupName && n.hasOwnProperty(this.options.attributesGroupName)) {
-                            a += e.attrStr;
-                        }
+            } else if (e[o] instanceof Date) {
+                n += this.buildTextValNode(e[o], o, "", t);
+            } else if (typeof e[o] !== "object") {
+                const i = this.isAttribute(o);
+                if (i && !this.ignoreAttributesFn(i, s)) {
+                    r += this.buildAttrPairStr(i, "" + e[o]);
+                } else if (!i) {
+                    if (o === this.options.textNodeName) {
+                        let t = this.options.tagValueProcessor(o, "" + e[o]);
+                        n += this.replaceEntitiesValue(t);
                     } else {
-                        r += this.processTextOrObjNode(n, o, t, i);
+                        n += this.buildTextValNode(e[o], o, "", t);
                     }
-                } else {
-                    if (this.options.oneListGroup) {
-                        let e = this.options.tagValueProcessor(o, n);
-                        e = this.replaceEntitiesValue(e);
-                        r += e;
+                }
+            } else if (Array.isArray(e[o])) {
+                const r = e[o].length;
+                let s = "";
+                let a = "";
+                for (let l = 0; l < r; l++) {
+                    const r = e[o][l];
+                    if (typeof r === "undefined") {} else if (r === null) {
+                        if (o[0] === "?") n += this.indentate(t) + "<" + o + "?" + this.tagEndChar; else n += this.indentate(t) + "<" + o + "/" + this.tagEndChar;
+                    } else if (typeof r === "object") {
+                        if (this.options.oneListGroup) {
+                            const e = this.j2x(r, t + 1, i.concat(o));
+                            s += e.val;
+                            if (this.options.attributesGroupName && r.hasOwnProperty(this.options.attributesGroupName)) {
+                                a += e.attrStr;
+                            }
+                        } else {
+                            s += this.processTextOrObjNode(r, o, t, i);
+                        }
                     } else {
-                        r += this.buildTextValNode(n, o, "", t);
+                        if (this.options.oneListGroup) {
+                            let e = this.options.tagValueProcessor(o, r);
+                            e = this.replaceEntitiesValue(e);
+                            s += e;
+                        } else {
+                            s += this.buildTextValNode(r, o, "", t);
+                        }
                     }
                 }
-            }
-            if (this.options.oneListGroup) {
-                r = this.buildObjectNode(r, o, a, t);
-            }
-            s += r;
-        } else {
-            if (this.options.attributesGroupName && o === this.options.attributesGroupName) {
-                const t = Object.keys(e[o]);
-                const i = t.length;
-                for (let s = 0; s < i; s++) {
-                    n += this.buildAttrPairStr(t[s], "" + e[o][t[s]]);
+                if (this.options.oneListGroup) {
+                    s = this.buildObjectNode(s, o, a, t);
                 }
+                n += s;
             } else {
-                s += this.processTextOrObjNode(e[o], o, t, i);
+                if (this.options.attributesGroupName && o === this.options.attributesGroupName) {
+                    const t = Object.keys(e[o]);
+                    const i = t.length;
+                    for (let n = 0; n < i; n++) {
+                        r += this.buildAttrPairStr(t[n], "" + e[o][t[n]]);
+                    }
+                } else {
+                    n += this.processTextOrObjNode(e[o], o, t, i);
+                }
             }
         }
-    }
-    return {
-        attrStr: n,
-        val: s
+        return {
+            attrStr: r,
+            val: n
+        };
     };
-};
-
-xe.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 + '"';
-};
-
-function Ne(e, t, i, n) {
-    const s = this.j2x(e, i + 1, n.concat(t));
-    if (e[this.options.textNodeName] !== undefined && Object.keys(e).length === 1) {
-        return this.buildTextValNode(e[this.options.textNodeName], t, s.attrStr, i);
-    } else {
-        return this.buildObjectNode(s.val, t, s.attrStr, i);
+    Builder.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 + '"';
+    };
+    function processTextOrObjNode(e, t, i, r) {
+        const n = this.j2x(e, i + 1, r.concat(t));
+        if (e[this.options.textNodeName] !== undefined && Object.keys(e).length === 1) {
+            return this.buildTextValNode(e[this.options.textNodeName], t, n.attrStr, i);
+        } else {
+            return this.buildObjectNode(n.val, t, n.attrStr, i);
+        }
     }
-}
-
-xe.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;
+    Builder.prototype.buildObjectNode = function(e, t, i, r) {
+        if (e === "") {
+            if (t[0] === "?") return this.indentate(r) + "<" + t + i + "?" + this.tagEndChar; else {
+                return this.indentate(r) + "<" + t + i + this.closeTag(t) + this.tagEndChar;
+            }
+        } else {
+            let n = "</" + t + this.tagEndChar;
+            let s = "";
+            if (t[0] === "?") {
+                s = "?";
+                n = "";
+            }
+            if ((i || i === "") && e.indexOf("<") === -1) {
+                return this.indentate(r) + "<" + t + i + s + ">" + e + n;
+            } else if (this.options.commentPropName !== false && t === this.options.commentPropName && s.length === 0) {
+                return this.indentate(r) + `\x3c!--${e}--\x3e` + this.newLine;
+            } else {
+                return this.indentate(r) + "<" + t + i + s + this.tagEndChar + e + this.indentate(r) + n;
+            }
         }
-    } else {
-        let s = "</" + t + this.tagEndChar;
-        let r = "";
-        if (t[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;
+    };
+    Builder.prototype.closeTag = function(e) {
+        let t = "";
+        if (this.options.unpairedTags.indexOf(e) !== -1) {
+            if (!this.options.suppressUnpairedNode) t = "/";
+        } else if (this.options.suppressEmptyNode) {
+            t = "/";
         } else {
-            return this.indentate(n) + "<" + t + i + r + this.tagEndChar + e + this.indentate(n) + s;
+            t = `></${e}`;
         }
-    }
-};
-
-xe.prototype.closeTag = function(e) {
-    let t = "";
-    if (this.options.unpairedTags.indexOf(e) !== -1) {
-        if (!this.options.suppressUnpairedNode) t = "/";
-    } else if (this.options.suppressEmptyNode) {
-        t = "/";
-    } else {
-        t = `></${e}`;
-    }
-    return t;
-};
-
-function be(e, t, i, n) {
-    if (e !== "") {
-        return this.buildObjectNode(e, t, i, n);
-    } else {
-        if (t[0] === "?") return this.indentate(n) + "<" + t + i + "?" + this.tagEndChar; else {
-            return this.indentate(n) + "<" + t + i + "/" + this.tagEndChar;
+        return t;
+    };
+    function buildEmptyObjNode(e, t, i, r) {
+        if (e !== "") {
+            return this.buildObjectNode(e, t, i, r);
+        } else {
+            if (t[0] === "?") return this.indentate(r) + "<" + t + i + "?" + this.tagEndChar; else {
+                return this.indentate(r) + "<" + t + i + "/" + this.tagEndChar;
+            }
         }
     }
-}
-
-xe.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;
-    } else {
-        let s = this.options.tagValueProcessor(t, e);
-        s = this.replaceEntitiesValue(s);
-        if (s === "") {
-            return this.indentate(n) + "<" + t + i + this.closeTag(t) + this.tagEndChar;
+    Builder.prototype.buildTextValNode = function(e, t, i, r) {
+        if (this.options.cdataPropName !== false && t === this.options.cdataPropName) {
+            return this.indentate(r) + `<![CDATA[${e}]]>` + this.newLine;
+        } else if (this.options.commentPropName !== false && t === this.options.commentPropName) {
+            return this.indentate(r) + `\x3c!--${e}--\x3e` + this.newLine;
+        } else if (t[0] === "?") {
+            return this.indentate(r) + "<" + t + i + "?" + this.tagEndChar;
         } else {
-            return this.indentate(n) + "<" + t + i + ">" + s + "</" + t + this.tagEndChar;
+            let n = this.options.tagValueProcessor(t, e);
+            n = this.replaceEntitiesValue(n);
+            if (n === "") {
+                return this.indentate(r) + "<" + t + i + this.closeTag(t) + this.tagEndChar;
+            } else {
+                return this.indentate(r) + "<" + t + i + ">" + n + "</" + t + this.tagEndChar;
+            }
+        }
+    };
+    Builder.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);
+            }
         }
+        return e;
+    };
+    function indentate(e) {
+        return this.options.indentBy.repeat(e);
     }
-};
-
-xe.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);
+    function isAttribute(e) {
+        if (e.startsWith(this.options.attributeNamePrefix) && e !== this.options.textNodeName) {
+            return e.substr(this.attrPrefixLen);
+        } else {
+            return false;
         }
     }
-    return e;
-};
-
-function Ee(e) {
-    return this.options.indentBy.repeat(e);
+    T = Builder;
+    return T;
 }
 
-function we(e) {
-    if (e.startsWith(this.options.attributeNamePrefix) && e !== this.options.textNodeName) {
-        return e.substr(this.attrPrefixLen);
-    } else {
-        return false;
-    }
+var A;
+
+var y;
+
+function requireFxp() {
+    if (y) return A;
+    y = 1;
+    "use strict";
+    const e = requireValidator();
+    const t = requireXMLParser();
+    const i = requireJson2xml();
+    A = {
+        XMLParser: t,
+        XMLValidator: e,
+        XMLBuilder: i
+    };
+    return A;
 }
 
-"use strict";
+var I = requireFxp();
 
-const Te = {
-    validate: d
-};
+const w = e(I);
 
-function ye(e) {
+function IsXML(e) {
     try {
-        Te.validate(e, {
+        I.XMLValidator.validate(e, {
             allowBooleanAttributes: true
         });
         return true;
@@ -1905,4 +1757,4 @@ function ye(e) {
     }
 }
 
-export { ye as IsXML };
+export { IsXML };