@dan-uni/dan-any 1.4.4 → 1.4.6

package/dist/umd/plugins/index.umd.min.js

@@ -13992,6 +13992,7 @@
                     unpairedTags: [],
                     processEntities: true,
                     htmlEntities: false,
+                    entityDecoder: null,
                     ignoreDeclaration: false,
                     ignorePiTags: false,
                     transformTagName: false,
@@ -14011,16 +14012,17 @@
                     if (DANGEROUS_PROPERTY_NAMES.some((dangerous)=>normalized === dangerous.toLowerCase())) throw new Error(`[SECURITY] Invalid ${optionName}: "${propertyName}" is a reserved JavaScript keyword that could cause prototype pollution`);
                     if (criticalProperties.some((dangerous)=>normalized === dangerous.toLowerCase())) throw new Error(`[SECURITY] Invalid ${optionName}: "${propertyName}" is a reserved JavaScript keyword that could cause prototype pollution`);
                 }
-                function normalizeProcessEntities(value) {
+                function normalizeProcessEntities(value, htmlEntities) {
                     if ('boolean' == typeof value) return {
                         enabled: value,
                         maxEntitySize: 10000,
-                        maxExpansionDepth: 10,
-                        maxTotalExpansions: 1000,
+                        maxExpansionDepth: 10000,
+                        maxTotalExpansions: 1 / 0,
                         maxExpandedLength: 100000,
-                        maxEntityCount: 100,
+                        maxEntityCount: 1000,
                         allowedTags: null,
-                        tagFilter: null
+                        tagFilter: null,
+                        appliesTo: "all"
                     };
                     if ('object' == typeof value && null !== value) return {
                         enabled: false !== value.enabled,
@@ -14030,7 +14032,8 @@
                         maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 100000),
                         maxEntityCount: Math.max(1, value.maxEntityCount ?? 1000),
                         allowedTags: value.allowedTags ?? null,
-                        tagFilter: value.tagFilter ?? null
+                        tagFilter: value.tagFilter ?? null,
+                        appliesTo: value.appliesTo ?? "all"
                     };
                     return normalizeProcessEntities(true);
                 }
@@ -14060,7 +14063,7 @@
                     ];
                     for (const { value, name } of propertyNameOptions)if (value) validatePropertyName(value, name);
                     if (null === built.onDangerousProperty) built.onDangerousProperty = defaultOnDangerousProperty;
-                    built.processEntities = normalizeProcessEntities(built.processEntities);
+                    built.processEntities = normalizeProcessEntities(built.processEntities, built.htmlEntities);
                     built.unpairedTagsSet = new Set(built.unpairedTags);
                     if (built.stopNodes && Array.isArray(built.stopNodes)) built.stopNodes = built.stopNodes.map((node)=>{
                         if ('string' == typeof node && node.startsWith('*.')) return '..' + node.substring(2);
@@ -14128,11 +14131,7 @@
                                     [entityName, val, i] = this.readEntityExp(xmlData, i + 1, this.suppressValidationErr);
                                     if (-1 === val.indexOf("&")) {
                                         if (false !== this.options.enabled && null != this.options.maxEntityCount && entityCount >= this.options.maxEntityCount) throw new Error(`Entity count (${entityCount + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`);
-                                        const escaped = entityName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                                        entities[entityName] = {
-                                            regx: RegExp(`&${escaped};`, "g"),
-                                            val: val
-                                        };
+                                        entities[entityName] = val;
                                         entityCount++;
                                     }
                                 } else if (hasBody && hasSeq(xmlData, "!ELEMENT", i)) {
@@ -14821,6 +14820,1333 @@
                         return null;
                     }
                 }
+                const BASIC_LATIN = {
+                    amp: '&',
+                    AMP: '&',
+                    lt: '<',
+                    LT: '<',
+                    gt: '>',
+                    GT: '>',
+                    quot: '"',
+                    QUOT: '"',
+                    apos: "'",
+                    lsquo: '‘',
+                    rsquo: '’',
+                    ldquo: '“',
+                    rdquo: '”',
+                    lsquor: '‚',
+                    rsquor: '’',
+                    ldquor: '„',
+                    bdquo: '„',
+                    comma: ',',
+                    period: '.',
+                    colon: ':',
+                    semi: ';',
+                    excl: '!',
+                    quest: '?',
+                    num: '#',
+                    dollar: '$',
+                    percent: '%',
+                    amp: '&',
+                    ast: '*',
+                    commat: '@',
+                    lowbar: '_',
+                    verbar: '|',
+                    vert: '|',
+                    sol: '/',
+                    bsol: '\\',
+                    lbrace: '{',
+                    rbrace: '}',
+                    lbrack: '[',
+                    rbrack: ']',
+                    lpar: '(',
+                    rpar: ')',
+                    nbsp: '\u00a0',
+                    iexcl: '¡',
+                    cent: '¢',
+                    pound: '£',
+                    curren: '¤',
+                    yen: '¥',
+                    brvbar: '¦',
+                    sect: '§',
+                    uml: '¨',
+                    copy: '©',
+                    COPY: '©',
+                    ordf: 'ª',
+                    laquo: '«',
+                    not: '¬',
+                    shy: '\u00ad',
+                    reg: '®',
+                    REG: '®',
+                    macr: '¯',
+                    deg: '°',
+                    plusmn: '±',
+                    sup2: '²',
+                    sup3: '³',
+                    acute: '´',
+                    micro: 'µ',
+                    para: '¶',
+                    middot: '·',
+                    cedil: '¸',
+                    sup1: '¹',
+                    ordm: 'º',
+                    raquo: '»',
+                    frac14: '¼',
+                    frac12: '½',
+                    half: '½',
+                    frac34: '¾',
+                    iquest: '¿',
+                    times: '×',
+                    div: '÷',
+                    divide: '÷'
+                };
+                const LATIN_ACCENTS = {
+                    Agrave: 'À',
+                    agrave: 'à',
+                    Aacute: 'Á',
+                    aacute: 'á',
+                    Acirc: 'Â',
+                    acirc: 'â',
+                    Atilde: 'Ã',
+                    atilde: 'ã',
+                    Auml: 'Ä',
+                    auml: 'ä',
+                    Aring: 'Å',
+                    aring: 'å',
+                    AElig: 'Æ',
+                    aelig: 'æ',
+                    Ccedil: 'Ç',
+                    ccedil: 'ç',
+                    Egrave: 'È',
+                    egrave: 'è',
+                    Eacute: 'É',
+                    eacute: 'é',
+                    Ecirc: 'Ê',
+                    ecirc: 'ê',
+                    Euml: 'Ë',
+                    euml: 'ë',
+                    Igrave: 'Ì',
+                    igrave: 'ì',
+                    Iacute: 'Í',
+                    iacute: 'í',
+                    Icirc: 'Î',
+                    icirc: 'î',
+                    Iuml: 'Ï',
+                    iuml: 'ï',
+                    ETH: 'Ð',
+                    eth: 'ð',
+                    Ntilde: 'Ñ',
+                    ntilde: 'ñ',
+                    Ograve: 'Ò',
+                    ograve: 'ò',
+                    Oacute: 'Ó',
+                    oacute: 'ó',
+                    Ocirc: 'Ô',
+                    ocirc: 'ô',
+                    Otilde: 'Õ',
+                    otilde: 'õ',
+                    Ouml: 'Ö',
+                    ouml: 'ö',
+                    Oslash: 'Ø',
+                    oslash: 'ø',
+                    Ugrave: 'Ù',
+                    ugrave: 'ù',
+                    Uacute: 'Ú',
+                    uacute: 'ú',
+                    Ucirc: 'Û',
+                    ucirc: 'û',
+                    Uuml: 'Ü',
+                    uuml: 'ü',
+                    Yacute: 'Ý',
+                    yacute: 'ý',
+                    THORN: 'Þ',
+                    thorn: 'þ',
+                    szlig: 'ß',
+                    yuml: 'ÿ',
+                    Yuml: 'Ÿ'
+                };
+                const LATIN_EXTENDED = {
+                    Amacr: 'Ā',
+                    amacr: 'ā',
+                    Abreve: 'Ă',
+                    abreve: 'ă',
+                    Aogon: 'Ą',
+                    aogon: 'ą',
+                    Cacute: 'Ć',
+                    cacute: 'ć',
+                    Ccirc: 'Ĉ',
+                    ccirc: 'ĉ',
+                    Cdot: 'Ċ',
+                    cdot: 'ċ',
+                    Ccaron: 'Č',
+                    ccaron: 'č',
+                    Dcaron: 'Ď',
+                    dcaron: 'ď',
+                    Dstrok: 'Đ',
+                    dstrok: 'đ',
+                    Emacr: 'Ē',
+                    emacr: 'ē',
+                    Ecaron: 'Ě',
+                    ecaron: 'ě',
+                    Edot: 'Ė',
+                    edot: 'ė',
+                    Eogon: 'Ę',
+                    eogon: 'ę',
+                    Gcirc: 'Ĝ',
+                    gcirc: 'ĝ',
+                    Gbreve: 'Ğ',
+                    gbreve: 'ğ',
+                    Gdot: 'Ġ',
+                    gdot: 'ġ',
+                    Gcedil: 'Ģ',
+                    Hcirc: 'Ĥ',
+                    hcirc: 'ĥ',
+                    Hstrok: 'Ħ',
+                    hstrok: 'ħ',
+                    Itilde: 'Ĩ',
+                    itilde: 'ĩ',
+                    Imacr: 'Ī',
+                    imacr: 'ī',
+                    Iogon: 'Į',
+                    iogon: 'į',
+                    Idot: 'İ',
+                    IJlig: 'IJ',
+                    ijlig: 'ij',
+                    Jcirc: 'Ĵ',
+                    jcirc: 'ĵ',
+                    Kcedil: 'Ķ',
+                    kcedil: 'ķ',
+                    kgreen: 'ĸ',
+                    Lacute: 'Ĺ',
+                    lacute: 'ĺ',
+                    Lcedil: 'Ļ',
+                    lcedil: 'ļ',
+                    Lcaron: 'Ľ',
+                    lcaron: 'ľ',
+                    Lmidot: 'Ŀ',
+                    lmidot: 'ŀ',
+                    Lstrok: 'Ł',
+                    lstrok: 'ł',
+                    Nacute: 'Ń',
+                    nacute: 'ń',
+                    Ncaron: 'Ň',
+                    ncaron: 'ň',
+                    Ncedil: 'Ņ',
+                    ncedil: 'ņ',
+                    ENG: 'Ŋ',
+                    eng: 'ŋ',
+                    Omacr: 'Ō',
+                    omacr: 'ō',
+                    Odblac: 'Ő',
+                    odblac: 'ő',
+                    OElig: 'Œ',
+                    oelig: 'œ',
+                    Racute: 'Ŕ',
+                    racute: 'ŕ',
+                    Rcaron: 'Ř',
+                    rcaron: 'ř',
+                    Rcedil: 'Ŗ',
+                    rcedil: 'ŗ',
+                    Sacute: 'Ś',
+                    sacute: 'ś',
+                    Scirc: 'Ŝ',
+                    scirc: 'ŝ',
+                    Scedil: 'Ş',
+                    scedil: 'ş',
+                    Scaron: 'Š',
+                    scaron: 'š',
+                    Tcedil: 'Ţ',
+                    tcedil: 'ţ',
+                    Tcaron: 'Ť',
+                    tcaron: 'ť',
+                    Tstrok: 'Ŧ',
+                    tstrok: 'ŧ',
+                    Utilde: 'Ũ',
+                    utilde: 'ũ',
+                    Umacr: 'Ū',
+                    umacr: 'ū',
+                    Ubreve: 'Ŭ',
+                    ubreve: 'ŭ',
+                    Uring: 'Ů',
+                    uring: 'ů',
+                    Udblac: 'Ű',
+                    udblac: 'ű',
+                    Uogon: 'Ų',
+                    uogon: 'ų',
+                    Wcirc: 'Ŵ',
+                    wcirc: 'ŵ',
+                    Ycirc: 'Ŷ',
+                    ycirc: 'ŷ',
+                    Zacute: 'Ź',
+                    zacute: 'ź',
+                    Zdot: 'Ż',
+                    zdot: 'ż',
+                    Zcaron: 'Ž',
+                    zcaron: 'ž'
+                };
+                const GREEK = {
+                    Alpha: 'Α',
+                    alpha: 'α',
+                    Beta: 'Β',
+                    beta: 'β',
+                    Gamma: 'Γ',
+                    gamma: 'γ',
+                    Delta: 'Δ',
+                    delta: 'δ',
+                    Epsilon: 'Ε',
+                    epsilon: 'ε',
+                    epsiv: 'ϵ',
+                    varepsilon: 'ϵ',
+                    Zeta: 'Ζ',
+                    zeta: 'ζ',
+                    Eta: 'Η',
+                    eta: 'η',
+                    Theta: 'Θ',
+                    theta: 'θ',
+                    thetasym: 'ϑ',
+                    vartheta: 'ϑ',
+                    Iota: 'Ι',
+                    iota: 'ι',
+                    Kappa: 'Κ',
+                    kappa: 'κ',
+                    kappav: 'ϰ',
+                    varkappa: 'ϰ',
+                    Lambda: 'Λ',
+                    lambda: 'λ',
+                    Mu: 'Μ',
+                    mu: 'μ',
+                    Nu: 'Ν',
+                    nu: 'ν',
+                    Xi: 'Ξ',
+                    xi: 'ξ',
+                    Omicron: 'Ο',
+                    omicron: 'ο',
+                    Pi: 'Π',
+                    pi: 'π',
+                    piv: 'ϖ',
+                    varpi: 'ϖ',
+                    Rho: 'Ρ',
+                    rho: 'ρ',
+                    rhov: 'ϱ',
+                    varrho: 'ϱ',
+                    Sigma: 'Σ',
+                    sigma: 'σ',
+                    sigmaf: 'ς',
+                    sigmav: 'ς',
+                    varsigma: 'ς',
+                    Tau: 'Τ',
+                    tau: 'τ',
+                    Upsilon: 'Υ',
+                    upsilon: 'υ',
+                    upsi: 'υ',
+                    Upsi: 'ϒ',
+                    upsih: 'ϒ',
+                    Phi: 'Φ',
+                    phi: 'φ',
+                    phiv: 'ϕ',
+                    varphi: 'ϕ',
+                    Chi: 'Χ',
+                    chi: 'χ',
+                    Psi: 'Ψ',
+                    psi: 'ψ',
+                    Omega: 'Ω',
+                    omega: 'ω',
+                    ohm: 'Ω',
+                    Gammad: 'Ϝ',
+                    gammad: 'ϝ',
+                    digamma: 'ϝ'
+                };
+                const CYRILLIC = {
+                    Afr: '𝔄',
+                    afr: '𝔞',
+                    Acy: 'А',
+                    acy: 'а',
+                    Bcy: 'Б',
+                    bcy: 'б',
+                    Vcy: 'В',
+                    vcy: 'в',
+                    Gcy: 'Г',
+                    gcy: 'г',
+                    Dcy: 'Д',
+                    dcy: 'д',
+                    IEcy: 'Е',
+                    iecy: 'е',
+                    IOcy: 'Ё',
+                    iocy: 'ё',
+                    ZHcy: 'Ж',
+                    zhcy: 'ж',
+                    Zcy: 'З',
+                    zcy: 'з',
+                    Icy: 'И',
+                    icy: 'и',
+                    Jcy: 'Й',
+                    jcy: 'й',
+                    Kcy: 'К',
+                    kcy: 'к',
+                    Lcy: 'Л',
+                    lcy: 'л',
+                    Mcy: 'М',
+                    mcy: 'м',
+                    Ncy: 'Н',
+                    ncy: 'н',
+                    Ocy: 'О',
+                    ocy: 'о',
+                    Pcy: 'П',
+                    pcy: 'п',
+                    Rcy: 'Р',
+                    rcy: 'р',
+                    Scy: 'С',
+                    scy: 'с',
+                    Tcy: 'Т',
+                    tcy: 'т',
+                    Ucy: 'У',
+                    ucy: 'у',
+                    Fcy: 'Ф',
+                    fcy: 'ф',
+                    KHcy: 'Х',
+                    khcy: 'х',
+                    TScy: 'Ц',
+                    tscy: 'ц',
+                    CHcy: 'Ч',
+                    chcy: 'ч',
+                    SHcy: 'Ш',
+                    shcy: 'ш',
+                    SHCHcy: 'Щ',
+                    shchcy: 'щ',
+                    HARDcy: 'Ъ',
+                    hardcy: 'ъ',
+                    Ycy: 'Ы',
+                    ycy: 'ы',
+                    SOFTcy: 'Ь',
+                    softcy: 'ь',
+                    Ecy: 'Э',
+                    ecy: 'э',
+                    YUcy: 'Ю',
+                    yucy: 'ю',
+                    YAcy: 'Я',
+                    yacy: 'я',
+                    DJcy: 'Ђ',
+                    djcy: 'ђ',
+                    GJcy: 'Ѓ',
+                    gjcy: 'ѓ',
+                    Jukcy: 'Є',
+                    jukcy: 'є',
+                    DScy: 'Ѕ',
+                    dscy: 'ѕ',
+                    Iukcy: 'І',
+                    iukcy: 'і',
+                    YIcy: 'Ї',
+                    yicy: 'ї',
+                    Jsercy: 'Ј',
+                    jsercy: 'ј',
+                    LJcy: 'Љ',
+                    ljcy: 'љ',
+                    NJcy: 'Њ',
+                    njcy: 'њ',
+                    TSHcy: 'Ћ',
+                    tshcy: 'ћ',
+                    KJcy: 'Ќ',
+                    kjcy: 'ќ',
+                    Ubrcy: 'Ў',
+                    ubrcy: 'ў',
+                    DZcy: 'Џ',
+                    dzcy: 'џ'
+                };
+                const MATH = {
+                    plus: '+',
+                    minus: '−',
+                    mnplus: '∓',
+                    mp: '∓',
+                    pm: '±',
+                    times: '×',
+                    div: '÷',
+                    divide: '÷',
+                    sdot: '⋅',
+                    star: '☆',
+                    starf: '★',
+                    bigstar: '★',
+                    lowast: '∗',
+                    ast: '*',
+                    midast: '*',
+                    compfn: '∘',
+                    smallcircle: '∘',
+                    bullet: '•',
+                    bull: '•',
+                    nbsp: '\u00a0',
+                    hellip: '…',
+                    mldr: '…',
+                    prime: '′',
+                    Prime: '″',
+                    tprime: '‴',
+                    bprime: '‵',
+                    backprime: '‵',
+                    minus: '−',
+                    minusd: '∸',
+                    dotminus: '∸',
+                    plusdo: '∔',
+                    dotplus: '∔',
+                    plusmn: '±',
+                    minusplus: '∓',
+                    mnplus: '∓',
+                    mp: '∓',
+                    setminus: '∖',
+                    smallsetminus: '∖',
+                    Backslash: '∖',
+                    setmn: '∖',
+                    ssetmn: '∖',
+                    lowbar: '_',
+                    verbar: '|',
+                    vert: '|',
+                    VerticalLine: '|',
+                    colon: ':',
+                    Colon: '∷',
+                    Proportion: '∷',
+                    ratio: '∶',
+                    equals: '=',
+                    ne: '≠',
+                    nequiv: '≢',
+                    equiv: '≡',
+                    Congruent: '≡',
+                    sim: '∼',
+                    thicksim: '∼',
+                    thksim: '∼',
+                    sime: '≃',
+                    simeq: '≃',
+                    TildeEqual: '≃',
+                    asymp: '≈',
+                    approx: '≈',
+                    thickapprox: '≈',
+                    thkap: '≈',
+                    TildeTilde: '≈',
+                    ncong: '≇',
+                    cong: '≅',
+                    TildeFullEqual: '≅',
+                    asympeq: '≍',
+                    CupCap: '≍',
+                    bump: '≎',
+                    Bumpeq: '≎',
+                    HumpDownHump: '≎',
+                    bumpe: '≏',
+                    bumpeq: '≏',
+                    HumpEqual: '≏',
+                    dotminus: '∸',
+                    minusd: '∸',
+                    plusdo: '∔',
+                    dotplus: '∔',
+                    le: '≤',
+                    LessEqual: '≤',
+                    ge: '≥',
+                    GreaterEqual: '≥',
+                    lesseqgtr: '⋚',
+                    lesseqqgtr: '⪋',
+                    greater: '>',
+                    less: '<'
+                };
+                const MATH_ADVANCED = {
+                    alefsym: 'ℵ',
+                    aleph: 'ℵ',
+                    beth: 'ℶ',
+                    gimel: 'ℷ',
+                    daleth: 'ℸ',
+                    forall: '∀',
+                    ForAll: '∀',
+                    part: '∂',
+                    PartialD: '∂',
+                    exist: '∃',
+                    Exists: '∃',
+                    nexist: '∄',
+                    nexists: '∄',
+                    empty: '∅',
+                    emptyset: '∅',
+                    emptyv: '∅',
+                    varnothing: '∅',
+                    nabla: '∇',
+                    Del: '∇',
+                    isin: '∈',
+                    isinv: '∈',
+                    in: '∈',
+                    Element: '∈',
+                    notin: '∉',
+                    notinva: '∉',
+                    ni: '∋',
+                    niv: '∋',
+                    SuchThat: '∋',
+                    ReverseElement: '∋',
+                    notni: '∌',
+                    notniva: '∌',
+                    prod: '∏',
+                    Product: '∏',
+                    coprod: '∐',
+                    Coproduct: '∐',
+                    sum: '∑',
+                    Sum: '∑',
+                    minus: '−',
+                    mp: '∓',
+                    plusdo: '∔',
+                    dotplus: '∔',
+                    setminus: '∖',
+                    lowast: '∗',
+                    radic: '√',
+                    Sqrt: '√',
+                    prop: '∝',
+                    propto: '∝',
+                    Proportional: '∝',
+                    varpropto: '∝',
+                    infin: '∞',
+                    infintie: '⧝',
+                    ang: '∠',
+                    angle: '∠',
+                    angmsd: '∡',
+                    measuredangle: '∡',
+                    angsph: '∢',
+                    mid: '∣',
+                    VerticalBar: '∣',
+                    nmid: '∤',
+                    nsmid: '∤',
+                    npar: '∦',
+                    parallel: '∥',
+                    spar: '∥',
+                    nparallel: '∦',
+                    nspar: '∦',
+                    and: '∧',
+                    wedge: '∧',
+                    or: '∨',
+                    vee: '∨',
+                    cap: '∩',
+                    cup: '∪',
+                    int: '∫',
+                    Integral: '∫',
+                    conint: '∮',
+                    ContourIntegral: '∮',
+                    Conint: '∯',
+                    DoubleContourIntegral: '∯',
+                    Cconint: '∰',
+                    there4: '∴',
+                    therefore: '∴',
+                    Therefore: '∴',
+                    becaus: '∵',
+                    because: '∵',
+                    Because: '∵',
+                    ratio: '∶',
+                    Proportion: '∷',
+                    minusd: '∸',
+                    dotminus: '∸',
+                    mDDot: '∺',
+                    homtht: '∻',
+                    sim: '∼',
+                    bsimg: '∽',
+                    backsim: '∽',
+                    ac: '∾',
+                    mstpos: '∾',
+                    acd: '∿',
+                    VerticalTilde: '≀',
+                    wr: '≀',
+                    wreath: '≀',
+                    nsime: '≄',
+                    nsimeq: '≄',
+                    nsimeq: '≄',
+                    ncong: '≇',
+                    simne: '≆',
+                    ncongdot: '⩭̸',
+                    ngsim: '≵',
+                    nsim: '≁',
+                    napprox: '≉',
+                    nap: '≉',
+                    ngeq: '≱',
+                    nge: '≱',
+                    nleq: '≰',
+                    nle: '≰',
+                    ngtr: '≯',
+                    ngt: '≯',
+                    nless: '≮',
+                    nlt: '≮',
+                    nprec: '⊀',
+                    npr: '⊀',
+                    nsucc: '⊁',
+                    nsc: '⊁'
+                };
+                const ARROWS = {
+                    larr: '←',
+                    leftarrow: '←',
+                    LeftArrow: '←',
+                    uarr: '↑',
+                    uparrow: '↑',
+                    UpArrow: '↑',
+                    rarr: '→',
+                    rightarrow: '→',
+                    RightArrow: '→',
+                    darr: '↓',
+                    downarrow: '↓',
+                    DownArrow: '↓',
+                    harr: '↔',
+                    leftrightarrow: '↔',
+                    LeftRightArrow: '↔',
+                    varr: '↕',
+                    updownarrow: '↕',
+                    UpDownArrow: '↕',
+                    nwarr: '↖',
+                    nwarrow: '↖',
+                    UpperLeftArrow: '↖',
+                    nearr: '↗',
+                    nearrow: '↗',
+                    UpperRightArrow: '↗',
+                    searr: '↘',
+                    searrow: '↘',
+                    LowerRightArrow: '↘',
+                    swarr: '↙',
+                    swarrow: '↙',
+                    LowerLeftArrow: '↙',
+                    lArr: '⇐',
+                    Leftarrow: '⇐',
+                    uArr: '⇑',
+                    Uparrow: '⇑',
+                    rArr: '⇒',
+                    Rightarrow: '⇒',
+                    dArr: '⇓',
+                    Downarrow: '⇓',
+                    hArr: '⇔',
+                    Leftrightarrow: '⇔',
+                    iff: '⇔',
+                    vArr: '⇕',
+                    Updownarrow: '⇕',
+                    lAarr: '⇚',
+                    Lleftarrow: '⇚',
+                    rAarr: '⇛',
+                    Rrightarrow: '⇛',
+                    lrarr: '⇆',
+                    leftrightarrows: '⇆',
+                    rlarr: '⇄',
+                    rightleftarrows: '⇄',
+                    lrhar: '⇋',
+                    leftrightharpoons: '⇋',
+                    ReverseEquilibrium: '⇋',
+                    rlhar: '⇌',
+                    rightleftharpoons: '⇌',
+                    Equilibrium: '⇌',
+                    udarr: '⇅',
+                    UpArrowDownArrow: '⇅',
+                    duarr: '⇵',
+                    DownArrowUpArrow: '⇵',
+                    llarr: '⇇',
+                    leftleftarrows: '⇇',
+                    rrarr: '⇉',
+                    rightrightarrows: '⇉',
+                    ddarr: '⇊',
+                    downdownarrows: '⇊',
+                    har: '↽',
+                    lhard: '↽',
+                    leftharpoondown: '↽',
+                    lharu: '↼',
+                    leftharpoonup: '↼',
+                    rhard: '⇁',
+                    rightharpoondown: '⇁',
+                    rharu: '⇀',
+                    rightharpoonup: '⇀',
+                    lsh: '↰',
+                    Lsh: '↰',
+                    rsh: '↱',
+                    Rsh: '↱',
+                    ldsh: '↲',
+                    rdsh: '↳',
+                    hookleftarrow: '↩',
+                    hookrightarrow: '↪',
+                    mapstoleft: '↤',
+                    mapstoup: '↥',
+                    map: '↦',
+                    mapsto: '↦',
+                    mapstodown: '↧',
+                    crarr: '↵',
+                    nwarrow: '↖',
+                    nearrow: '↗',
+                    searrow: '↘',
+                    swarrow: '↙',
+                    nleftarrow: '↚',
+                    nleftrightarrow: '↮',
+                    nrightarrow: '↛',
+                    nrarr: '↛',
+                    larrtl: '↢',
+                    rarrtl: '↣',
+                    leftarrowtail: '↢',
+                    rightarrowtail: '↣',
+                    twoheadleftarrow: '↞',
+                    twoheadrightarrow: '↠',
+                    Larr: '↞',
+                    Rarr: '↠',
+                    larrhk: '↩',
+                    rarrhk: '↪',
+                    larrlp: '↫',
+                    looparrowleft: '↫',
+                    rarrlp: '↬',
+                    looparrowright: '↬',
+                    harrw: '↭',
+                    leftrightsquigarrow: '↭',
+                    nrarrw: '↝̸',
+                    rarrw: '↝',
+                    rightsquigarrow: '↝',
+                    larrbfs: '⤟',
+                    rarrbfs: '⤠',
+                    nvHarr: '⤄',
+                    nvlArr: '⤂',
+                    nvrArr: '⤃',
+                    larrfs: '⤝',
+                    rarrfs: '⤞',
+                    Map: '⤅',
+                    larrsim: '⥳',
+                    rarrsim: '⥴',
+                    harrcir: '⥈',
+                    Uarrocir: '⥉',
+                    lurdshar: '⥊',
+                    ldrdhar: '⥧',
+                    ldrushar: '⥋',
+                    rdldhar: '⥩',
+                    lrhard: '⥭',
+                    rlhar: '⇌',
+                    uharr: '↾',
+                    uharl: '↿',
+                    dharr: '⇂',
+                    dharl: '⇃',
+                    Uarr: '↟',
+                    Darr: '↡',
+                    zigrarr: '⇝',
+                    nwArr: '⇖',
+                    neArr: '⇗',
+                    seArr: '⇘',
+                    swArr: '⇙',
+                    nharr: '↮',
+                    nhArr: '⇎',
+                    nlarr: '↚',
+                    nlArr: '⇍',
+                    nrarr: '↛',
+                    nrArr: '⇏',
+                    larrb: '⇤',
+                    LeftArrowBar: '⇤',
+                    rarrb: '⇥',
+                    RightArrowBar: '⇥'
+                };
+                const SHAPES = {
+                    square: '□',
+                    Square: '□',
+                    squ: '□',
+                    squf: '▪',
+                    squarf: '▪',
+                    blacksquar: '▪',
+                    blacksquare: '▪',
+                    FilledVerySmallSquare: '▪',
+                    blk34: '▓',
+                    blk12: '▒',
+                    blk14: '░',
+                    block: '█',
+                    srect: '▭',
+                    rect: '▭',
+                    sdot: '⋅',
+                    sdotb: '⊡',
+                    dotsquare: '⊡',
+                    triangle: '▵',
+                    tri: '▵',
+                    trine: '▵',
+                    utri: '▵',
+                    triangledown: '▿',
+                    dtri: '▿',
+                    tridown: '▿',
+                    triangleleft: '◃',
+                    ltri: '◃',
+                    triangleright: '▹',
+                    rtri: '▹',
+                    blacktriangle: '▴',
+                    utrif: '▴',
+                    blacktriangledown: '▾',
+                    dtrif: '▾',
+                    blacktriangleleft: '◂',
+                    ltrif: '◂',
+                    blacktriangleright: '▸',
+                    rtrif: '▸',
+                    loz: '◊',
+                    lozenge: '◊',
+                    blacklozenge: '⧫',
+                    lozf: '⧫',
+                    bigcirc: '◯',
+                    xcirc: '◯',
+                    circ: 'ˆ',
+                    Circle: '○',
+                    cir: '○',
+                    o: '○',
+                    bullet: '•',
+                    bull: '•',
+                    hellip: '…',
+                    mldr: '…',
+                    nldr: '‥',
+                    boxh: '─',
+                    HorizontalLine: '─',
+                    boxv: '│',
+                    boxdr: '┌',
+                    boxdl: '┐',
+                    boxur: '└',
+                    boxul: '┘',
+                    boxvr: '├',
+                    boxvl: '┤',
+                    boxhd: '┬',
+                    boxhu: '┴',
+                    boxvh: '┼',
+                    boxH: '═',
+                    boxV: '║',
+                    boxdR: '╒',
+                    boxDr: '╓',
+                    boxDR: '╔',
+                    boxDl: '╕',
+                    boxdL: '╖',
+                    boxDL: '╗',
+                    boxuR: '╘',
+                    boxUr: '╙',
+                    boxUR: '╚',
+                    boxUl: '╜',
+                    boxuL: '╛',
+                    boxUL: '╝',
+                    boxvR: '╞',
+                    boxVr: '╟',
+                    boxVR: '╠',
+                    boxVl: '╢',
+                    boxvL: '╡',
+                    boxVL: '╣',
+                    boxHd: '╤',
+                    boxhD: '╥',
+                    boxHD: '╦',
+                    boxHu: '╧',
+                    boxhU: '╨',
+                    boxHU: '╩',
+                    boxvH: '╪',
+                    boxVh: '╫',
+                    boxVH: '╬'
+                };
+                const PUNCTUATION = {
+                    excl: '!',
+                    iexcl: '¡',
+                    brvbar: '¦',
+                    sect: '§',
+                    uml: '¨',
+                    copy: '©',
+                    ordf: 'ª',
+                    laquo: '«',
+                    not: '¬',
+                    shy: '\u00ad',
+                    reg: '®',
+                    macr: '¯',
+                    deg: '°',
+                    plusmn: '±',
+                    sup2: '²',
+                    sup3: '³',
+                    acute: '´',
+                    micro: 'µ',
+                    para: '¶',
+                    middot: '·',
+                    cedil: '¸',
+                    sup1: '¹',
+                    ordm: 'º',
+                    raquo: '»',
+                    frac14: '¼',
+                    frac12: '½',
+                    frac34: '¾',
+                    iquest: '¿',
+                    nbsp: '\u00a0',
+                    comma: ',',
+                    period: '.',
+                    colon: ':',
+                    semi: ';',
+                    vert: '|',
+                    Verbar: '‖',
+                    verbar: '|',
+                    dblac: '˝',
+                    circ: 'ˆ',
+                    caron: 'ˇ',
+                    breve: '˘',
+                    dot: '˙',
+                    ring: '˚',
+                    ogon: '˛',
+                    tilde: '˜',
+                    DiacriticalGrave: '`',
+                    DiacriticalAcute: '´',
+                    DiacriticalTilde: '˜',
+                    DiacriticalDot: '˙',
+                    DiacriticalDoubleAcute: '˝',
+                    grave: '`',
+                    acute: '´'
+                };
+                const CURRENCY = {
+                    cent: '¢',
+                    pound: '£',
+                    curren: '¤',
+                    yen: '¥',
+                    euro: '€',
+                    dollar: '$',
+                    euro: '€',
+                    fnof: 'ƒ',
+                    inr: '₹',
+                    af: '؋',
+                    birr: 'ብር',
+                    peso: '₱',
+                    rub: '₽',
+                    won: '₩',
+                    yuan: '¥',
+                    cedil: '¸'
+                };
+                const FRACTIONS = {
+                    frac12: '½',
+                    half: '½',
+                    frac13: '⅓',
+                    frac14: '¼',
+                    frac15: '⅕',
+                    frac16: '⅙',
+                    frac18: '⅛',
+                    frac23: '⅔',
+                    frac25: '⅖',
+                    frac34: '¾',
+                    frac35: '⅗',
+                    frac38: '⅜',
+                    frac45: '⅘',
+                    frac56: '⅚',
+                    frac58: '⅝',
+                    frac78: '⅞',
+                    frasl: '⁄'
+                };
+                const MISC_SYMBOLS = {
+                    trade: '™',
+                    TRADE: '™',
+                    telrec: '⌕',
+                    target: '⌖',
+                    ulcorn: '⌜',
+                    ulcorner: '⌜',
+                    urcorn: '⌝',
+                    urcorner: '⌝',
+                    dlcorn: '⌞',
+                    llcorner: '⌞',
+                    drcorn: '⌟',
+                    lrcorner: '⌟',
+                    intercal: '⊺',
+                    intcal: '⊺',
+                    oplus: '⊕',
+                    CirclePlus: '⊕',
+                    ominus: '⊖',
+                    CircleMinus: '⊖',
+                    otimes: '⊗',
+                    CircleTimes: '⊗',
+                    osol: '⊘',
+                    odot: '⊙',
+                    CircleDot: '⊙',
+                    oast: '⊛',
+                    circledast: '⊛',
+                    odash: '⊝',
+                    circleddash: '⊝',
+                    ocirc: '⊚',
+                    circledcirc: '⊚',
+                    boxplus: '⊞',
+                    plusb: '⊞',
+                    boxminus: '⊟',
+                    minusb: '⊟',
+                    boxtimes: '⊠',
+                    timesb: '⊠',
+                    boxdot: '⊡',
+                    sdotb: '⊡',
+                    veebar: '⊻',
+                    vee: '∨',
+                    barvee: '⊽',
+                    and: '∧',
+                    wedge: '∧',
+                    Cap: '⋒',
+                    Cup: '⋓',
+                    Fork: '⋔',
+                    pitchfork: '⋔',
+                    epar: '⋕',
+                    ltlarr: '⥶',
+                    nvap: '≍⃒',
+                    nvsim: '∼⃒',
+                    nvge: '≥⃒',
+                    nvle: '≤⃒',
+                    nvlt: '<⃒',
+                    nvgt: '>⃒',
+                    nvltrie: '⊴⃒',
+                    nvrtrie: '⊵⃒',
+                    Vdash: '⊩',
+                    dashv: '⊣',
+                    vDash: '⊨',
+                    Vdash: '⊩',
+                    Vvdash: '⊪',
+                    nvdash: '⊬',
+                    nvDash: '⊭',
+                    nVdash: '⊮',
+                    nVDash: '⊯'
+                };
+                ({
+                    ...BASIC_LATIN,
+                    ...LATIN_ACCENTS,
+                    ...LATIN_EXTENDED,
+                    ...GREEK,
+                    ...CYRILLIC,
+                    ...MATH,
+                    ...MATH_ADVANCED,
+                    ...ARROWS,
+                    ...SHAPES,
+                    ...PUNCTUATION,
+                    ...CURRENCY,
+                    ...FRACTIONS,
+                    ...MISC_SYMBOLS
+                });
+                const XML = {
+                    amp: "&",
+                    apos: "'",
+                    gt: ">",
+                    lt: "<",
+                    quot: "\""
+                };
+                const COMMON_HTML = {
+                    nbsp: '\u00a0',
+                    copy: '\u00a9',
+                    reg: '\u00ae',
+                    trade: '\u2122',
+                    mdash: '\u2014',
+                    ndash: '\u2013',
+                    hellip: '\u2026',
+                    laquo: '\u00ab',
+                    raquo: '\u00bb',
+                    lsquo: '\u2018',
+                    rsquo: '\u2019',
+                    ldquo: '\u201c',
+                    rdquo: '\u201d',
+                    bull: '\u2022',
+                    para: '\u00b6',
+                    sect: '\u00a7',
+                    deg: '\u00b0',
+                    frac12: '\u00bd',
+                    frac14: '\u00bc',
+                    frac34: '\u00be'
+                };
+                const SPECIAL_CHARS = new Set('!?\\\\/[]$%{}^&*()<>|+');
+                function EntityDecoder_validateEntityName(name) {
+                    if ('#' === name[0]) throw new Error(`[EntityReplacer] Invalid character '#' in entity name: "${name}"`);
+                    for (const ch of name)if (SPECIAL_CHARS.has(ch)) throw new Error(`[EntityReplacer] Invalid character '${ch}' in entity name: "${name}"`);
+                    return name;
+                }
+                function mergeEntityMaps(...maps) {
+                    const out = Object.create(null);
+                    for (const map of maps)if (map) for (const key of Object.keys(map)){
+                        const raw = map[key];
+                        if ('string' == typeof raw) out[key] = raw;
+                        else if (raw && 'object' == typeof raw && void 0 !== raw.val) {
+                            const val = raw.val;
+                            if ('string' == typeof val) out[key] = val;
+                        }
+                    }
+                    return out;
+                }
+                const LIMIT_TIER_EXTERNAL = 'external';
+                const LIMIT_TIER_BASE = 'base';
+                const LIMIT_TIER_ALL = 'all';
+                function parseLimitTiers(raw) {
+                    if (!raw || raw === LIMIT_TIER_EXTERNAL) return new Set([
+                        LIMIT_TIER_EXTERNAL
+                    ]);
+                    if (raw === LIMIT_TIER_ALL) return new Set([
+                        LIMIT_TIER_ALL
+                    ]);
+                    if (raw === LIMIT_TIER_BASE) return new Set([
+                        LIMIT_TIER_BASE
+                    ]);
+                    if (Array.isArray(raw)) return new Set(raw);
+                    return new Set([
+                        LIMIT_TIER_EXTERNAL
+                    ]);
+                }
+                const NCR_LEVEL = Object.freeze({
+                    allow: 0,
+                    leave: 1,
+                    remove: 2,
+                    throw: 3
+                });
+                const XML10_ALLOWED_C0 = new Set([
+                    0x09,
+                    0x0A,
+                    0x0D
+                ]);
+                function parseNCRConfig(ncr) {
+                    if (!ncr) return {
+                        xmlVersion: 1.0,
+                        onLevel: NCR_LEVEL.allow,
+                        nullLevel: NCR_LEVEL.remove
+                    };
+                    const xmlVersion = 1.1 === ncr.xmlVersion ? 1.1 : 1.0;
+                    const onLevel = NCR_LEVEL[ncr.onNCR] ?? NCR_LEVEL.allow;
+                    const nullLevel = NCR_LEVEL[ncr.nullNCR] ?? NCR_LEVEL.remove;
+                    const clampedNull = Math.max(nullLevel, NCR_LEVEL.remove);
+                    return {
+                        xmlVersion,
+                        onLevel,
+                        nullLevel: clampedNull
+                    };
+                }
+                class EntityDecoder {
+                    constructor(options = {}){
+                        this._limit = options.limit || {};
+                        this._maxTotalExpansions = this._limit.maxTotalExpansions || 0;
+                        this._maxExpandedLength = this._limit.maxExpandedLength || 0;
+                        this._postCheck = 'function' == typeof options.postCheck ? options.postCheck : (r)=>r;
+                        this._limitTiers = parseLimitTiers(this._limit.applyLimitsTo ?? LIMIT_TIER_EXTERNAL);
+                        this._numericAllowed = options.numericAllowed ?? true;
+                        this._baseMap = mergeEntityMaps(XML, options.namedEntities || null);
+                        this._externalMap = Object.create(null);
+                        this._inputMap = Object.create(null);
+                        this._totalExpansions = 0;
+                        this._expandedLength = 0;
+                        this._removeSet = new Set(options.remove && Array.isArray(options.remove) ? options.remove : []);
+                        this._leaveSet = new Set(options.leave && Array.isArray(options.leave) ? options.leave : []);
+                        const ncrCfg = parseNCRConfig(options.ncr);
+                        this._ncrXmlVersion = ncrCfg.xmlVersion;
+                        this._ncrOnLevel = ncrCfg.onLevel;
+                        this._ncrNullLevel = ncrCfg.nullLevel;
+                    }
+                    setExternalEntities(map) {
+                        if (map) for (const key of Object.keys(map))EntityDecoder_validateEntityName(key);
+                        this._externalMap = mergeEntityMaps(map);
+                    }
+                    addExternalEntity(key, value) {
+                        EntityDecoder_validateEntityName(key);
+                        if ('string' == typeof value && -1 === value.indexOf('&')) this._externalMap[key] = value;
+                    }
+                    addInputEntities(map) {
+                        this._totalExpansions = 0;
+                        this._expandedLength = 0;
+                        this._inputMap = mergeEntityMaps(map);
+                    }
+                    reset() {
+                        this._inputMap = Object.create(null);
+                        this._totalExpansions = 0;
+                        this._expandedLength = 0;
+                        return this;
+                    }
+                    setXmlVersion(version) {
+                        this._ncrXmlVersion = 1.1 === version ? 1.1 : 1.0;
+                    }
+                    decode(str) {
+                        if ('string' != typeof str || 0 === str.length) return str;
+                        const original = str;
+                        const chunks = [];
+                        const len = str.length;
+                        let last = 0;
+                        let i = 0;
+                        const limitExpansions = this._maxTotalExpansions > 0;
+                        const limitLength = this._maxExpandedLength > 0;
+                        const checkLimits = limitExpansions || limitLength;
+                        while(i < len){
+                            if (38 !== str.charCodeAt(i)) {
+                                i++;
+                                continue;
+                            }
+                            let j = i + 1;
+                            while(j < len && 59 !== str.charCodeAt(j) && j - i <= 32)j++;
+                            if (j >= len || 59 !== str.charCodeAt(j)) {
+                                i++;
+                                continue;
+                            }
+                            const token = str.slice(i + 1, j);
+                            if (0 === token.length) {
+                                i++;
+                                continue;
+                            }
+                            let replacement;
+                            let tier;
+                            if (this._removeSet.has(token)) {
+                                replacement = '';
+                                if (void 0 === tier) tier = LIMIT_TIER_EXTERNAL;
+                            } else if (this._leaveSet.has(token)) {
+                                i++;
+                                continue;
+                            } else if (35 === token.charCodeAt(0)) {
+                                const ncrResult = this._resolveNCR(token);
+                                if (void 0 === ncrResult) {
+                                    i++;
+                                    continue;
+                                }
+                                replacement = ncrResult;
+                                tier = LIMIT_TIER_BASE;
+                            } else {
+                                const resolved = this._resolveName(token);
+                                replacement = resolved?.value;
+                                tier = resolved?.tier;
+                            }
+                            if (void 0 === replacement) {
+                                i++;
+                                continue;
+                            }
+                            if (i > last) chunks.push(str.slice(last, i));
+                            chunks.push(replacement);
+                            last = j + 1;
+                            i = last;
+                            if (checkLimits && this._tierCounts(tier)) {
+                                if (limitExpansions) {
+                                    this._totalExpansions++;
+                                    if (this._totalExpansions > this._maxTotalExpansions) throw new Error(`[EntityReplacer] Entity expansion count limit exceeded: ${this._totalExpansions} > ${this._maxTotalExpansions}`);
+                                }
+                                if (limitLength) {
+                                    const delta = replacement.length - (token.length + 2);
+                                    if (delta > 0) {
+                                        this._expandedLength += delta;
+                                        if (this._expandedLength > this._maxExpandedLength) throw new Error(`[EntityReplacer] Expanded content length limit exceeded: ${this._expandedLength} > ${this._maxExpandedLength}`);
+                                    }
+                                }
+                            }
+                        }
+                        if (last < len) chunks.push(str.slice(last));
+                        const result = 0 === chunks.length ? str : chunks.join('');
+                        return this._postCheck(result, original);
+                    }
+                    _tierCounts(tier) {
+                        if (this._limitTiers.has(LIMIT_TIER_ALL)) return true;
+                        return this._limitTiers.has(tier);
+                    }
+                    _resolveName(name) {
+                        if (name in this._inputMap) return {
+                            value: this._inputMap[name],
+                            tier: LIMIT_TIER_EXTERNAL
+                        };
+                        if (name in this._externalMap) return {
+                            value: this._externalMap[name],
+                            tier: LIMIT_TIER_EXTERNAL
+                        };
+                        if (name in this._baseMap) return {
+                            value: this._baseMap[name],
+                            tier: LIMIT_TIER_BASE
+                        };
+                    }
+                    _classifyNCR(cp) {
+                        if (0 === cp) return this._ncrNullLevel;
+                        if (cp >= 0xD800 && cp <= 0xDFFF) return NCR_LEVEL.remove;
+                        if (1.0 === this._ncrXmlVersion) {
+                            if (cp >= 0x01 && cp <= 0x1F && !XML10_ALLOWED_C0.has(cp)) return NCR_LEVEL.remove;
+                        }
+                        return -1;
+                    }
+                    _applyNCRAction(action, token, cp) {
+                        switch(action){
+                            case NCR_LEVEL.allow:
+                                return String.fromCodePoint(cp);
+                            case NCR_LEVEL.remove:
+                                return '';
+                            case NCR_LEVEL.leave:
+                                return;
+                            case NCR_LEVEL.throw:
+                                throw new Error(`[EntityDecoder] Prohibited numeric character reference &${token}; (U+${cp.toString(16).toUpperCase().padStart(4, '0')})`);
+                            default:
+                                return String.fromCodePoint(cp);
+                        }
+                    }
+                    _resolveNCR(token) {
+                        const second = token.charCodeAt(1);
+                        let cp;
+                        cp = 120 === second || 88 === second ? parseInt(token.slice(2), 16) : parseInt(token.slice(1), 10);
+                        if (Number.isNaN(cp) || cp < 0 || cp > 0x10FFFF) return;
+                        const minimum = this._classifyNCR(cp);
+                        if (!this._numericAllowed && minimum < NCR_LEVEL.remove) return;
+                        const effective = -1 === minimum ? this._ncrOnLevel : Math.max(this._ncrOnLevel, minimum);
+                        return this._applyNCRAction(effective, token, cp);
+                    }
+                }
                 function extractRawAttributes(prefixedAttrs, options) {
                     if (!prefixedAttrs) return {};
                     const attrs = options.attributesGroupName ? prefixedAttrs[options.attributesGroupName] : prefixedAttrs;
@@ -14841,76 +16167,10 @@
                     }
                 }
                 class OrderedObjParser {
-                    constructor(options){
+                    constructor(options, externalEntities){
                         this.options = options;
                         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: (_, str)=>fromCodePoint(str, 10, "&#")
-                            },
-                            num_hex: {
-                                regex: /&#x([0-9a-fA-F]{1,6});/g,
-                                val: (_, str)=>fromCodePoint(str, 16, "&#x")
-                            }
-                        };
-                        this.addExternalEntities = addExternalEntities;
                         this.parseXml = parseXml;
                         this.parseTextData = parseTextData;
                         this.resolveNameSpace = resolveNameSpace;
@@ -14923,6 +16183,29 @@
                         this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
                         this.entityExpansionCount = 0;
                         this.currentExpandedLength = 0;
+                        let namedEntities = {
+                            ...XML
+                        };
+                        if (this.options.entityDecoder) this.entityDecoder = this.options.entityDecoder;
+                        else {
+                            if ("object" == typeof this.options.htmlEntities) namedEntities = this.options.htmlEntities;
+                            else if (true === this.options.htmlEntities) namedEntities = {
+                                ...COMMON_HTML,
+                                ...CURRENCY
+                            };
+                            this.entityDecoder = new EntityDecoder({
+                                namedEntities: {
+                                    ...namedEntities,
+                                    ...externalEntities
+                                },
+                                numericAllowed: this.options.htmlEntities,
+                                limit: {
+                                    maxTotalExpansions: this.options.processEntities.maxTotalExpansions,
+                                    maxExpandedLength: this.options.processEntities.maxExpandedLength,
+                                    applyLimitsTo: this.options.processEntities.appliesTo
+                                }
+                            });
+                        }
                         this.matcher = new Matcher();
                         this.readonlyMatcher = this.matcher.readOnly();
                         this.isCurrentNodeStopNode = false;
@@ -14938,17 +16221,6 @@
                         }
                     }
                 }
-                function addExternalEntities(externalEntities) {
-                    const entKeys = Object.keys(externalEntities);
-                    for(let i = 0; i < entKeys.length; i++){
-                        const ent = entKeys[i];
-                        const escaped = ent.replace(/[.\-+*:]/g, '\\.');
-                        this.lastEntities[ent] = {
-                            regex: new RegExp("&" + escaped + ";", "g"),
-                            val: externalEntities[ent]
-                        };
-                    }
-                }
                 function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
                     const options = this.options;
                     if (void 0 !== val) {
@@ -14978,9 +16250,9 @@
                     return tagname;
                 }
                 const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
-                function buildAttributesMap(attrStr, jPath, tagName) {
+                function buildAttributesMap(attrStr, jPath, tagName, force = false) {
                     const options = this.options;
-                    if (true !== options.ignoreAttributes && 'string' == typeof attrStr) {
+                    if (true === force || true !== options.ignoreAttributes && 'string' == typeof attrStr) {
                         const matches = getAllMatches(attrStr, attrsRegx);
                         const len = matches.length;
                         const attrs = {};
@@ -15023,7 +16295,7 @@
                             }
                         }
                         if (!hasAttrs) return;
-                        if (options.attributesGroupName) {
+                        if (options.attributesGroupName && !options.preserveOrder) {
                             const attrCollection = {};
                             attrCollection[options.attributesGroupName] = attrs;
                             return attrCollection;
@@ -15037,11 +16309,9 @@
                     let currentNode = xmlObj;
                     let textData = "";
                     this.matcher.reset();
+                    this.entityDecoder.reset();
                     this.entityExpansionCount = 0;
                     this.currentExpandedLength = 0;
-                    this.docTypeEntitiesKeys = [];
-                    this.lastEntitiesKeys = Object.keys(this.lastEntities);
-                    this.htmlEntitiesKeys = this.options.htmlEntities ? Object.keys(this.htmlEntities) : [];
                     const options = this.options;
                     const docTypeReader = new DocTypeReader(options.processEntities);
                     const xmlLen = xmlData.length;
@@ -15073,11 +16343,16 @@
                                 let tagData = readTagExp(xmlData, i, false, "?>");
                                 if (!tagData) throw new Error("Pi Tag is not closed.");
                                 textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
+                                const attsMap = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName, true);
+                                if (attsMap) {
+                                    const ver = attsMap[this.options.attributeNamePrefix + "version"];
+                                    this.entityDecoder.setXmlVersion(Number(ver) || 1.0);
+                                }
                                 if (options.ignoreDeclaration && "?xml" === tagData.tagName || options.ignorePiTags) ;
                                 else {
                                     const childNode = new XmlNode(tagData.tagName);
                                     childNode.add(options.textNodeName, "");
-                                    if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);
+                                    if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent && true !== options.ignoreAttributes) childNode[":@"] = attsMap;
                                     this.addChild(currentNode, childNode, this.readonlyMatcher, i);
                                 }
                                 i = tagData.closeIndex + 1;
@@ -15095,8 +16370,7 @@
                                 i = endIndex;
                             } else if (33 === c1 && 68 === xmlData.charCodeAt(i + 2)) {
                                 const result = docTypeReader.readDocType(xmlData, i);
-                                this.docTypeEntities = result.entities;
-                                this.docTypeEntitiesKeys = Object.keys(this.docTypeEntities) || [];
+                                this.entityDecoder.addInputEntities(result.entities);
                                 i = result.i;
                             } else if (33 === c1 && 91 === xmlData.charCodeAt(i + 2)) {
                                 const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
@@ -15221,42 +16495,7 @@
                         const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
                         if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) return val;
                     }
-                    for (const entityName of this.docTypeEntitiesKeys){
-                        const entity = this.docTypeEntities[entityName];
-                        const matches = val.match(entity.regx);
-                        if (matches) {
-                            this.entityExpansionCount += matches.length;
-                            if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`);
-                            const lengthBefore = val.length;
-                            val = val.replace(entity.regx, entity.val);
-                            if (entityConfig.maxExpandedLength) {
-                                this.currentExpandedLength += val.length - lengthBefore;
-                                if (this.currentExpandedLength > entityConfig.maxExpandedLength) throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`);
-                            }
-                        }
-                    }
-                    if (-1 === val.indexOf('&')) return val;
-                    for (const entityName of this.lastEntitiesKeys){
-                        const entity = this.lastEntities[entityName];
-                        const matches = val.match(entity.regex);
-                        if (matches) {
-                            this.entityExpansionCount += matches.length;
-                            if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`);
-                        }
-                        val = val.replace(entity.regex, entity.val);
-                    }
-                    if (-1 === val.indexOf('&')) return val;
-                    for (const entityName of this.htmlEntitiesKeys){
-                        const entity = this.htmlEntities[entityName];
-                        const matches = val.match(entity.regex);
-                        if (matches) {
-                            this.entityExpansionCount += matches.length;
-                            if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`);
-                        }
-                        val = val.replace(entity.regex, entity.val);
-                    }
-                    val = val.replace(this.ampEntity.regex, this.ampEntity.val);
-                    return val;
+                    return this.entityDecoder.decode(val);
                 }
                 function saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {
                     if (textData) {
@@ -15273,29 +16512,35 @@
                 }
                 function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
                     let attrBoundary = 0;
-                    const chars = [];
                     const len = xmlData.length;
                     const closeCode0 = closingChar.charCodeAt(0);
                     const closeCode1 = closingChar.length > 1 ? closingChar.charCodeAt(1) : -1;
+                    let result = '';
+                    let segmentStart = i;
                     for(let index = i; index < len; index++){
                         const code = xmlData.charCodeAt(index);
                         if (attrBoundary) {
                             if (code === attrBoundary) attrBoundary = 0;
                         } else if (34 === code || 39 === code) attrBoundary = code;
-                        else if (code === closeCode0) {
-                            if (-1 === closeCode1) return {
-                                data: String.fromCharCode(...chars),
-                                index
-                            };
-                            else if (xmlData.charCodeAt(index + 1) === closeCode1) return {
-                                data: String.fromCharCode(...chars),
+                        else if (code === closeCode0) if (-1 !== closeCode1) {
+                            if (xmlData.charCodeAt(index + 1) === closeCode1) {
+                                result += xmlData.substring(segmentStart, index);
+                                return {
+                                    data: result,
+                                    index
+                                };
+                            }
+                        } else {
+                            result += xmlData.substring(segmentStart, index);
+                            return {
+                                data: result,
                                 index
                             };
-                        } else if (9 === code) {
-                            chars.push(32);
-                            continue;
                         }
-                        chars.push(code);
+                        else if (9 === code && !attrBoundary) {
+                            result += xmlData.substring(segmentStart, index) + ' ';
+                            segmentStart = index + 1;
+                        }
                     }
                 }
                 function findClosingIndex(xmlData, str, i, errMsg) {
@@ -15363,7 +16608,7 @@
                             const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
                             i = closeIndex;
                         } else {
-                            const tagData = readTagExp(xmlData, i, '>');
+                            const tagData = readTagExp(xmlData, i, false);
                             if (tagData) {
                                 const openTagName = tagData && tagData.tagName;
                                 if (openTagName === tagName && "/" !== tagData.tagExp[tagData.tagExp.length - 1]) openTagCount++;
@@ -15382,11 +16627,6 @@
                     if (isExist(val)) return val;
                     return '';
                 }
-                function fromCodePoint(str, base, prefix) {
-                    const codePoint = Number.parseInt(str, base);
-                    if (codePoint >= 0 && codePoint <= 0x10FFFF) return String.fromCodePoint(codePoint);
-                    return prefix + str + ";";
-                }
                 function transformTagName(fn, tagName, tagExp, options) {
                     if (fn) {
                         const newTagName = fn(tagName);
@@ -15434,6 +16674,7 @@
                         else if (tagObj[property]) {
                             let val = node2json_compress(tagObj[property], options, matcher, readonlyMatcher);
                             const isLeaf = isLeafTag(val, options);
+                            if (0 === Object.keys(val).length && options.alwaysCreateTextNode) val[options.textNodeName] = "";
                             if (tagObj[":@"]) assignAttributes(val, tagObj[":@"], readonlyMatcher, options);
                             else if (1 !== Object.keys(val).length || void 0 === val[options.textNodeName] || options.alwaysCreateTextNode) {
                                 if (0 === Object.keys(val).length) if (options.alwaysCreateTextNode) val[options.textNodeName] = "";
@@ -15725,8 +16966,7 @@
                             const result = validate(xmlData, validationOption);
                             if (true !== result) throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
                         }
-                        const orderedObjParser = new OrderedObjParser(this.options);
-                        orderedObjParser.addExternalEntities(this.externalEntities);
+                        const orderedObjParser = new OrderedObjParser(this.options, this.externalEntities);
                         const orderedResult = orderedObjParser.parseXml(xmlData);
                         if (this.options.preserveOrder || void 0 === orderedResult) return orderedResult;
                         return prettify(orderedResult, this.options, orderedObjParser.matcher, orderedObjParser.readonlyMatcher);
@@ -15741,20 +16981,73 @@
                         return XmlNode.getMetaDataSymbol();
                     }
                 }
+                function safeComment(val) {
+                    return String(val).replace(/--/g, '- -').replace(/--/g, '- -').replace(/-$/, '- ');
+                }
+                function safeCdata(val) {
+                    return String(val).replace(/\]\]>/g, ']]]]><![CDATA[>');
+                }
+                function escapeAttribute(val) {
+                    return String(val).replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+                }
+                const nameStartChar10 = ":A-Za-z_À-ÖØ-öø-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�";
+                const nameChar10 = nameStartChar10 + "\\-\\.\\d·̀-ͯ‿-⁀";
+                const nameStartChar11 = ":A-Za-z_À-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿";
+                const nameChar11 = nameStartChar11 + "\\-\\.\\d·̀-ͯ҇‿-⁀";
+                const buildRegexes = (startChar, char, flags = '')=>{
+                    const ncStart = startChar.replace(':', '');
+                    const ncChar = char.replace(':', '');
+                    const ncNamePat = `[${ncStart}][${ncChar}]*`;
+                    return {
+                        name: new RegExp(`^[${startChar}][${char}]*$`, flags),
+                        ncName: new RegExp(`^${ncNamePat}$`, flags),
+                        qName: new RegExp(`^${ncNamePat}(?::${ncNamePat})?$`, flags),
+                        nmToken: new RegExp(`^[${char}]+$`, flags),
+                        nmTokens: new RegExp(`^[${char}]+(?:\\s+[${char}]+)*$`, flags)
+                    };
+                };
+                const regexes10 = buildRegexes(nameStartChar10, nameChar10);
+                const regexes11 = buildRegexes(nameStartChar11, nameChar11, 'u');
+                const getRegexes = (xmlVersion = '1.0')=>'1.1' === xmlVersion ? regexes11 : regexes10;
+                const qName = (str, { xmlVersion = '1.0' } = {})=>getRegexes(xmlVersion).qName.test(str);
                 const EOL = "\n";
+                function detectXmlVersionFromArray(jArray, options) {
+                    if (!Array.isArray(jArray) || 0 === jArray.length) return '1.0';
+                    const first = jArray[0];
+                    const firstKey = orderedJs2Xml_propName(first);
+                    if ('?xml' === firstKey) {
+                        const attrs = first[':@'];
+                        if (attrs) {
+                            const versionKey = options.attributeNamePrefix + 'version';
+                            if (attrs[versionKey]) return attrs[versionKey];
+                        }
+                    }
+                    return '1.0';
+                }
+                function resolveTagName(name, isAttribute, options, matcher, xmlVersion) {
+                    if (!options.sanitizeName) return name;
+                    if (qName(name, {
+                        xmlVersion
+                    })) return name;
+                    return options.sanitizeName(name, {
+                        isAttribute,
+                        matcher: matcher.readOnly()
+                    });
+                }
                 function toXml(jArray, options) {
                     let indentation = "";
-                    if (options.format && options.indentBy.length > 0) indentation = EOL;
+                    if (options.format) indentation = EOL;
                     const stopNodeExpressions = [];
                     if (options.stopNodes && Array.isArray(options.stopNodes)) for(let i = 0; i < options.stopNodes.length; i++){
                         const node = options.stopNodes[i];
                         if ('string' == typeof node) stopNodeExpressions.push(new Expression(node));
                         else if (node instanceof Expression) stopNodeExpressions.push(node);
                     }
+                    const xmlVersion = detectXmlVersionFromArray(jArray, options);
                     const matcher = new Matcher();
-                    return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions);
+                    return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions, xmlVersion);
                 }
-                function arrToStr(arr, options, indentation, matcher, stopNodeExpressions) {
+                function arrToStr(arr, options, indentation, matcher, stopNodeExpressions, xmlVersion) {
                     let xmlStr = "";
                     let isPreviousElementTag = false;
                     if (options.maxNestedTags && matcher.getDepth() > options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
@@ -15768,13 +17061,15 @@
                     }
                     for(let i = 0; i < arr.length; i++){
                         const tagObj = arr[i];
-                        const tagName = orderedJs2Xml_propName(tagObj);
-                        if (void 0 === tagName) continue;
+                        const rawTagName = orderedJs2Xml_propName(tagObj);
+                        if (void 0 === rawTagName) continue;
+                        const isSpecialName = rawTagName === options.textNodeName || rawTagName === options.cdataPropName || rawTagName === options.commentPropName || '?' === rawTagName[0];
+                        const tagName = isSpecialName ? rawTagName : resolveTagName(rawTagName, false, options, matcher, xmlVersion);
                         const attrValues = extractAttributeValues(tagObj[":@"], options);
                         matcher.push(tagName, attrValues);
                         const isStopNode = checkStopNode(matcher, stopNodeExpressions);
                         if (tagName === options.textNodeName) {
-                            let tagText = tagObj[tagName];
+                            let tagText = tagObj[rawTagName];
                             if (!isStopNode) {
                                 tagText = options.tagValueProcessor(tagName, tagText);
                                 tagText = orderedJs2Xml_replaceEntitiesValue(tagText, options);
@@ -15787,32 +17082,34 @@
                         }
                         if (tagName === options.cdataPropName) {
                             if (isPreviousElementTag) xmlStr += indentation;
-                            xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
+                            const val = tagObj[rawTagName][0][options.textNodeName];
+                            const safeVal = safeCdata(val);
+                            xmlStr += `<![CDATA[${safeVal}]]>`;
                             isPreviousElementTag = false;
                             matcher.pop();
                             continue;
                         }
                         if (tagName === options.commentPropName) {
-                            xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
+                            const val = tagObj[rawTagName][0][options.textNodeName];
+                            const safeVal = safeComment(val);
+                            xmlStr += indentation + `<!--${safeVal}-->`;
                             isPreviousElementTag = true;
                             matcher.pop();
                             continue;
                         } else if ("?" === tagName[0]) {
-                            const attStr = attr_to_str(tagObj[":@"], options, isStopNode);
+                            const attStr = attr_to_str(tagObj[":@"], options, isStopNode, matcher, xmlVersion);
                             const tempInd = "?xml" === tagName ? "" : indentation;
-                            let piTextNodeName = tagObj[tagName][0][options.textNodeName];
-                            piTextNodeName = 0 !== piTextNodeName.length ? " " + piTextNodeName : "";
-                            xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr}?>`;
+                            xmlStr += tempInd + `<${tagName}${attStr}?>`;
                             isPreviousElementTag = true;
                             matcher.pop();
                             continue;
                         }
                         let newIdentation = indentation;
                         if ("" !== newIdentation) newIdentation += options.indentBy;
-                        const attStr = attr_to_str(tagObj[":@"], options, isStopNode);
+                        const attStr = attr_to_str(tagObj[":@"], options, isStopNode, matcher, xmlVersion);
                         const tagStart = indentation + `<${tagName}${attStr}`;
                         let tagValue;
-                        tagValue = isStopNode ? getRawContent(tagObj[tagName], options) : arrToStr(tagObj[tagName], options, newIdentation, matcher, stopNodeExpressions);
+                        tagValue = isStopNode ? getRawContent(tagObj[rawTagName], options) : arrToStr(tagObj[rawTagName], options, newIdentation, matcher, stopNodeExpressions, xmlVersion);
                         if (-1 !== options.unpairedTags.indexOf(tagName)) if (options.suppressUnpairedNode) xmlStr += tagStart + ">";
                         else xmlStr += tagStart + "/>";
                         else if ((!tagValue || 0 === tagValue.length) && options.suppressEmptyNode) xmlStr += tagStart + "/>";
@@ -15835,7 +17132,7 @@
                     for(let attr in attrMap){
                         if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
                         const cleanAttrName = attr.startsWith(options.attributeNamePrefix) ? attr.substr(options.attributeNamePrefix.length) : attr;
-                        attrValues[cleanAttrName] = attrMap[attr];
+                        attrValues[cleanAttrName] = escapeAttribute(attrMap[attr]);
                         hasAttrs = true;
                     }
                     return hasAttrs ? attrValues : null;
@@ -15868,7 +17165,7 @@
                         if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
                         let attrVal = attrMap[attr];
                         if (true === attrVal && options.suppressBooleanAttributes) attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
-                        else attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
+                        else attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${escapeAttribute(attrVal)}"`;
                     }
                     return attrStr;
                 }
@@ -15881,18 +17178,20 @@
                         }
                     }
                 }
-                function attr_to_str(attrMap, options, isStopNode) {
+                function attr_to_str(attrMap, options, isStopNode, matcher, xmlVersion) {
                     let attrStr = "";
                     if (attrMap && !options.ignoreAttributes) for(let attr in attrMap){
                         if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
+                        const cleanAttrName = attr.substr(options.attributeNamePrefix.length);
+                        const resolvedAttrName = isStopNode ? cleanAttrName : resolveTagName(cleanAttrName, true, options, matcher, xmlVersion);
                         let attrVal;
                         if (isStopNode) attrVal = attrMap[attr];
                         else {
                             attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
                             attrVal = orderedJs2Xml_replaceEntitiesValue(attrVal, options);
                         }
-                        if (true === attrVal && options.suppressBooleanAttributes) attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
-                        else attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
+                        if (true === attrVal && options.suppressBooleanAttributes) attrStr += ` ${resolvedAttrName}`;
+                        else attrStr += ` ${resolvedAttrName}="${escapeAttribute(attrVal)}"`;
                     }
                     return attrStr;
                 }
@@ -15964,7 +17263,8 @@
                     stopNodes: [],
                     oneListGroup: false,
                     maxNestedTags: 100,
-                    jPath: true
+                    jPath: true,
+                    sanitizeName: false
                 };
                 function Builder(options) {
                     this.options = Object.assign({}, fxb_defaultOptions, options);
@@ -15984,7 +17284,7 @@
                     else {
                         this.ignoreAttributesFn = ignoreAttributes_getIgnoreAttributesFn(this.options.ignoreAttributes);
                         this.attrPrefixLen = this.options.attributeNamePrefix.length;
-                        this.isAttribute = isAttribute;
+                        this.isAttribute = fxb_isAttribute;
                     }
                     this.processTextOrObjNode = processTextOrObjNode;
                     if (this.options.format) {
@@ -15999,6 +17299,28 @@
                         this.newLine = '';
                     }
                 }
+                function detectXmlVersionFromObj(jObj, options) {
+                    const decl = jObj['?xml'];
+                    if (decl && 'object' == typeof decl) {
+                        if (options.attributesGroupName && decl[options.attributesGroupName]) {
+                            const v = decl[options.attributesGroupName][options.attributeNamePrefix + 'version'];
+                            if (v) return v;
+                        }
+                        const v = decl[options.attributeNamePrefix + 'version'];
+                        if (v) return v;
+                    }
+                    return '1.0';
+                }
+                function fxb_resolveTagName(name, isAttribute, options, matcher, xmlVersion) {
+                    if (!options.sanitizeName) return name;
+                    if (qName(name, {
+                        xmlVersion
+                    })) return name;
+                    return options.sanitizeName(name, {
+                        isAttribute,
+                        matcher: matcher.readOnly()
+                    });
+                }
                 Builder.prototype.build = function(jObj) {
                     if (this.options.preserveOrder) return toXml(jObj, this.options);
                     {
@@ -16006,76 +17328,87 @@
                             [this.options.arrayNodeName]: jObj
                         };
                         const matcher = new Matcher();
-                        return this.j2x(jObj, 0, matcher).val;
+                        const xmlVersion = detectXmlVersionFromObj(jObj, this.options);
+                        return this.j2x(jObj, 0, matcher, xmlVersion).val;
                     }
                 };
-                Builder.prototype.j2x = function(jObj, level, matcher) {
+                Builder.prototype.j2x = function(jObj, level, matcher, xmlVersion) {
                     let attrStr = '';
                     let val = '';
                     if (this.options.maxNestedTags && matcher.getDepth() >= this.options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
                     const jPath = this.options.jPath ? matcher.toString() : matcher;
                     const isCurrentStopNode = this.checkStopNode(matcher);
-                    for(let key in jObj)if (Object.prototype.hasOwnProperty.call(jObj, key)) if (void 0 === jObj[key]) {
-                        if (this.isAttribute(key)) val += '';
-                    } else if (null === jObj[key]) if (this.isAttribute(key)) val += '';
-                    else if (key === this.options.cdataPropName) val += '';
-                    else if ('?' === key[0]) val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
-                    else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
-                    else if (jObj[key] instanceof Date) val += this.buildTextValNode(jObj[key], key, '', level, matcher);
-                    else if ('object' != typeof jObj[key]) {
-                        const attr = this.isAttribute(key);
-                        if (attr && !this.ignoreAttributesFn(attr, jPath)) attrStr += this.buildAttrPairStr(attr, '' + jObj[key], isCurrentStopNode);
-                        else if (!attr) if (key === this.options.textNodeName) {
-                            let newval = this.options.tagValueProcessor(key, '' + jObj[key]);
-                            val += this.replaceEntitiesValue(newval);
-                        } else {
-                            matcher.push(key);
-                            const isStopNode = this.checkStopNode(matcher);
-                            matcher.pop();
-                            if (isStopNode) {
-                                const textValue = '' + jObj[key];
-                                if ('' === textValue) val += this.indentate(level) + '<' + key + this.closeTag(key) + this.tagEndChar;
-                                else val += this.indentate(level) + '<' + key + '>' + textValue + '</' + key + this.tagEndChar;
-                            } else val += this.buildTextValNode(jObj[key], key, '', level, matcher);
-                        }
-                    } else if (Array.isArray(jObj[key])) {
-                        const arrLen = jObj[key].length;
-                        let listTagVal = "";
-                        let listTagAttr = "";
-                        for(let j = 0; j < arrLen; j++){
-                            const item = jObj[key][j];
-                            if (void 0 === item) ;
-                            else if (null === item) if ("?" === key[0]) val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
-                            else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
-                            else if ('object' == typeof item) if (this.options.oneListGroup) {
-                                matcher.push(key);
-                                const result = this.j2x(item, level + 1, matcher);
-                                matcher.pop();
-                                listTagVal += result.val;
-                                if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) listTagAttr += result.attrStr;
-                            } else listTagVal += this.processTextOrObjNode(item, key, level, matcher);
-                            else if (this.options.oneListGroup) {
-                                let textValue = this.options.tagValueProcessor(key, item);
-                                textValue = this.replaceEntitiesValue(textValue);
-                                listTagVal += textValue;
+                    for(let key in jObj){
+                        if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
+                        const isSpecialKey = key === this.options.textNodeName || key === this.options.cdataPropName || key === this.options.commentPropName || this.options.attributesGroupName && key === this.options.attributesGroupName || this.isAttribute(key) || '?' === key[0];
+                        const resolvedKey = isSpecialKey ? key : fxb_resolveTagName(key, false, this.options, matcher, xmlVersion);
+                        if (void 0 === jObj[key]) {
+                            if (this.isAttribute(key)) val += '';
+                        } else if (null === jObj[key]) if (this.isAttribute(key)) val += '';
+                        else if (resolvedKey === this.options.cdataPropName || resolvedKey === this.options.commentPropName) val += '';
+                        else if ('?' === resolvedKey[0]) val += this.indentate(level) + '<' + resolvedKey + '?' + this.tagEndChar;
+                        else val += this.indentate(level) + '<' + resolvedKey + '/' + this.tagEndChar;
+                        else if (jObj[key] instanceof Date) val += this.buildTextValNode(jObj[key], resolvedKey, '', level, matcher);
+                        else if ('object' != typeof jObj[key]) {
+                            const attr = this.isAttribute(key);
+                            if (attr && !this.ignoreAttributesFn(attr, jPath)) {
+                                const resolvedAttr = fxb_resolveTagName(attr, true, this.options, matcher, xmlVersion);
+                                attrStr += this.buildAttrPairStr(resolvedAttr, '' + jObj[key], isCurrentStopNode);
+                            } else if (!attr) if (key === this.options.textNodeName) {
+                                let newval = this.options.tagValueProcessor(key, '' + jObj[key]);
+                                val += this.replaceEntitiesValue(newval);
                             } else {
-                                matcher.push(key);
+                                matcher.push(resolvedKey);
                                 const isStopNode = this.checkStopNode(matcher);
                                 matcher.pop();
                                 if (isStopNode) {
-                                    const textValue = '' + item;
-                                    if ('' === textValue) listTagVal += this.indentate(level) + '<' + key + this.closeTag(key) + this.tagEndChar;
-                                    else listTagVal += this.indentate(level) + '<' + key + '>' + textValue + '</' + key + this.tagEndChar;
-                                } else listTagVal += this.buildTextValNode(item, key, '', level, matcher);
-                            }
-                        }
-                        if (this.options.oneListGroup) listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);
-                        val += listTagVal;
-                    } else if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
-                        const Ks = Object.keys(jObj[key]);
-                        const L = Ks.length;
-                        for(let j = 0; j < L; j++)attrStr += this.buildAttrPairStr(Ks[j], '' + jObj[key][Ks[j]], isCurrentStopNode);
-                    } else val += this.processTextOrObjNode(jObj[key], key, level, matcher);
+                                    const textValue = '' + jObj[key];
+                                    if ('' === textValue) val += this.indentate(level) + '<' + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;
+                                    else val += this.indentate(level) + '<' + resolvedKey + '>' + textValue + '</' + resolvedKey + this.tagEndChar;
+                                } else val += this.buildTextValNode(jObj[key], resolvedKey, '', level, matcher);
+                            }
+                        } else if (Array.isArray(jObj[key])) {
+                            const arrLen = jObj[key].length;
+                            let listTagVal = "";
+                            let listTagAttr = "";
+                            for(let j = 0; j < arrLen; j++){
+                                const item = jObj[key][j];
+                                if (void 0 === item) ;
+                                else if (null === item) if ("?" === resolvedKey[0]) val += this.indentate(level) + '<' + resolvedKey + '?' + this.tagEndChar;
+                                else val += this.indentate(level) + '<' + resolvedKey + '/' + this.tagEndChar;
+                                else if ('object' == typeof item) if (this.options.oneListGroup) {
+                                    matcher.push(resolvedKey);
+                                    const result = this.j2x(item, level + 1, matcher, xmlVersion);
+                                    matcher.pop();
+                                    listTagVal += result.val;
+                                    if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) listTagAttr += result.attrStr;
+                                } else listTagVal += this.processTextOrObjNode(item, resolvedKey, level, matcher, xmlVersion);
+                                else if (this.options.oneListGroup) {
+                                    let textValue = this.options.tagValueProcessor(resolvedKey, item);
+                                    textValue = this.replaceEntitiesValue(textValue);
+                                    listTagVal += textValue;
+                                } else {
+                                    matcher.push(resolvedKey);
+                                    const isStopNode = this.checkStopNode(matcher);
+                                    matcher.pop();
+                                    if (isStopNode) {
+                                        const textValue = '' + item;
+                                        if ('' === textValue) listTagVal += this.indentate(level) + '<' + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;
+                                        else listTagVal += this.indentate(level) + '<' + resolvedKey + '>' + textValue + '</' + resolvedKey + this.tagEndChar;
+                                    } else listTagVal += this.buildTextValNode(item, resolvedKey, '', level, matcher);
+                                }
+                            }
+                            if (this.options.oneListGroup) listTagVal = this.buildObjectNode(listTagVal, resolvedKey, listTagAttr, level);
+                            val += listTagVal;
+                        } else if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
+                            const Ks = Object.keys(jObj[key]);
+                            const L = Ks.length;
+                            for(let j = 0; j < L; j++){
+                                const resolvedAttr = fxb_resolveTagName(Ks[j], true, this.options, matcher, xmlVersion);
+                                attrStr += this.buildAttrPairStr(resolvedAttr, '' + jObj[key][Ks[j]], isCurrentStopNode);
+                            }
+                        } else val += this.processTextOrObjNode(jObj[key], resolvedKey, level, matcher, xmlVersion);
+                    }
                     return {
                         attrStr: attrStr,
                         val: val
@@ -16087,9 +17420,9 @@
                         val = this.replaceEntitiesValue(val);
                     }
                     if (this.options.suppressBooleanAttributes && "true" === val) return ' ' + attrName;
-                    return ' ' + attrName + '="' + val + '"';
+                    return ' ' + attrName + '="' + escapeAttribute(val) + '"';
                 };
-                function processTextOrObjNode(object, key, level, matcher) {
+                function processTextOrObjNode(object, key, level, matcher, xmlVersion) {
                     const attrValues = this.extractAttributes(object);
                     matcher.push(key, attrValues);
                     const isStopNode = this.checkStopNode(matcher);
@@ -16099,8 +17432,9 @@
                         matcher.pop();
                         return this.buildObjectNode(rawContent, key, attrStr, level);
                     }
-                    const result = this.j2x(object, level + 1, matcher);
+                    const result = this.j2x(object, level + 1, matcher, xmlVersion);
                     matcher.pop();
+                    if ('?' === key[0]) return this.buildTextValNode('', key, result.attrStr, level, matcher);
                     if (void 0 !== object[this.options.textNodeName] && 1 === Object.keys(object).length) return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level, matcher);
                     return this.buildObjectNode(result.val, key, result.attrStr, level);
                 }
@@ -16113,14 +17447,14 @@
                         for(let attrKey in attrGroup){
                             if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;
                             const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix) ? attrKey.substring(this.options.attributeNamePrefix.length) : attrKey;
-                            attrValues[cleanKey] = attrGroup[attrKey];
+                            attrValues[cleanKey] = escapeAttribute(attrGroup[attrKey]);
                             hasAttrs = true;
                         }
                     } else for(let key in obj){
                         if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
                         const attr = this.isAttribute(key);
                         if (attr) {
-                            attrValues[attr] = obj[key];
+                            attrValues[attr] = escapeAttribute(obj[key]);
                             hasAttrs = true;
                         }
                     }
@@ -16181,6 +17515,7 @@
                     if ("" === val) if ("?" === key[0]) return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;
                     else return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;
                     {
+                        if ("?" === key[0]) return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;
                         let tagEndExp = '</' + key + this.tagEndChar;
                         let piClosingChar = "";
                         if ("?" === key[0]) {
@@ -16205,9 +17540,15 @@
                     return false;
                 };
                 Builder.prototype.buildTextValNode = function(val, key, attrStr, level, matcher) {
-                    if (false !== this.options.cdataPropName && key === this.options.cdataPropName) return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;
+                    if (false !== this.options.cdataPropName && key === this.options.cdataPropName) {
+                        const safeVal = safeCdata(val);
+                        return this.indentate(level) + `<![CDATA[${safeVal}]]>` + this.newLine;
+                    }
+                    if (false !== this.options.commentPropName && key === this.options.commentPropName) {
+                        const safeVal = safeComment(val);
+                        return this.indentate(level) + `<!--${safeVal}-->` + this.newLine;
+                    }
                     {
-                        if (false !== this.options.commentPropName && key === this.options.commentPropName) return this.indentate(level) + `<!--${val}-->` + this.newLine;
                         if ("?" === key[0]) return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;
                         let textValue = this.options.tagValueProcessor(key, val);
                         textValue = this.replaceEntitiesValue(textValue);
@@ -16225,7 +17566,7 @@
                 function indentate(level) {
                     return this.options.indentBy.repeat(level);
                 }
-                function isAttribute(name) {
+                function fxb_isAttribute(name) {
                     if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) return name.substr(this.attrPrefixLen);
                     return false;
                 }
@@ -16656,11 +17997,18 @@
                     if (void 0 == globalThis[symbol]) {
                         const te = new globalThis.TextEncoder();
                         const td = new globalThis.TextDecoder();
+                        let tdStrict;
                         globalThis[symbol] = {
                             encodeUtf8 (text) {
                                 return te.encode(text);
                             },
-                            decodeUtf8 (bytes) {
+                            decodeUtf8 (bytes, strict) {
+                                if (strict) {
+                                    if (void 0 === tdStrict) tdStrict = new globalThis.TextDecoder("utf-8", {
+                                        fatal: true
+                                    });
+                                    return tdStrict.decode(bytes);
+                                }
                                 return td.decode(bytes);
                             },
                             checkUtf8 (text) {
@@ -16836,8 +18184,13 @@
                         this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
                     }
                     tag() {
-                        let tag = this.uint32(), fieldNo = tag >>> 3, wireType = 7 & tag;
-                        if (fieldNo <= 0 || wireType < 0 || wireType > 5) throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+                        const start = this.pos;
+                        const tag = this.uint32();
+                        const bytesRead = this.pos - start;
+                        if (bytesRead > 5 || 5 == bytesRead && this.buf[this.pos - 1] > 0x0f) throw new Error("illegal tag: varint overflows uint32");
+                        const fieldNo = tag >>> 3;
+                        const wireType = 7 & tag;
+                        if (fieldNo <= 0 || wireType > 5) throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
                         return [
                             fieldNo,
                             wireType
@@ -16925,8 +18278,8 @@
                         this.assertBounds();
                         return this.buf.subarray(start, start + len);
                     }
-                    string() {
-                        return this.decodeUtf8(this.bytes());
+                    string(strict) {
+                        return this.decodeUtf8(this.bytes(), strict);
                     }
                 }
                 function assertInt32(arg) {
@@ -17676,7 +19029,7 @@
                     var _a;
                     switch(field.fieldKind){
                         case "scalar":
-                            message.set(field, readScalar(reader, field.scalar));
+                            message.set(field, readScalar(reader, field.scalar, field.utf8Validation));
                             break;
                         case "enum":
                             const val = readScalar(reader, descriptors_ScalarType.INT32);
@@ -17718,12 +19071,12 @@
                         const [fieldNo] = reader.tag();
                         switch(fieldNo){
                             case 1:
-                                key = readScalar(reader, field.mapKey);
+                                key = readScalar(reader, field.mapKey, field.utf8Validation);
                                 break;
                             case 2:
                                 switch(field.mapKind){
                                     case "scalar":
-                                        val = readScalar(reader, field.scalar);
+                                        val = readScalar(reader, field.scalar, field.utf8Validation);
                                         break;
                                     case "enum":
                                         val = reader.int32();
@@ -17755,9 +19108,9 @@
                     if ("message" === field.listKind) return void list.add(readMessageField(reader, options, field));
                     const scalarType = null != (_a = field.scalar) ? _a : descriptors_ScalarType.INT32;
                     const packed = wireType == binary_encoding_WireType.LengthDelimited && scalarType != descriptors_ScalarType.STRING && scalarType != descriptors_ScalarType.BYTES;
-                    if (!packed) return void list.add(readScalar(reader, scalarType));
+                    if (!packed) return void list.add(readScalar(reader, scalarType, field.utf8Validation));
                     const e = reader.uint32() + reader.pos;
-                    while(reader.pos < e)list.add(readScalar(reader, scalarType));
+                    while(reader.pos < e)list.add(readScalar(reader, scalarType, field.utf8Validation));
                 }
                 function readMessageField(reader, options, field, mergeMessage) {
                     const delimited = field.delimitedEncoding;
@@ -17765,10 +19118,10 @@
                     readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32());
                     return message;
                 }
-                function readScalar(reader, type) {
+                function readScalar(reader, type, validateUtf8 = false) {
                     switch(type){
                         case descriptors_ScalarType.STRING:
-                            return reader.string();
+                            return reader.string(validateUtf8);
                         case descriptors_ScalarType.BOOL:
                             return reader.bool();
                         case descriptors_ScalarType.DOUBLE:
@@ -18316,6 +19669,7 @@
                 }
                 const registry_EDITION_PROTO2 = 998;
                 const registry_EDITION_PROTO3 = 999;
+                const EDITION_UNSTABLE = 9999;
                 const TYPE_STRING = 9;
                 const TYPE_GROUP = 10;
                 const TYPE_MESSAGE = 11;
@@ -18331,6 +19685,8 @@
                 const PACKED = 1;
                 const DELIMITED = 2;
                 const OPEN = 1;
+                const VERIFY = 2;
+                const maximumEdition = 1001;
                 const featureDefaults = {
                     998: {
                         fieldPresence: 1,
@@ -18593,6 +19949,7 @@
                         message: void 0,
                         enum: void 0,
                         presence: getFieldPresence(proto, oneof, isExtension, parentOrFile),
+                        utf8Validation: isUtf8Validated(proto, parentOrFile),
                         listKind: void 0,
                         mapKind: void 0,
                         mapKey: void 0,
@@ -18698,6 +20055,7 @@
                         case "proto3":
                             return registry_EDITION_PROTO3;
                         case "editions":
+                            if (proto.edition === EDITION_UNSTABLE) return maximumEdition;
                             if (proto.edition in featureDefaults) return proto.edition;
                             throw new Error(`${proto.name}: unsupported edition`);
                         default:
@@ -18790,6 +20148,12 @@
                         parent
                     });
                 }
+                function isUtf8Validated(proto, parent) {
+                    return VERIFY == resolveFeature("utf8Validation", {
+                        proto,
+                        parent
+                    });
+                }
                 function resolveFeature(name, ref) {
                     var _a, _b;
                     const featureSet = null == (_a = ref.proto.options) ? void 0 : _a.features;
@@ -19612,7 +20976,8 @@
                                     number: 10,
                                     type: 8,
                                     label: 1,
-                                    defaultValue: "false"
+                                    defaultValue: "false",
+                                    options: {}
                                 },
                                 {
                                     name: "java_generate_equals_and_hash",
@@ -19977,6 +21342,12 @@
                                             type: 14,
                                             label: 1,
                                             typeName: ".google.protobuf.Edition"
+                                        },
+                                        {
+                                            name: "removal_error",
+                                            number: 5,
+                                            type: 9,
+                                            label: 1
                                         }
                                     ]
                                 }
@@ -21186,7 +22557,7 @@
                 function timestamp_timestampMs(timestamp) {
                     return 1000 * Number(timestamp.seconds) + Math.round(timestamp.nanos / 1000000);
                 }
-                var package_namespaceObject = JSON.parse('{"UU":"@dan-uni/dan-any","rE":"1.4.4","TB":"https://github.com/ani-uni/danuni/tree/master/packages/dan-any#readme"}');
+                var package_namespaceObject = JSON.parse('{"UU":"@dan-uni/dan-any","rE":"1.4.6","TB":"https://github.com/ani-uni/danuni/tree/master/packages/dan-any#readme"}');
                 const color_pad = (s)=>s.length < 2 ? `0${s}` : s;
                 const decimalToHex = (n)=>color_pad(n.toString(16));
                 const isDarkColor = ({ r, g, b })=>0.299 * r + 0.587 * g + 0.114 * b < 0x30;
@@ -25102,7 +26473,11 @@
                     }
                     static fromBiliXML(xml, options) {
                         const parser = new XMLParser({
-                            ignoreAttributes: false
+                            ignoreAttributes: false,
+                            isArray: (_name, jpath, _isLeafNode, _isAttribute)=>{
+                                if ('i.d' === jpath) return true;
+                                return false;
+                            }
                         });
                         const oriData = parser.parse(xml);
                         const dans = oriData.i.d;