@templatical/editor 0.42.0 → 0.43.0

package/dist/cdn/chunks/htmlparser-ClUZ6waR.js.map

@@ -1 +1 @@
-{"version":3,"file":"htmlparser-ClUZ6waR.js","names":["CharCodes"],"sources":["../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/decode-codepoint.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/internal/decode-shared.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/generated/decode-data-html.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/generated/decode-data-xml.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/internal/bin-trie-flags.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/decode.js","../../../../../node_modules/.pnpm/htmlparser2@12.0.0/node_modules/htmlparser2/dist/Tokenizer.js","../../../../../node_modules/.pnpm/htmlparser2@12.0.0/node_modules/htmlparser2/dist/Parser.js"],"sourcesContent":["// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\n/**\n * C1 Unicode control character reference replacements (code points 128–159).\n * Index i gives the replacement for code point 128+i; 0 means \"no replacement\".\n */\nconst c1 = [\n    8364, 0, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 0,\n    381, 0, 0, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250,\n    339, 0, 382, 376,\n];\n/**\n * True for NUL, UTF-16 surrogates, and values past U+10FFFF.\n * @param codePoint Unicode code point to check.\n */\nfunction isInvalidCodePoint(codePoint) {\n    return (codePoint === 0 ||\n        (codePoint >= 0xd8_00 && codePoint <= 0xdf_ff) ||\n        codePoint > 0x10_ff_ff);\n}\n/**\n * Replace the given code point with U+FFFD if it is NUL (0), a surrogate, or\n * outside the valid Unicode range. Code points in the C1 controls range\n * (128–159) are remapped to their Windows-1252 equivalents, following the\n * HTML spec. All other code points are returned unchanged.\n * @param codePoint Unicode code point to convert.\n */\nexport function replaceCodePoint(codePoint) {\n    if (isInvalidCodePoint(codePoint)) {\n        return 0xff_fd;\n    }\n    if (codePoint >= 128 && codePoint <= 159) {\n        return c1[codePoint - 128] || codePoint;\n    }\n    return codePoint;\n}\n/**\n * XML numeric character references are the referenced Unicode code point.\n * Invalid values still become U+FFFD; the HTML Windows-1252 C1 remap is not\n * applied.\n * @see https://www.w3.org/TR/xml/#NT-CharRef\n * @param codePoint Unicode code point to convert.\n */\nexport function replaceCodePointXML(codePoint) {\n    return isInvalidCodePoint(codePoint) ? 0xff_fd : codePoint;\n}\n/**\n * Convert the code point of a decoded numeric entity to a string, replacing\n * invalid values.\n *\n * Fast path for plain BMP code points: [1..0x7F] and [0xA0..0xD7FF] pass\n * `replaceCodePoint` unchanged (no NUL, C1 remap, surrogate, or out-of-range\n * handling) and fit a single charCode. 0xd760 = 0xD800 (the first surrogate)\n * - 0xA0.\n * @param codePoint Unicode code point to convert.\n */\nexport function codePointToString(codePoint) {\n    return (codePoint - 1) >>> 0 < 0x7f || (codePoint - 0xa0) >>> 0 < 0xd7_60\n        ? String.fromCharCode(codePoint)\n        : String.fromCodePoint(replaceCodePoint(codePoint));\n}\n//# sourceMappingURL=decode-codepoint.js.map","/*\n * Inverse of the encoder's SAFE alphabet (0x21..0x7E minus 0x22, 0x24, 0x5C),\n * precomputed once at module load. Entries for excluded chars stay 0 but\n * are never read.\n */\nconst BASE91_INVERSE = /* #__PURE__ */ (() => {\n    const table = new Uint8Array(127);\n    let code = 0;\n    for (let char = 0x21; char <= 0x7e; char++) {\n        if (char !== 0x22 && char !== 0x24 && char !== 0x5c) {\n            table[char] = code++;\n        }\n    }\n    return table;\n})();\n/**\n * Decode a dictionary-encoded trie string back into its Uint16Array.\n *\n * Stream layout (consumed in this order):\n *   1. dict1 atoms — `dict1AtomCount` uint16 values, delta+RLE encoded.\n *   2. dict2 atoms — `atomCount - dict1AtomCount` values, delta+RLE.\n *   3. dict2 ngrams — `ngramCount - (dictSize - dict1AtomCount)` entries,\n *      each a pair of slot codes that resolve to earlier slots.\n *   4. dict1 ngrams — `dictSize - dict1AtomCount` entries, same shape.\n *   5. data — slot codes, each expanding to one or more uint16 values.\n *\n * Codes use a 91-char base (printable ASCII minus `\"`, `$`, `\\`):\n *   - char1 < dictSize  → 1-char code, slot = char1\n *   - char1 ≥ dictSize  → 2-char code, slot = dictSize + (char1 - dictSize)*91 + char2\n *\n * Slot index → token kind:\n *   [0, A)                  dict1 atoms     (1-char codes)\n *   [A, dictSize)           dict1 ngrams    (1-char codes)\n *   [dictSize, dictSize+D)  dict2 atoms     (2-char codes)\n *   [dictSize+D, end)       dict2 ngrams    (2-char codes)\n *\n * Both atom dicts decode before any ngram, and dict2 ngrams decode before\n * dict1 ngrams. So every ngram entry references slots whose contents are\n * already filled — no forward references to handle.\n *\n * This runs on library import. Flat typed arrays store each slot as either\n * a plain value (`single`, covering every atom) or a range in a shared\n * `pool` (ngrams).\n * @param input Packed trie string.\n * @param resultLength Expected number of uint16 values in the output.\n * @param atomCount Total number of distinct uint16 values in the trie.\n * @param dict1AtomCount Atoms in the 1-char range (`A` above).\n * @param ngramCount Total number of ngram entries (dict1 + dict2).\n * @param dictSize Number of 1-char code slots; the rest of `BASE - dictSize`\n *   first-byte values are 2-char codes.\n */\nexport function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCount, dictSize) {\n    const base = 91;\n    const inputLength = input.length;\n    // For 2-char codes, slot = char1 * base - twoCharBias + char2.\n    const twoCharBias = dictSize * (base - 1);\n    let pos = 0;\n    /** Read one slot code at `pos` and return its slot index, advancing pos. */\n    const readSlotCode = () => {\n        const c1 = BASE91_INVERSE[input.charCodeAt(pos++)];\n        return c1 < dictSize\n            ? c1\n            : c1 * base - twoCharBias + BASE91_INVERSE[input.charCodeAt(pos++)];\n    };\n    const dict2AtomCount = atomCount - dict1AtomCount;\n    const slotCount = atomCount + ngramCount;\n    /*\n     * Per-slot contents: atoms (always a single value) live directly in\n     * `single`; ngram slots hold -1 there and expand to\n     * `pool[start[slot] .. start[slot] + length[slot])`.\n     */\n    const single = new Int32Array(slotCount);\n    single.fill(-1, dict1AtomCount, dictSize);\n    single.fill(-1, dictSize + dict2AtomCount, slotCount);\n    const start = new Int32Array(slotCount);\n    const length = new Int32Array(slotCount);\n    /**\n     * Decode `count` ascending uint16 values from a delta+RLE stream into\n     * `single[off..off+count)`.\n     *\n     *   code < 89   → delta = code\n     *   code == 89  → run-length: next char encodes runLength-2; emit `runLength` consecutive +1 values\n     *   code == 90, next < 90  → escape: delta = 89 + next * BASE + after-next\n     *   code == 90, next == 90 → double-escape: extra char for very large deltas\n     * @param count\n     * @param off\n     */\n    function decodeDelta(count, off) {\n        let previous = 0;\n        let slot = off;\n        const end = off + count;\n        while (slot < end) {\n            const code = BASE91_INVERSE[input.charCodeAt(pos++)];\n            if (code < 89) {\n                previous += code;\n                single[slot++] = previous;\n            }\n            else if (code === 89) {\n                let runLength = BASE91_INVERSE[input.charCodeAt(pos++)] + 2;\n                while (runLength--)\n                    single[slot++] = ++previous;\n            }\n            else {\n                const next = BASE91_INVERSE[input.charCodeAt(pos++)];\n                previous +=\n                    89 +\n                        // eslint-disable-next-line unicorn/prefer-minimal-ternary -- branches read a different number of side-effecting input bytes\n                        (next < 90\n                            ? next * base + BASE91_INVERSE[input.charCodeAt(pos++)]\n                            : BASE91_INVERSE[input.charCodeAt(pos++)] * 8281 +\n                                BASE91_INVERSE[input.charCodeAt(pos++)] * base +\n                                BASE91_INVERSE[input.charCodeAt(pos++)]);\n                single[slot++] = previous;\n            }\n        }\n    }\n    // Streams 1 & 2: atoms decoded into their slot ranges.\n    decodeDelta(dict1AtomCount, 0);\n    decodeDelta(dict2AtomCount, dictSize);\n    /*\n     * Streams 3 & 4 are read in two passes: first collect every ngram's two\n     * references and derive its expanded length (each ref resolves to an earlier\n     * slot, so lengths are already known), which sizes the shared pool.\n     * Pool ranges are handed out in decode order, so the second pass fills\n     * the pool contiguously with a single write cursor.\n     */\n    const references = new Int32Array(ngramCount * 2);\n    let poolSize = 0;\n    let ngramIndex = 0;\n    /**\n     * Read `count` ngram entries (each = 2 slot-code references) for the slots\n     * starting at `startSlot`, recording references and assigning pool ranges.\n     * @param count\n     * @param startSlot\n     */\n    function readNgramReferences(count, startSlot) {\n        for (let index = 0; index < count; index++) {\n            const slot = startSlot + index;\n            const a = readSlotCode();\n            const b = readSlotCode();\n            references[ngramIndex * 2] = a;\n            references[ngramIndex * 2 + 1] = b;\n            ngramIndex += 1;\n            start[slot] = poolSize;\n            const entryLength = (single[a] < 0 ? length[a] : 1) +\n                (single[b] < 0 ? length[b] : 1);\n            length[slot] = entryLength;\n            poolSize += entryLength;\n        }\n    }\n    readNgramReferences(ngramCount - dictSize + dict1AtomCount, dictSize + dict2AtomCount);\n    readNgramReferences(dictSize - dict1AtomCount, dict1AtomCount);\n    // Second pass: concatenate each ngram's two halves into the pool.\n    const pool = new Uint16Array(poolSize);\n    let write = 0;\n    for (let index = 0; index < ngramIndex; index++) {\n        for (let half = 0; half < 2; half++) {\n            const source = references[index * 2 + half];\n            const value = single[source];\n            if (value < 0) {\n                let read = start[source];\n                const readEnd = read + length[source];\n                while (read < readEnd)\n                    pool[write++] = pool[read++];\n            }\n            else {\n                pool[write++] = value;\n            }\n        }\n    }\n    // Stream 5: data. Each code expands to its slot's stored values.\n    const out = new Uint16Array(resultLength);\n    let outIndex = 0;\n    while (pos < inputLength) {\n        let slot = BASE91_INVERSE[input.charCodeAt(pos++)];\n        if (slot >= dictSize) {\n            slot =\n                slot * base -\n                    twoCharBias +\n                    BASE91_INVERSE[input.charCodeAt(pos++)];\n        }\n        const value = single[slot];\n        if (value < 0) {\n            let read = start[slot];\n            const readEnd = read + length[slot];\n            while (read < readEnd)\n                out[outIndex++] = pool[read++];\n        }\n        else {\n            out[outIndex++] = value;\n        }\n    }\n    return out;\n}\n//# sourceMappingURL=decode-shared.js.map","// Generated using scripts/write-decode-map.ts\nimport { decodeTrieDict } from \"../internal/decode-shared.js\";\n/** Packed HTML decode trie data. */\nexport const htmlDecodeTree = /* #__PURE__ */ decodeTrieDict(\"!}.&u%}'&}*'~!6*)%&,~!J~!J~%L~y<~!R,~~%Lu~~#GD~~#|)1#%}^%}2%+#.##%##%}&%##%'#%##&%#%#'%#&#%#&#'#%%#&#%##%#)%''%&%#%#'%#%%#%%}%%%#%#&(23#%%#&-%0%('1#(##%#'##+%'*.:1}#%#6-+(%'%%#%%%}#L'2351&('%}&/N'(0(/*-%(%%}#'+&T%7.2}#&%&#%#36/5##%&%%#&#%%#))2%%##%&&'0~!#*+&'%1~!%).'3q?&%'1~!.##%6(~!+%%%(Gw'rT~!E#<nA%#jZ~!H%(~!42##~!*31&~!G%U~#)5~#`3~!J~!Z~%]~%Y~%C~!q~!u~#kz~%#~!6'~!D~!U~!?~#T~!c%~!G#'~%7|~!G~!J~!G&~#pb~(Df}#%}*&}#%##%##%##&#-}&'#'&%#.++}%mI,#,@&(}*%}*'%&##&#%##%}&0}#.},U},%}+%}&%}#%##&}B%(}(%}+%)})%##%#&}&%##%&}<%}>%#%&}*%}(%}9%}/%})%}*%}*%}?&}&%}3%}&*#%})%#%#)}#&#-#+*%E%%'%'#%}#*V##&##I}#&&##%&%#&&Qf%%))w/0+&%#(#.%-''''++++7}>%4'',##1,#%#&%##&#'##&#*#9)%&%}#*}%,#+P(%A&%#'&##wSD',9E00#y#@}(+}&%&>~!#~!X}#*}(&&}(&}(,%}%&#+&}#&}I%#%}%)#(},'%#*}4%%#%}(''}#/##(##),%-##%%)#&}(.}&%#&}%%}*&#%},&&}&%}#%*'#%})%}D&}&%}-&}6&#&}-,%}#%})-(~+`~,=?~I9'9%~!,#%})%})%}@%}?%}(~!?~#<~#pP~#BG~#=1#%K+~#?#~%;)~#A~#mF1~#A'~'X%'~#lR~#N~'N~#r~#m#-~#i'?%#'%~#B%##%,%#~#_%#0%~#]732~,w~2+#:&#%&'0%&>%}#>##F+)#%&&#(+_}4&}-%}(&}@&}O7Fdf0@+/v4}&WU##&/0#&'('B#%}.%}'+#%}#%%&#&%#%##+#&#)#6#'#.},%}c%},%#%##%&#&%#&~#>'*-.%##%##%}#%%}%'~#)D1}#%*&~#_%%'(~#S2%'.}#~#=##*'*-%}&'%'##&&~'E%.#&~#M4}%%##&'%#~#O1##%&#'+~#<B%##%%'%+~#;#@%}#&%#&&%#(~#H1}'%'##&&~#?A}&'~#D#%32}'&&&&~#[}'(#%}'~#;C})&}%%#%~#=&%,3}%'(#%%~#^'#&&)#%'~#Y%-~#d-%'~#^%%&#&&&}#~#b~2t*&'~&(~&@~0%~e~3}%*''0})&}+~!9##-}#%-hD*)1fC#%/&/fB#40~!+#)*4~!+~!K'&:~!/*7~!.#~!H~!L':~%x&~!H#~!*~%1~!I#~!+A~#p'~!F~~#-#~,,(~.Z~!V~%;'B'mq-W~!N~%I%#&&#&}#%},%%}'%}+X#%}#&}(%}'%}<%}#%}%%'}'%}:~![)9@~%>~#UA%-%##&~!C%~!-.9:~!1~!-^2/:a~!y,D*J#-5)/4~%23,~#G~!L1~!0X3`~!2+~!!0-~&E~!W~!o,>Y&]~%cZx_&~#O*9#A#'#+I'%#)~!0B*-5A+-((F&*M#)(-7-5+'-3a5Vi~!Y~!?+[)%3),ERHm~!+:D,VG.+)?fB%%*(%)'(#&80%1'8`K8?`+'Z#&O&'H5#*9)A%%5&3))0%39+.*7#()&&*=4@**L)<'_&*+..;(#*+)./&0#3)%')-8(4ixD(&.}%,('aI:,)%,k2231T)I'#/-W7,/'Q#.'Y24+h')37</31&83##&0#),H(?'&?/1##%#&&#%''-%&&&#(&''&#.-'%#%%(,')*'&#&#'##%(%(#%('#&##%%%%('%#%#%%#%#&%##h>w+v<ayvyvcg.uuhKr}g/v|g>u9i[~>g5uI~=RvdwEg;v/g;uk!!TTSx]@RT!U!#!@VBRUU!'UTe-d0c`e&gSdicedFcrdTaqb.kYcAohdYd@a3e+d}dMdtd.aJ#bqcK`dle/e.e'dwdPdodddjbEb}ogd^ofdpduc6j?l%d{drdqc)d7bacOdQ%T#Y)X.sR[yH>6Vyv3[xwLu>vo'!*.[yBacahoj>6Rew3[xqdZa#!a&#^(X-[yG>6Vyu3[xvg3sEr|g.u/Ri9db0T#^(Xa)!-[y;>6Vylg4wKs{JwNZt3@3r=c4Z([xlg;wKt!cpq's@v7A'*a(a+!-a#[y<3Dt?3Dt'>6Vym3[xmg9rxsNJwLZt4~?r?db1T#`-!(Xa,!0[yS>6Vz%NuQs.g4wKtnJwNZtS@3r>c4Z([y%g;wKtrdga8!a(!#&T*Y-Xa#!a0<or[yc3Dtq>6Vz43[y3JwNZtf@3s!Ju}!%Dti:pm3c_%X#tjB5pkd6q!r]u?voC'*-a.a2!0a&a+[yI3DtI3Ds~3DtH>6Vyw3[xx;:s#~<5pKJwNZtE@3r~d`a)!a2T#a.(!+U.X1[yT3Dt`3Dtv>6Vz&3[y&g9rxwzcxstPu.<rAJwLZtT~?r@dZa%!a.&^*Za(/Reu[ya>6Vz23[y1g3sEr}wkg{NuQRg{ci(U#5@b`~,cg#U(2WnH5wugcRh7dX#T(Y,a'Ta!!a,[yZ<]mj>6Vz,3[y+Pv#5ReZKu+=,%!H}7ABwkaS?Rh:BcW(X#<]mrj:ubv/ARekdg%!(!a.*Ta(Y.X1!#sP>Rl*Dt6[y>>6Vyo3Wf*jOvuumvuRgRJuq*!:9<B@bX~3jVv&v@s@5Re[d/rQt{uAvo&a&a*)a2!,0Wf!3Dt0=Bs'>6Re}3[xy~<5s%JwJZt1~Gs)c;&!#2sJkNuXvzq7rxu,Re8dka4!a8(aEZ+a@Y.X1Xa)[yd=Bs(3DtP>6Vz53[y4cX#X&Re:avRe9~<5s&JwJZtQ~Gs*i^rzvdRg+Jv{%!2sbB@bX}kdga,!Za?&^*T1/!a'Dt+[y6>6Vyf3Wf%g/u;s4hGu6?Rh-JvZ,!c%#&RoX54Rivj7uyvf8RgTKvZB%*!2sGh<vu5Rgq<=C::9bb~#dZ#T&Ta6Y.X*Dt>[y93Wf)coZ(T,6VyifluvRgC@95@B@bX~/hFu34cC#T,k/unq8w8Q5RkUklwQuzunq8w8Q5Rk8d/rJu?v8w9)-&!a0a;a&aIWejg3sEr/h1s<DtDJvyZqY5aws3Jvy!&Wei~Hr1:au5@Bag>23E~5c:Z&bX};kKv?w&unuVu5Rjc;>bs)#~@:Rh.=ay<a]C;b`}Vd6s/t{uAvoaxa()!a,a7%-a#a2Dt,[yF2Wo[>6Vyt3[xuNuPRi&NuPwpi#RoWh?vf8Ri%Jv]!%Ri:KvxD!.'2WeAjZu`q9rxu,Re7woeAg-unLq(qA_/*2Wg_g3u5q^9:4E}/jTrxrzv=Wkkd~0UX#^^Xa-a1a5T&a=U1a'*aEa]!a*aPaA-adok[y54Rn>;:p3~Dp5g9rpsFNvZqjg3uJp4~<5p0Pw;5qlJwNZt*@3p1Pw:5p/Ou!5p2JvG'!6Vye=<qnJvh_[xhg3v,Rh3kOwOw-sDuev/Re^dha[a%!%!a+#Ta7)-5TaCaO!aka!a)sf[yb2>Rl!9ARiq5E}Qg=ucRkBE|oJrJ_@Wk~@Wk{JrJ_@Wk|@WkyJrJ_@Wk}@WkzJvO_[y2g-vMRmiKuYC!)&>Ri;>Ri<@3RkNc](X#@9Rk=g5vuRmhKvDB!+'=]meg3u4Rmgd)#Y'Vz3CARmfd`a+!%T'!+#Ta1Ta6TaM-sTDt9[yA9sYd'%Y#s[[xpj:ueunaXRgEjRq,v-vuqdd2'`#6Rev<32@5>:2<E}5xIo9a*X#Y(;5RePJvD_g>vyRgNj8w)v8<wggs:RgXiZt|vjx,hSq3ah!-(~@:Ro/Ou!5RhWj^v(pyw8unRhUdx-UY#^Ua.a3a70!)%UX1TaDa)'omRiRRhE[y:3Dsz=Br,>6Vyj3[xkg6ruwjcqsrPw;5r*Ku]D'Zt-@3r(~?r.i[vwv]dU1a--U#`a4(g/vsRhPOu!5RhLj:rmu9Wo!~@:wdh@g/vsRiTjXuvvNr}:RhBj^v(pyw8unRn]dz1UYa'a+^Y(!aETZalaRY.Ta?a4[yDJw1!#qLsW>6Vyrfzq-pLflpwRe|Js>%!Dt@3Dt&Jvy_[xs~HrnjMuwpsw'RecKu+D#'!t<~Grl~?rjg5u-x,gwp{ah!-(~@:Rg~Ou!5Rh'jXuvvNr}:Rh#cW#X/c;&!#2sLi[v7u7RgpJv)(!iLrxu,Re6j7v@s@5Se[e7d`aW!Za(a`T.a#!a3!&aDa-!9)Dt_=6s+3[x~~DR|h~DS6avhGun5RkZj3w)v-]mkKunB!&*]kb97R|i<ARk<c:Z(6Vy}Juh'!wziMRoS:F|vkLuauJv5vtvQRh1d='T+Y#VyO~DR|jcF#T'7R|g97R|kJv3'!ay<Rj,Jvh&!:ReXcsa6*a+#a#_aIRf9aLRf?c,Z&Rf5Rf7c.Z&Rf;Rf>cQ#%T'p-Rf8Rf=ct#%'(*!,p,Rf4p+Rf6Rf:Rf<d~'Ua%U*^UYa(!a,-!#a4YaTalaEX0a8a<Weo3Dt/3Dsx=Br93Wen~Dr;~<5p<JwNZt2@3p=Pw:5p;Ou!5r3c7&!#:p>3Ds}KvGB)_6Vyk2sM=<r7x'eovA(!hFu1ARf}cV#X&@r5j6rvwQa^Rf3c=Za'wkghJv__g;unRggA53B9=b^}%j6uduo5Jq;!(hIv%2Re`Ou4ARe_e%a#^^^Xa&!a*a2!&a6YaP!*ad!#a:aE/5Rn?[y@>6Vyp;:pE~DrY~<5pBJwNZt8@3pCh=rt3rWPw:5pAJup_[xoNuPpF9c!#'45pD5ARn)d8#X'X*3@rU72s]h>v<<sSjJpqvewOJq/(!hNw'5ReBk0s2u3w/w'5ReE5@Jq.!a+JQ!&WeU23d(#Y&RjG5]jBk!u7w&u0udARjEe#+^^^Ub#!a2/a`Z(agT1!a-a;|@TaG!aS[yV=Re~fow'RguNuPRe?bz#'>RoUWeL>:Cbb|?JwPZtVg6ruRmzJvD'!6Vz(g/vmRh~Jvy_[y(g9voRgyx*cy(#2>Ri2B9b]~9kIw9u7rluJu3Rg]dI#a%UY'@=p%CAx.gQZ&RhwwygtRm{x5g_Z'+ABqR9Woa=Bp&dV#^*Xa'!&@o{g4v]Rk;Jv{!%Rk[wkkiA5RkiwwfUB=x,fUuqC&*!>RfTg8v0RfV~ARfSd;rJsAuAv9wR'ae+/aO!a@aza/a#[yQ@Wg!2Wemg3sEr0JvB_g>uvReWg2v+Re=KupB_+[y!2AbY~-~Hr2AJwD!(h<~El>h<~El?Kun@+_:9b`}Kg-v/Ri3g;vtwyk_9]k_d=&T#*U.6qh@Ab`|K9:H|CJv[!&3Dtex'fDwC%!Rf[9WlMd[(^X,!a%Z06Vz!@WgBg=v~Rgvg,QRe@awd,#Y+jTv|Q~EfWj]uNr|~FRfXdy#Y&^Ua%!aO.!(a)Ua;=!a@aKap!a-,a!Ta]a[rSa]p?[y82sK=Bq~;:p:~<5p8Pw:5p7d'#Y'Wf(;RnRi[u4w&RgJJvG'!6Vyh=<r#ijuuv/sIKuYD'ZtG@3p9~Gr&d2#`(g<vtRgFj`u5w&rqpxRf2CJuY!+:wfnTOu!5Rg}jNs1ucv&RfwJvA!&3@q|BDcC#T,k/unq8w8Q5RkTklwQuzunq8w8Q5Rk9dga#!a'!a=#a0!:+Tb*b@aO.a4!aba8aFJv^}?!VyR~Dr<g;u%Rn.~<5p[x'e`wNZtR@3p]Pw:5pZhNvjBp.woe_g5u-r4JwF!%DtO3:ooc7&!#:p^3DtpLuGw(!+%)Dtk6Vz#2sd=<r8d'#Y([y#<x3gJt`w@!)%}MRiowzikRij=]ilxAf3,U(#B2Rf#g0v-Rm[ck{`U#]giKv3>)!&6Ri154s,KuGB_%@r68r:dJ|t`#X(9<E|u2@H|rx3gJu?w'!+'1Nu7Reg4=H~+9<wxgY95Rm]xLggZ-`(X}U2:Ri4h<uOawRmsJv__5@bb{jbV~3dka#a'a]!,#a+U=a>b6a3b%!/aKa/)!arwve^VyJ;:pR~DpTg3uJpS~<5pOPw;5qmPw:5pNOu!5pQJvG'!6Vyx=<qoJvA!{~Jup!%@qk7Rn/KvyD!}''[xz;>wkh'?Rh,x8gyt`w5D!&),(SgyccRgztJ@3pPB5p#d'(Y#<]mmifubw&RgoJvE&!82s^JvF&!8Rf,ADb]~;x=h'rNu]vK!,%'*0RnORh)4Rh*AqQg-vaRnNg;wHwkh'ba~4cE#Ta*x3gctyw@'!+%RnFRnD<4Rn@hFvK5RnCxWg[#`&a0Ua()`1Rm75Rg[c]%X#qi8Rg^NvdRj>BwzgZauwji7Rm6A4wgg]d1#&(*,.0a#Rm;Rm<Rm=Rm>Rm?Rm@RmARmBe%#^^^Xaea?aC/b+(,!a+a#!a/!>a&Ta<aKbD!2wphBRnk[yPw}hE|.=Br-3Dtm>6Vy~g6urRf.x,hPrNav!%'RnqRo%Ro#Nu;q[Pw;5r+JwNZtM@3r)d'#Y'Weh;xChL#`&RnmRnoKu}>%(!Rne~Bs-;2wjcussJv+'!aYSO}6@B<5?ba~8LrNvj!.%*ROwungw~ng~:9;Ri^>wtnig;wHRnixDh@|(UZ.x1h@|)!#:2<H|*xHn]#-UX'3Ro)z=iT}6ARns=Bwsn_wpnaRncw]aR(#UXa&Ua*a/=]iPd'#Y&Ro'WnXf{QRm2hNvj]nZd`'T~&1`{|`#9b]{}c:'!#Wl{>@=be}]?cl{{U#:5Abb}Jds#^YaF!a*b4a#a3aPa>&Tb!bH!*a_!Eau?/a&RjY<]gj>6Vz*;:pe~DrZg,QRj1JwNZtX@wihspcJvZ&!VyX9WmOJu|!|N2WmHJvh&!]ht~Bpbcn&T(!#RmQ<s7Nu;padH#X'`+WmJ@>RmKCARhnKup=!)&Wf+:RhqNuPpf9c!#'45pd5AwghpARn(Ls@w!%,)!RmP@Wfe<E|IJva!&WmNg8vsRmLd`*.`#Y'Xa!axRn*]hrA8Rhug5s@rXg8u!RmMd8#X'X*3@rV72smdI*#UY&RmICARho~GsgxVgd)Ta'U-Y&Xa!T#RnEWnA@Wffg1uDRi0hFvK5RnBxGnG&#`%owp)@wsf+bX}Ze-*1!a*^^^Ua|!#a.aq&Ya2!a>.a6!a:aO`aJDtL[y`@Wg#>6Vz12@wzoYRoZNuPRi!NuPRhzg=ucRi,@=b`{Yg=ucRi-ACJvB!&Sh[ebSh]ebi`wUuFRm4Jw2_[y0JvB!.<Ju(!&SoG}6Shd}6<Ju(!&SoH}6She}6Kur@._g5vHRieJvx!{L2G{Kx6gd'T#?Rh82Wi5cZ#X(g1w)Rm5dW-Y(Ta#!a)!#aYa=wnfE=su2>>bU{0j9udv:<svj8uQv-7RgHdE%#^'sq9sp=>Bb_{TJv`!&g/r|snj6v(us5d,#Y(56H}[978H}]Jw5!&g1rushJvB!+j;v{u5?zDhd}6}bj;v{u5?zDhe}6}ce*#`(^^^a[aea!=!a6a*aoXb1a.!aAbL!b>,b'aL!aV@Wf|2Wlg3[y/JwNZt^@3piPw:5pgJunZou3@rsJva&!Vy_g<v~Rm#JvG'!6Vz0=<r{Ju{%!:pj@WfsiXuJu3Rm:JvZ&!WfA~Bph@c4Z&Dtwax5rubx(#:awRk1@d,#Y&RfjRfid1#,Y(@Wfp2Wlrg5s@ryKu[@!,'=]ig9wlk?Rk>g5u-rqJvy'!@9RkQcH(T#=>Ri~@<wkj(Wj(KuZB*!&<7rw@9RkRcH(T#=>Ri}@<wkj)Wj)dg(Ta2Xa9X#`-!a*CARhg@@=I}d9x;c~#X%so=<sj>2@@=aybb}XjWv0Q~EfEj3vLv;<d,#Y(56H}`978H}_dgaPaFa'a/!#a3Y0a_a;a|!1(a7-[yE3[xt;:pJNvZrrg3uJrvJwNZt=@3pIh=rt3rxPw:5pGOu!5rpJvG'!6Vys=<rz@c4Z&Dt(ax5rtJvZ!&~BpH@wsfNg-vaRlNci*U#=<wei<F}a5@Jq.!a*JQ!%@qZ23d(#Y&RjH5]jCk!u7w&u0udARjFd/prq=tyvpaEa(a:.!a1aZ(@@=I}:9wpd%=<sX55w_h}@@=I{t=ay<aU@@=I}T=ay<2@@=I})?C9:9au@9Cb]}DP~=x-fAZ(2Wl1=ay<aU@@=I}>5@d##Y+jTv|vV~EfFj]uNpn~FRfGdgaK!Z2&!a8a-Tb({E!acTbM*!a(DtY[yYd'%Y#sl[y*hHvh>Re5x2c{Z}.j4uCvcawRiMd+#X+_x&d!},<5RkX;2Hzw@x,gavfB-!{CcF&T#Roe;RodwWbBg5urRgaKvHC*_6Vz+<4opieuew&Rmq@d]&Y)X,T#X0Rh}<BqP=4qS9:ReMg/ujReNJw0!/<Jui%!bd{kawwnemRelAxUa?a3#*.&UX(Ya+a/RhvRnQ<o}9Wmtd-#Y&RgSRmw9;Rmxay=Rmyg-vaRmuxEhSrNu,v-voC!%(aR.a(a7+1Ro1>Ro5CE{A9b]{@;5x#eO{:g;urRi+KrNA!%(Ro3>Ro79;Ri_Ku@>{;&!x%gX|{KunA_+g5QRj/g3u5Rj#g>uERj%wio/xRhS&!,!#^1U}wba{8>>@=be}qC@:D5ba{7Ku+A&!}x?ba}t>>@=be}se(aA^^^Uat!b0#{pa+awUazbGa#aLb9bgaWac'a5TbS=Br!d1#`%scp_Jvl!#rT>Re0JvX&!VyN=H{Fcm#U&:pY=ReaJv2&!]h0=]nUJvG'!6Vy|=<r%JrM_=]h2@Wlud'#)U'Wf'b]{i=]h/Jvh!&~BpWg=v]RnMx+ny#'Nu;pVwjnu=]nwxJnx,T#`&Reqwjnt=]nvieu9vrRjLLuYwP(#+!th@wih5pX~Gr'g5v/Rh4KunA'!-CARnP@wwiN:Rm_9x'cvw>!|l=<saKvAA!0&3@q}>w^e1bp#&Re2Re3BDx7gH#T|f5H|eKuZ>!%(:qNAH{]Jv6!+3B2B9=b^{X<5<B92:E{ZLvhwA(a;a%!igQuyRmad+#Y}m@3Rh5d8#X'X*:AqUAHzmaxwbh<aXRnVcF}RT#Nw&cj#U(BWnug/vsRntdka)(a3+.Zb7aYYan1!bVa@Xa}[y^@b[{G=H{+hFu73Rj&Pv#5ReQcK%T#sig1v{Rj'Ku+D#'!t]~Grm~?rkKuMB!01d5#`'Vy.ta3Dtu~Hroc8#'{^45s85AwZbP&!#Rn!wghxWn#KvEA!)&2RlA2RlBx:h|#(T,=]j09Wobz>x]z/@awRoTd+#Y(az]hFhCrm4d,#Y+jTv|Q~EfMj]uNr|~FRfOdCa!Xa9_X#@<plJvf!%b`{(9;Rgwc;.!#2x7cw#T|UDb]|T5Ju={(!=@E{&Jv)&!Ab`{'awJvf!~*>>@=be{#KuY>!+&4Ezyi[ugv&RjIdea+T)#UXa&T-T&a!Rh9auRmW=]kLg5vuRn+g3u4Rn-Ow6ARn,hHus5xNk?#UX(U~)/g8v0RkD~AwkkF?Ri.OuNBwkkA?Ri/d|a2`a*^UYa.!aBTZaTa'Xa;!(!2!-a#b2[yC>6Vyq3[xr2Wi?g1rusVh%s?DtF~<5rbJs;%!DtBfswKtCj[uvuSsEu3RgVx3o:u+wN'*Zt;@3rd~Grh~?rfg8w)Lq)qE&-a%!>bI|`jWv0vV~EfCjTv|vV~Ef@j]uNpn~FRfBcK#T']gWNu7x,k7q4ai(0!hHv8<RhmkMu9vrsBuev/RhlCJvB!,g<v{wchh~@:Rhji[vrv{wchi~@:RhkdS&a5UY#Ta!RgPwwiI5BwciI~@:Rh`x'iJvj'!5]iJPu8Bwch]~@:Rhach)U#h3rp]gLh@t|Ax,hTq3ah!-(~@:Ro0Ou!5RhXj^v(pyw8unRhVd|)`,^UYas!a?/a2Z'a^Ta{Tb7Ta(a#!a,Wf&9sZ3DtAadamov=Bqt3[xig8vsRm~>waiL2b`{QJv*_Ouv2qgj<v]v2BqfdR'X*X#Y-@3qr~Gqv~?p6hHv-]glPup5Lq+q?_%*b_{qF{n9b^{rOu4ARhpKvCD!+&~Bqp:5Dbb}nwoiKl&unuTuBv]v+ueunaXRf0=Jvh!0nKufu8v1w&w7q%w&uHrz:Rgnj5w,uxDJq/(!hNw'5ReCk0s2u3w/w'5ReFd>Za&!*UaA=<wkgsRnSJv^!%Refifw3vyRgOKu_B'!,<]gkiiu:w&Rh<=C@a^<B57@2F{[<B5@aW:=3away9A5aW=<B=C@a^<B57@2F{Ie-#`(^^^bCara.b8aza6!/bZ,!adTbnTbOb+aFaS!aAT9@Wf~2Wli3Dtl2@d,#Y&RfnRfmJwJZtN~GqyJva&!VyMg<v~Rm%iXuJu3Rm9Jv[_=]ih9wlkDRkCd1#`(@Wg>2Wls3cH#T(@<Rj*=>Ri|b~'#23s9h<~El.d'#Y&Dtxi^rzvdRl#d*#U%(o|B2s`hJwSaxRmDKv4B&!1:Rmdd5#`'Vx}to~Hq{x'f1v3(!BA5ba|bJv_&!Wfug1v]ReIdO+U/Y#&G}-8wze=Rh{g1v]ReHg/uQRf/by#)ibQwERl/cH#T(@<Rj+=>Ri{cNu+vlax-!(#a0qa9<Rii2;;bU{H;x<i=&X#Rk`<4wwi=C9H~8xAI(Y#<azRi@45wXI<B9;5bb~7dL(X#Xa(+!aL6Vy{g5QqOau:5au2@ay547EzbxOcU(UX-T#Ta#:Cbb|A?wjh/b_|SOw6ARgtihr}u7Rhy<d1#T)X1@@=I|~=ay<2@@=aybb}Sj3vLv;<d,#Y(56H}A978H}@dGpvs@uAu`vcw9*!aFa+ai%(b!aXa8.a?a[ozWey=sU2@G}Nch&U#Rf_WexKu+D#'!t:~Gr`~?r^j]uNr|~FRg*j^psurwJt|RmcKv)@&!)7Rkv~Br[@wxfO:Rl3co#U'6Rezj_q#vIuavjRltwzeyh@vr5JqD0!>aY?C9:9au@9Cb]}9cl#U*5;5<H||jbuus1ucv&Rfvg1v~d/pppzqFr^a--a~!aMat1(hFv;Wiz@@=Izoj5uuv-7Rix~Cw`fk2WlVcZ#X,k)u3vWs@u2]ktg;wEx'fBq(_2Wg/jTv|vV~EfoJv]!15x'hzqG!(P~EfU~CRl_j6v(us5x4i-#T(2WmZ?C2F|d>Kq<aj1!*jTqIsBv=Wl`~Cw`fi2WlWj`v0u*~>RlR=c>Z,k#u3vWs@u2]kr<c1Z+jTqIsBv=Wla~Cw`fm2WlXdmb3!a{(arZa`bkTa%TbQTa-a9+c'!aM!/[yL=Bqug.w'RifhFvyDRj.g>vgwyk^9]k^Jv3_@WfbAARkhJw2_[x|JvB_wkoIRoKwkoJRoLd'(Y#<]gm=<9<H|yd'%_X#skDtb3awwqkgNulRkgdB#^',9:p'hJwSaxRmEBwVb8@4=H|qLu+w50&!)@3qs~?pU>Awwn;;Rn=c:Z'ARn<=<qwKvC@!/&~BqqJv6!&]eVb^z^xRge'/a%+^`#Sge}6<4Rn3=]n0Pw2>Rn8Jw0!&>Rn:>Rn6cY#a7+!a&=<wkaNw~h3z_c5Z{=wjh#=]nLKv^D!&)Vyz=bW|swYb<WetcG#T(2wxa@qVx@gD#Y&b^|V5JwG&!5bb|pg/w&RgD@x=kHs=uAvn!a%%/'+RmSRh694Ro`g-vaRmRhHv-]mlxCcS#`&ba~.5cD#Ta)P~=d,#Y(56H{>978H{Dd_#{2^Y%_+qbbb{6g3sERhsbU{?dfa.,`a(Xa<!aiX#(55RiG54RiHcI#T'WiU3RiVNvdwtfcRlKNvdd,#Y&RlHRlExQgf.1*^T'X#Sgf}6Wn4=]hfPrk>Rn7Jw0!&>Rn5>Rn9Lunw?&a2!,5<oq@@wqfdRlJj5Q~=d,#Y(~ARfcOuN]fdDKw;ay(}i!547E}j?cI#T(@5bV}iCbV}hdv(^^Tb?a40,b##Tbo!a*bR!a<b|a/!aKai!aU[yK=]o^g:v>ReGJwPZtK<7Rh+h<~El,Pv#5ReR@awwxjCg,ulRjDJv6&!]j!z?aQeeg>w=Sh<eeJw;!&axEzOg,Qosc!#*:wkeJ]eJ>x'h-u(!%Ro.w~h.zPdNZ(X,Ya![x{;9ReY;wkgxRiF:x?ap#Y&RmUg<s2Rkod]+UY0TZ'!a&A9sw<=bczLNvuw{gqzNhJwSaxRmCKuLay!#&s_Rf-55b^{uJvZa!!c%#(55Ri654wmiu5RiuawLu,vp!+}^%b_}Y9;wkgxba}o>A9:=b^}zKuh=a''!3awRk3c*'!#aHRk6c+Z&Rk5Rk4Jv)&!awRjSawd9*`#0?C2@EzMj8u<uJ5RmbjQrquJu3x,k>uq@_+=ayb^|W~ARkEOuN]k@7dhzV^X/X&a-#zRzSb`zXcJzTT#2WkVKvDBzW!%FzY9;5bbzWjQrquJu3Jw3%!b`zU=ayb^zQd:#X(T-a!6Vyywxh}=b]{Jg=u1RiAdGp~qHtzv!w(wA+a+a;<!aJaYai'anasb(=azRmV:Cbb{MLq2vb!%')RjuRjrRjtRjqx3jnqCw3!%')Rk(Rk+Rk&Rk)Lq2vb!%')Rj{RjxRjzRjwLq2vb!%')RjsRjpRjfRjex3jcqCw3!%')Rk'Rk*RjkRjl9<CbbzfOu4ARhxLq2vb!%')RjyRjvRjhRjgx=joq*uKvb!%')+-Rk.Rk%Rj~Rk-Rk#Rj}x=jdq*uKvb!%')+-Rk,Rk!Rj|RjmRjjRjidAq&qKs@uAv8Aa.'*-a@a&0!aM@a5[y73Dsy3Ds|3Dt):wxgI2sHJwJZt.~Gqxwsf0ikrzt}Rl0Jvy_[xj~HqzKv_A|D!&WfP8axRoVcf,U#k(v]v+ueunaXRf1Ju}'!g8u#Ri=jQw!sCunLprq>!,')~<5qeGzq9F{W=c##%s5au:5aU3CBE|;d4#X(D!a&6Vygx(b;#(=]ed?C2F{N<capoq2r[a&!aPa9,'Pw;5s:@@=I|,55w_h|@@=IzcP~=x'fCqB_2Wl2>aU@@=I|1OuNBc1Z+jTqIsBv=Wlc~Cw`fl2WlZ~AcTa%!Z+jTqIsBv=Wlb~Cw`fh2WlYk+uNqJsBv=WlSg,u3dca3#UXaMYa)TaB-=cM|7T#<bI}l5@B932:aV2G{BOuNBJq:|M!5Ezt=<B=C@a^<B57@2F{v>cB{/T#=ay<bI{3Jv6!a.6BKq0ah&+!5E}HP~Ef{978BaU@@=Iza<7d#.Y#978BaU@@=IzH~AJq0!(@@=IzG978BaU@@=IzFe,aU*Y&^^^bvJb,b:bFad!a,c2Ta>aL.bo6!a#CbTa'T#Re{2Wlh2@G{yg6t~Ro_NvdRfticuRQRllJv3&!x&c|zs@Jw3!%RflwpfkRlpKuL;%(!Re<@G|C2GzdhIvuBwgjAg-u0RjAKQB%!(GzZ@G|5NuuRl7d='T+Y#Vy[g<v~Rm!==G|>JvA!)@wma=]m1ifuaw&RmnLs@vT'!|/+[y,g:v>ReTJw1!#qX=x!eC{bLu+wT&)ZtZauq_~Graci&U#F|89:r_Lupvq!.)&2RlG8RfaC=x!eF{_h?rpWlmd&'!#X|&]k::xJey#`'T|+<E|&2@H|%dE#(^,g;u.RiEg6vjRiC9xCkA{O|zY#g=ucRmXKs0@!&*@G|m@awRknJuh!,3d(}gY}eJvj!%Rm):Jw3!%Rm+Rm-Ls0w(&!a(a#@b[|6cZ#X'7RkxWgAOu4ARn'dH'U#Y*Vz-Wm'CARm}d]*#a%^a*T'aK!a<9bV{PC=p*Jw4!&SgxcbB5r]idw(wBRmF7xFkt#&`(Rm/Rm8E|!JuY_9:Rl5=wrgr2:bbxd@xXfB(a*#T+!.X0X1Ta/a'T&RlDRfL>RlyARl9b[z[>RfZ:RlL:RfRwlg/ARl;9;RlxKv,A/!%7s69<74=BA5ba{-8Bde#`a<XaKYa1,a'P~=wxfB2bZ}}?C972@@=I}r8@55B9;5bb}G978B2@@=aybb}3j3vLv;<Jw3&!>Rfk=ayb^}4~Ad1#`*@@=aybb{w2@>==<bbz]dx+UY#^UaF!a9!bB'Ya1.!ajXa#%olRhD[y=3Dt#Ov5BrHKuMB%!(Rf^Wep~HrJwkiQjKr|~FRg)Ku+D#'!t5~GrF~?rDdV)UY,Z/_7RkuG{<~BrBg,rlsO:235B@bX}|d?a1!#`(6Vyn5@d##Y+jTv|vV~EfIj]uNpn~FRfH7Lq2vb1!a9-978BaU@@=Iz9978BbU}#~AJq0!(@@=Iz8978BaU@@=Iz7~AJQ|}!978BbU}!JvkaK!AdUa21-U#`a+(g/vsRn~Ou!5RPj:rmu9WhOjXuvvNr}:RhAj^v(pyw8unRn[kPr}p|u7vwv]RiSBd;pppzq@qHQa?(b.!a.a`@.|xa(hFv;Wiyj5uuv-7Riw~Cw`fg2WlU978BbU|wOuNBJqG!(P~EfD~CRlQcZ#X,k)u3vWs@u2]ksg;wEx'f@q1_2Wg.j]uNpn~FRfqJv]!15x'h{qG!(@@=IzK~CRl^j6v(us5x4i,#T(2WmY?C2F{1>Kq<aj1!*jTqIsBv=Wld~Cw`fj2Wl[j`v0u*~>RlT=c>Z,k#u3vWs@u2]kq<c1Z+jTqIsBv=Wle~Cw`fn2Wl]dn1#c(a(b^a2!b/bAT(bj!aDa7bu,a_a{c0!2T0g:v>ReD2@G{42@G{5~DpM~<5rc=Bx6i>{RT#RnI@zCx]y]z:2Jv[!zr5Awyk]9]k]dD(Y+X#6Vz.g=wKtgwhaCwgmTWj2Lu,w%_+/[y-B;b^xeg3u3Rj-2@bX{*KrJ<!+'@Wg(g?QRlC@Jv`!%b[zIwsfII}8JQ_@w|kW|=Jv(%!AqcOuNBJvEzh!bYzjLs@wP#(0!oy@>RkdJwMZtc3Dtd@BcG#T'9bWxg2@2Fznd*#Y+;2x'c}w<zizixNgwa#Z'U+!/!a'!a+w~g~z6wcn{Rn}wcnzRn|5Rh%=]nJg5vuRmvNvdRlvcprJu}w*az*a#!%.a.'Bot9qT]kj@Wg'ay2Gzv@Jv`!%b[zEwsfHI}1;ck#Ux`<Cbbx_Lu+w!a&0*!wko*wwo,So,}6Juqxf!E}PigQuyRm`d3(`#8>Rn%:A5B;bZ~%KvhCa!a2!x>k7#Uxb@b{#xaRk7Jw0!)>wwhlShl}6>wwhmShm}6CJvB!.x'hhvj{!!5Bwkhhbaz}x'hivjz~!5Bwkhibaz|xEhTrNu,v-vpD!a%&/)a3a.,%Ro2t[CE{)@3re9b]{%wjo09:rgc:Z&Ro6=<riifuaw&RmoKrNA!%(Ro4>Ro89;Ri`dSaL'UYzxZb)7Rka3xRhT&!,!#^1U}vbaz{>>@=be}yC@:D5bazzKu+A&!}{?ba}y>>@=be}wxBh[t`u~vJvr!%a!a()a,a0a4RoC=]o;Ju(!%RoGRhdwjh`=]oAg>w#Ro?g5vuRo=NvdRl|Ku]C.!&;RoEJvB!%RoORoMBx'h[v+_?w~h`}~5?w~hd~!xKh]oiptu-utv.vp!#%&a30a@a'a+(a/aOp(o~p!RoDJu(!%RoHRhewjha=]oBNvdRl}g>w#Ro@g5vuRo>c[#X']o<CauRoRAd-#Y':RkpauRoQKu]C.!&;RoFJvB!%RoNRoPBx'h]v+_?w~ha}t5?w~he}ue!/UbhYacXaW^Tc&a;b:a-c/#b&aja1(!cL+!bKbt!bmcRc9aIc?8[yW3Dtt94Rg`Jv}!&SiRMzBhEebShEMNuPRe>x7gL#TzuwjirRipc<Z&>on;>z=h-MSh.Mwqczx'a7vj&!>Re4@=ResJt__NuPRi*NuPRi)j]uNr|~FRfzKrJ>_+@Wfy@Wf]2WocKrJ<!+'@Wg%g/QRl@@Jv`!&awRl<wsfFIzgLu(w*!.*&ShBMwvhIRhI9;RhNx1hK'!#Sn]Mx1hK~0!#:2<H~7cNu+w7D*'1ZtW>Rn1~?rOc:Z&Rn2=<rQ<7wjh&=BSnLMc]#X(6Vz)w[b=a!U#9wzgMc3#&(RgMRitRis<x,gKt`ax!&+SioM=BSilMc3#&(RgKRinRimKurB,!&SiQMzBhDebShDM6BJQ!(P~Efx978B2@@=I}WLrJw!!,a*&@G}O@9wkibRid@@x'fKwC!&SlDMSfLMjUv~Q~EfKKv3@a+!(hFv-]mpx/hYZ(C5RiWz<o/MwkhY?So/M@x,gbvfB*&!SgEM:SoeeehFu3:Rgbda(,^TZa)X/7Sg[eb:2RgI~BrMC@wgkc:wwkcRerx3h(uUvK!&*,SnOM4Sh*MArRg;wHRh(x=h;rJvPwI!a4',a'0@Wg&=BSh/Mg>w=Rh=g3w*wwgGRgGcW(X#;Sg}M2Gzk@Jv`!&awRl=wsfGIz`dKZ*T'Y-:RhR7RhQg5u-p`j6v(us5d,#Y+~Awkia?RicOuNBwkibba}Ld6p~tyu_vbAa'a+!a/'a3aEa8a!>Sh,ebJv{!&Sh@ebSaReb9;SgwebNuPRi(NvdRl)NuPRi'hHu^<Rm^Jvv_@Wl(g;u1Si/ebKu'B&!*Sh?eb@Wl'z@aPeb95Si.ebcpputyvjB)!,&a+0a%ShAMWeK@G}C@WfJ9;RhMwvhH9w{ia}ix,hJvRA1(!zAn[MRhHx1hJ~*!#hFv(BSn[MBJQ!(@@=I~'978B2@@=I}2db.Ua<'X}+T#a0XaG2G}E;wkg|wuh!Rh!x,hZu,@)!&So0MVy)C5RiXACJvB!&5RiY5RiZg8w)cG}*T#2@bU}=KsA>(!a.3wkhZba~(x,h^u(A!&(SoCMRhb5Bz=h[eb?w~hb~6x,h_u(A!&(SoDMRhc5Bz=h]eb?w~hc~6e)aA1T#T,^^^c-bMb&blcPaP(a/!0!bA=b5c@a(!bfbrc#2afwmhARnjwchORnp2Wlf3DtsNvdRl-2@wpa<]m0bx(#:awRk2@Jw3!%RfhwpfgRlnKQB%!(G{V@G|'NuuRl6d='T+Y#VyUg<v~Rl~==G|<Jv+'!aYShC}6@B<5?ba~8@Jw3'!g2QRljhLrpWlOd+#Y'g.w'rIg>w*wgj@g-u0Rj@Lu+wT&)ZtUauq]~GrGci&U#F|39:rELrNvj!.%*RhCwunfw~nf~:9;Ri]>wtnhg;wHRnhx3hDs@v~!/+'@Wfr@9RkSNu&Rlo=@<5GzoKs0@_+@Wl+@awRkmJuh!-3d(}pY#qWJvj!%Rm(:Jw3!%Rm,Rm*de&!1U-U#`)Re;@G|.@9Ri82@wjfvRlq=@<5GzpLvOvr!).&2RlF8Rf`C=x!eE{.Jw3_g2QRlkhLrpWlPde(!#U{s,UXa*Ta'[y'g:v>ReS;x0PZ&RnlRnn~HrKJw1}f!=x!eB|2w]aP(#Xa&a*Ta.Ua2a7=]iOd'#Y&Ro&WnWg;u.RiDg6vjRiBNvdRlzhNvj]nYJuW_2Wm3x)kFze{9d])!a.!,Y01!#&aC!a3RndC=ox~BrC@2b^{pg,rlse7x'ksuq!%Rm.E{xidw(wBRmGx9o+)X#wwo-So-}69:Rl4@xSf@a#XZ'X)X,Ta(/ARl8b[xc>RfY:RlI:RfQwlg.ARl:9;Rlwdn'#^XafaQa1X1TaHTa)@b[{zcZ#X'7RkwWg@Ou4ARn&x)kG#{,g7u/RkGdH'U#Y*Vz'Wm&CARm|bx#(A]gUbUzJj9Q~=d,#Y(56H}l978H{U7d,0#U*2>ABb_xZ978BbU{e~AJQ{g!978BbU{hxMh?ad{oUYZ.x1h?{l!#:2<H{mx3n[t{vl!,&a%3Ro(z=iS}6ARnr=Bwsn^wvn`Rnbd`*T}B0!#^X'BG{c9b]{a>>@=be}F?JvS!&BG{d7BG}(Bde#`a1X,Ya@!a'P~=wxf@2bZ}I56B2@@=aybb}08@55B9;5bb}<j3vLv;<Jw3&!>Rfg=ayb^}&OuNBKuLA!)a!P~=x#fD{f2@>==<bbzl?C972@@=Ix^d6rSu,v7w*C(0a)a6#B+a%!sQ[y?3Dt%3[xn~<5rLOu!5p@Ku+D#'!t7~GrP~?rNKvlaya7'!h+v-5qMg=t|cd,U#5AAaa5Abb{S@52B5@a[@52B5Gx[iXueu;d<#`a(!/549C;ag>23ExY5@Dah89b^~689Jv)!~2b[~1Lv'w(%*!a#bX|aPrmawRe]keu7uhv-q6rxu,q`xTo]/a5aU!bNaDXbi!b-!ao!b<bwA!#5@B932:aV2G|:d-)Y#hJrL>RhG<7@C5<H|_=Cau:5aj5@B932:bJ|ng>vIbs)#?C2F|9jPv0w.vISh-MKvUaz(.!9ABbb|[5;5<H|Eg>unwfh;9:4E|YjQsBt|vjx'hYq3!(?C2F|J:2<BaY?C2F|GOu!5x,g|p{ah!-(?C2F|c9:4E|OjXuvvNr}:Rh&i[w*t|cd+U#jJvsu)vsSn~Mkfrmu9p}u7vwv]So!McW#Xa!ax5@A5aY:5;5<H|>kJv~vYrquJu3x4ib#T)2@SmZM?C2F|Bj:rmu9@xPhI(a*a#U#`a3-5Abb|L~@:RhK9:4E|0@52B5G|#C::aY?C2F|-:2<BaY?C2F|.5Jvk!a)javYrquJu3x4ia#T)2@SmYM?C2F|HAxPhH(!a#U#`a*-5Abb|4~@:RhJ9:4E|R@52B5G|F:2<BaY?C2F|Sc^#Xa2j=Qq5CJvB!-g<v{z;hhM?C2F|Zi[vrv{z;hiM?C2F|XKsA>!a)-g<v{z;h[eb?C2F|]i[vrv{z;h]eb?C2F|^iZu.vix,hZq3ah!.(?C2F|QOu!5ShXM:2<BaY?C2F|P\", 13_494, 2713, 49, 25, 61);\n//# sourceMappingURL=decode-data-html.js.map","// Generated using scripts/write-decode-map.ts\n/** Packed XML decode trie data. */\nexport const xmlDecodeTree = /* #__PURE__ */ new Uint16Array([\n    512, 26_465, 29_036, 7, 0, 2, 4, 116, 24_638, 116, 24_636, 8693, 29_807,\n    24_610, 621, 1, 0, 0, 3, 112, 24_614, 111, 115, 24_615,\n]);\n//# sourceMappingURL=decode-data-xml.js.map","/**\n * Bit flags & masks for the binary trie encoding used for entity decoding.\n *\n * The trie is a flat `Uint16Array`. Every node starts with one header word:\n *\n *   15..14 VALUE_LENGTH   Number of words the value occupies, +1.\n *                         0 = no value; 1 = value inline in bits 12..0;\n *                         2/3 = value in the 1/2 words after the header.\n *   13     FLAG13         If VALUE_LENGTH > 0: semicolon required (\"strict\"\n *                         entity; `;` is never stored as a branch).\n *                         If VALUE_LENGTH == 0: this node is a compact run.\n *   12..7  BRANCH_LENGTH  Number of branches (or run length for runs).\n *   6..0   JUMP_TABLE     Jump-table offset / single-branch char / first\n *                         run char (see below).\n *\n * Branch data follows the header and any value words. Its shape is selected\n * by (JUMP_TABLE, BRANCH_LENGTH) in the header:\n *\n *   Single branch  JUMP_TABLE = the only child's char, BRANCH_LENGTH = 0.\n *                  No branch words; the child node follows immediately.\n *   Jump table     JUMP_TABLE = first covered char (> 0), BRANCH_LENGTH =\n *                  table length. One word per covered char: 0 = no branch,\n *                  otherwise the child's offset from the END of the table,\n *                  +1 (so 0 stays the no-branch sentinel).\n *   Dictionary     JUMP_TABLE = 0, BRANCH_LENGTH = number of branches.\n *                  ceil(n/2) words of sorted keys packed two per word\n *                  (low byte first), then n pointer words storing the\n *                  child's offset from the END of the branch data.\n *   Compact run    VALUE_LENGTH = 0, FLAG13 set. BRANCH_LENGTH = run\n *                  length (3..63), JUMP_TABLE = first char; remaining run\n *                  chars packed two per word after the header. The target\n *                  node follows the packed words immediately.\n *\n * Pointers are end-relative (rather than relative to the pointer's own\n * position) because that makes the common \"child encoded right after the\n * branch data\" case a small constant, which compresses far better. Offsets\n * to already-encoded (shared) nodes wrap via uint16 modulo arithmetic; the\n * decoder masks navigation results with `& 0xff_ff` to match.\n */\nexport var BinTrieFlags;\n(function (BinTrieFlags) {\n    BinTrieFlags[BinTrieFlags[\"VALUE_LENGTH\"] = 49152] = \"VALUE_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"FLAG13\"] = 8192] = \"FLAG13\";\n    BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 8064] = \"BRANCH_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n    /** Bits 12..0: the inline value of a VALUE_LENGTH = 1 header word. */\n    BinTrieFlags[BinTrieFlags[\"VALUE_MASK\"] = 8191] = \"VALUE_MASK\";\n})(BinTrieFlags || (BinTrieFlags = {}));\n//# sourceMappingURL=bin-trie-flags.js.map","import { codePointToString, replaceCodePoint, replaceCodePointXML, } from \"./decode-codepoint.js\";\nimport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nimport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\nimport { BinTrieFlags } from \"./internal/bin-trie-flags.js\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"AMP\"] = 38] = \"AMP\";\n    CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n    CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n    CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n    CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n    CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n    CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n    CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nconst TO_LOWER_BIT = 0b10_0000;\n/*\n * `parseNumericEntity` packs its two results into one 32-bit integer:\n * `(consumed << CONSUMED_SHIFT) | codePoint`. The 21-bit code point field\n * fits any valid Unicode value (max 0x10FFFF, clamped before packing); the\n * consumed count excludes `&` and gets the remaining 11 bits. Extract it\n * with `>>>` so the topmost bit isn't treated as a sign.\n *\n * Plain consts rather than a `const enum`: with `isolatedModules`, enum\n * member reads compile to runtime property loads.\n */\nconst CONSUMED_SHIFT = 21;\nconst CODE_POINT_MASK = 0x1f_ff_ff;\n/**\n * Reserved consumed field for counts of at least 2047 characters after `&`.\n * The true count is in `longNumericConsumed`.\n */\nconst CONSUMED_OVERFLOW = 0x7_ff;\n/**\n * Side channel for numeric entities of at least 2048 characters including\n * `&`. Set by `parseNumericEntity` when its consumed count reaches the\n * reserved value `CONSUMED_OVERFLOW`; callers read the true count from here.\n * A module-level slot avoids a tuple allocation on the hot path.\n */\nlet longNumericConsumed = 0;\n/**\n * Extract the consumed count from a `parseNumericEntity` packed result,\n * recovering the true length from `longNumericConsumed` when the packed\n * field contains the sentinel. Read it before the next `parseNumericEntity`\n * call, which may overwrite the side channel. This helper owns that protocol.\n * @param packed Packed result of `parseNumericEntity`.\n */\nfunction unpackConsumed(packed) {\n    const consumed = packed >>> CONSUMED_SHIFT;\n    return consumed === CONSUMED_OVERFLOW ? longNumericConsumed : consumed;\n}\n/**\n * Unsigned subtraction trick: (code - lo) >>> 0 wraps negatives to large\n * values, so a single `<=` covers the entire [lo..hi] range check.\n * @param code Code point to check.\n */\nfunction isNumber(code) {\n    return (code - CharCodes.ZERO) >>> 0 <= 9;\n}\nfunction isHexadecimalCharacter(code) {\n    return ((code | TO_LOWER_BIT) - CharCodes.LOWER_A) >>> 0 <= 5; // F - a\n}\nfunction isAlpha(code) {\n    return ((code | TO_LOWER_BIT) - CharCodes.LOWER_A) >>> 0 <= 25; // Z - a\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n * @param code Code point to check.\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n    return code === CharCodes.EQUALS || isAlpha(code) || isNumber(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n    EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n    EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n    EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\n/**\n * Decoding mode for named entities.\n */\nexport var DecodingMode;\n(function (DecodingMode) {\n    /** Entities in text nodes that can end with any character. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Only allow entities terminated with a semicolon. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n    /** Entities in attributes have limitations on ending characters. */\n    DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode || (DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nexport class EntityDecoder {\n    decodeTree;\n    emitCodePoint;\n    errors;\n    /** The current state of the decoder. */\n    state = EntityDecoderState.EntityStart;\n    /** Characters that were consumed while parsing an entity. */\n    consumed = 1;\n    /**\n     * The result of the entity.\n     *\n     * For named entities: the trie index of the best legacy match so far\n     * (0 = none). For numeric entities: the accumulated code point.\n     */\n    result = 0;\n    /** The current index in the decode tree. */\n    treeIndex = 0;\n    /**\n     * Characters consumed since the last recorded legacy match, plus one.\n     * Invariant at the top of the `stateNamedEntity` loop: `excess` equals\n     * the number of unrecorded consumed characters + 1.\n     */\n    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: False positive (read via destructuring)\n    excess = 1;\n    /** The mode in which the decoder is operating. */\n    decodeMode = DecodingMode.Strict;\n    /** The number of characters that have been consumed in the current run. */\n    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: False positive\n    runConsumed = 0;\n    constructor(\n    /** The predefined HTML or XML decode tree. */\n    decodeTree, \n    /**\n     * The function that is called when a codepoint is decoded.\n     *\n     * For named entities that decode to multiple code points, this will\n     * be called multiple times, with the second codepoint, and the same\n     * `consumed` value.\n     * @param codepoint The decoded codepoint.\n     * @param consumed The number of characters consumed by the decoder.\n     */\n    emitCodePoint, \n    /** An object that is used to produce errors. */\n    errors) {\n        this.decodeTree = decodeTree;\n        this.emitCodePoint = emitCodePoint;\n        this.errors = errors;\n    }\n    /**\n     * Resets the instance to make it reusable.\n     * @param decodeMode Entity decoding mode to use.\n     */\n    startEntity(decodeMode) {\n        this.decodeMode = decodeMode;\n        this.state = EntityDecoderState.EntityStart;\n        this.result = 0;\n        this.treeIndex = 0;\n        this.excess = 1;\n        this.consumed = 1;\n        this.runConsumed = 0;\n    }\n    /**\n     * Write an entity to the decoder. This can be called multiple times with partial entities.\n     * If the entity is incomplete, the decoder will return -1.\n     *\n     * Mirrors the non-streaming `decodeWithTrie`, but with the ability to stop decoding if the\n     * entity is incomplete, and resume when the next string is written.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    write(input, offset) {\n        switch (this.state) {\n            case EntityDecoderState.EntityStart: {\n                if (input.charCodeAt(offset) === CharCodes.NUM) {\n                    this.state = EntityDecoderState.NumericStart;\n                    this.consumed += 1;\n                    return this.stateNumericStart(input, offset + 1);\n                }\n                this.state = EntityDecoderState.NamedEntity;\n                return this.stateNamedEntity(input, offset);\n            }\n            case EntityDecoderState.NumericStart: {\n                return this.stateNumericStart(input, offset);\n            }\n            case EntityDecoderState.NumericDecimal: {\n                return this.stateNumericDecimal(input, offset);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.stateNumericHex(input, offset);\n            }\n            default: {\n                // NamedEntity — the only remaining state.\n                return this.stateNamedEntity(input, offset);\n            }\n        }\n    }\n    /**\n     * Switches between the numeric decimal and hexadecimal states.\n     *\n     * Equivalent to the `Numeric character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    // eslint-disable-next-line unicorn/consistent-class-member-order\n    stateNumericStart(input, offset) {\n        if (offset >= input.length) {\n            return -1;\n        }\n        if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n            this.state = EntityDecoderState.NumericHex;\n            this.consumed += 1;\n            return this.stateNumericHex(input, offset + 1);\n        }\n        this.state = EntityDecoderState.NumericDecimal;\n        return this.stateNumericDecimal(input, offset);\n    }\n    /**\n     * Parses a hexadecimal numeric entity.\n     *\n     * Equivalent to the `Hexademical character reference state` in the HTML\n     * spec. Digit parsing matches the hex loop in `parseNumericEntity`.\n     * The accumulated value is preserved for numeric validation callbacks.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericHex(input, offset) {\n        const inputLength = input.length;\n        // Local accumulators; flushed before any exit (see stateNamedEntity).\n        let { result } = this;\n        let { consumed } = this;\n        while (offset < inputLength) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char) || isHexadecimalCharacter(char)) {\n                // Convert hex digit to value (0-15); 'a'/'A' -> 10.\n                const digit = char <= CharCodes.NINE\n                    ? char - CharCodes.ZERO\n                    : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;\n                result = result * 16 + digit;\n                consumed += 1;\n                offset += 1;\n            }\n            else {\n                this.result = result;\n                this.consumed = consumed;\n                return this.emitNumericEntity(char, 3);\n            }\n        }\n        this.result = result;\n        this.consumed = consumed;\n        return -1; // Incomplete entity\n    }\n    /**\n     * Parses a decimal numeric entity.\n     *\n     * Equivalent to the `Decimal character reference state` in the HTML\n     * spec. Digit parsing matches the decimal loop in `parseNumericEntity`.\n     * The accumulated value is preserved for numeric validation callbacks.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericDecimal(input, offset) {\n        const inputLength = input.length;\n        // Local accumulators; flushed before any exit (see stateNamedEntity).\n        let { result } = this;\n        let { consumed } = this;\n        while (offset < inputLength) {\n            const digit = input.charCodeAt(offset) - CharCodes.ZERO;\n            if (digit >>> 0 > 9) {\n                this.result = result;\n                this.consumed = consumed;\n                return this.emitNumericEntity(digit + CharCodes.ZERO, 2);\n            }\n            result = result * 10 + digit;\n            consumed += 1;\n            offset += 1;\n        }\n        this.result = result;\n        this.consumed = consumed;\n        return -1; // Incomplete entity\n    }\n    /**\n     * Validate and emit a numeric entity.\n     *\n     * Implements the logic from the `Hexademical character reference start\n     * state` and `Numeric character reference end state` in the HTML spec.\n     * @param lastCp The last code point of the entity. Used to see if the\n     *               entity was terminated with a semicolon.\n     * @param expectedLength The minimum number of characters that should be\n     *                       consumed. Used to validate that at least one digit\n     *                       was consumed.\n     * @returns The number of characters that were consumed.\n     */\n    emitNumericEntity(lastCp, expectedLength) {\n        // Ensure we consumed at least one digit.\n        if (this.consumed <= expectedLength) {\n            this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);\n            return 0;\n        }\n        // Figure out if this is a legit end of the entity\n        if (lastCp === CharCodes.SEMI) {\n            this.consumed += 1;\n        }\n        else if (this.decodeMode === DecodingMode.Strict) {\n            return 0;\n        }\n        this.emitCodePoint((this.decodeTree === xmlDecodeTree\n            ? replaceCodePointXML\n            : replaceCodePoint)(this.result), this.consumed);\n        if (this.errors) {\n            if (lastCp !== CharCodes.SEMI) {\n                this.errors.missingSemicolonAfterCharacterReference();\n            }\n            this.errors.validateNumericCharacterReference(this.result);\n        }\n        return this.consumed;\n    }\n    /**\n     * Flush locally-tracked walk state back to the fields, then emit the\n     * recorded legacy match or reject (cold path — at most once per\n     * entity). Called after failed navigation (leaf node, branch miss, or\n     * compact-run mismatch). In attribute mode, reject if no legacy was\n     * recorded at the current node, if we descended past it, or if the\n     * pending input character is an invalid attribute terminator.\n     * @param consumed Locally-tracked consumed count.\n     * @param excess Locally-tracked excess count.\n     * @param char Pending input character (may be the mismatching char).\n     * @param valueLength Value length at the current trie node.\n     */\n    flushAndEmitLegacyOrReject(consumed, excess, char, valueLength) {\n        this.consumed = consumed;\n        this.excess = excess;\n        return this.result === 0 ||\n            (this.decodeMode === DecodingMode.Attribute &&\n                (valueLength === 0 ||\n                    excess > 1 ||\n                    isEntityInAttributeInvalidEnd(char)))\n            ? 0\n            : this.emitNotTerminatedNamedEntity();\n    }\n    /**\n     * Parses a named entity.\n     *\n     * Equivalent to the `Named character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNamedEntity(input, offset) {\n        const { decodeTree } = this;\n        const inputLength = input.length;\n        const isStrict = this.decodeMode === DecodingMode.Strict;\n        /*\n         * Local copies of the resumable walk state avoid per-character\n         * field writes. They are flushed back to the fields\n         * on every exit (chunk end, and before any emit helper that reads\n         * them). `this.result` is only written at the (rare) record points,\n         * so it stays a direct field write.\n         *\n         * Legacy-match recording happens in two idempotent places: at the\n         * loop top when sitting on a value node, and in the chunk-end\n         * epilogue (so `end()` sees matches that land exactly on a chunk\n         * boundary). Recording applies `consumed += excess - 1; excess = 1`,\n         * which is a no-op when repeated — the loop-top invariant is\n         * `excess` = unrecorded consumed characters + 1.\n         */\n        let { treeIndex } = this;\n        let { excess } = this;\n        let { consumed } = this;\n        let current = decodeTree[treeIndex];\n        while (offset < inputLength) {\n            /*\n             * Descend through value-less jump-table nodes (including the\n             * single-branch encoding) inline, mirroring `decodeWithTrie`:\n             * this avoids a `determineBranch` call per level for the\n             * dominant node shape — including the root on the first write.\n             */\n            while ((current &\n                (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                0 &&\n                (current & BinTrieFlags.JUMP_TABLE) !== 0) {\n                const char = input.charCodeAt(offset);\n                const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n                const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                if (branchCount === 0) {\n                    // Single branch encoded inline in the jump offset bits.\n                    if (char !== jumpOffset) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    treeIndex += 1;\n                }\n                else {\n                    const slot = char - jumpOffset;\n                    if (slot >>> 0 >= branchCount) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    const stored = decodeTree[treeIndex + 1 + slot];\n                    if (stored === 0) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    // End-relative: branch data ends at treeIndex+1+branchCount.\n                    treeIndex = (treeIndex + branchCount + stored) & 0xff_ff;\n                }\n                current = decodeTree[treeIndex];\n                offset += 1;\n                excess += 1;\n                /*\n                 * `charCodeAt` past the end returns NaN, which would alias\n                 * to slot 0 after `>>> 0` — bail out explicitly.\n                 */\n                // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                if (offset >= inputLength)\n                    break;\n            }\n            if (offset >= inputLength)\n                break;\n            // Handle compact runs (resumable across chunks).\n            if ((current &\n                (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                BinTrieFlags.FLAG13) {\n                const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7; /* 3..63 */\n                let { runConsumed } = this;\n                // If we are starting a run, check the first char.\n                if (runConsumed === 0) {\n                    const char = input.charCodeAt(offset);\n                    if (char !== (current & BinTrieFlags.JUMP_TABLE)) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    offset += 1;\n                    excess += 1;\n                    runConsumed = 1;\n                }\n                // Check remaining characters in the run (packed two per uint16 word).\n                while (runConsumed < runLength) {\n                    if (offset >= inputLength) {\n                        this.treeIndex = treeIndex;\n                        this.excess = excess;\n                        this.consumed = consumed;\n                        this.runConsumed = runConsumed;\n                        return -1;\n                    }\n                    const charIndexInPacked = runConsumed - 1;\n                    const packedWord = decodeTree[treeIndex + 1 + (charIndexInPacked >> 1)];\n                    const expectedChar = (packedWord >> ((charIndexInPacked & 1) << 3)) & 0xff;\n                    const char = input.charCodeAt(offset);\n                    if (char !== expectedChar) {\n                        this.runConsumed = 0;\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    offset += 1;\n                    excess += 1;\n                    runConsumed += 1;\n                }\n                this.runConsumed = 0;\n                treeIndex += 1 + (runLength >> 1);\n                current = decodeTree[treeIndex];\n                // Loop top handles the landed-on node (record/emit/branch).\n                continue;\n            }\n            // Header plus out-of-line value words; 0 means no value.\n            const valueLength = current >>> 14;\n            const char = input.charCodeAt(offset);\n            if (valueLength !== 0) {\n                // Record a legacy match (FLAG13 clear = semicolon optional).\n                if (!isStrict && (current & BinTrieFlags.FLAG13) === 0) {\n                    this.result = treeIndex;\n                    consumed += excess - 1;\n                    excess = 1;\n                }\n                /*\n                 * Implicit semicolon handling: emit immediately. Covers both\n                 * strict (FLAG13 set) and legacy entities — neither stores\n                 * an explicit `;` branch in the trie.\n                 */\n                if (char === CharCodes.SEMI) {\n                    return this.emitNamedEntityData(treeIndex, valueLength, consumed + excess);\n                }\n                /*\n                 * `valueLength === 1` packs the codepoint into the header\n                 * word's low 13 bits, where branch metadata also lives. Skip\n                 * the branch lookup on leaves so those value bits aren't\n                 * reinterpreted as branch offsets.\n                 */\n                if (valueLength === 1) {\n                    return this.flushAndEmitLegacyOrReject(consumed, excess, char, valueLength);\n                }\n            }\n            // Value-bearing or dictionary node: dispatch through determineBranch.\n            const next = determineBranch(decodeTree, current, treeIndex + (valueLength || 1), char);\n            if (next < 0) {\n                return this.flushAndEmitLegacyOrReject(consumed, excess, char, valueLength);\n            }\n            treeIndex = next;\n            current = decodeTree[treeIndex];\n            offset += 1;\n            excess += 1;\n        }\n        /*\n         * Chunk exhausted. Record a legacy match we may be sitting on, so a\n         * subsequent `end()` emits it, then persist the walk state.\n         */\n        if (!isStrict &&\n            current >>> 14 !== 0 &&\n            (current & BinTrieFlags.FLAG13) === 0) {\n            this.result = treeIndex;\n            consumed += excess - 1;\n            excess = 1;\n        }\n        this.treeIndex = treeIndex;\n        this.excess = excess;\n        this.consumed = consumed;\n        return -1;\n    }\n    /**\n     * Emit a named entity that was not terminated with a semicolon.\n     * @returns The number of characters consumed.\n     */\n    emitNotTerminatedNamedEntity() {\n        const { result, decodeTree } = this;\n        const valueLength = decodeTree[result] >>> 14;\n        this.emitNamedEntityData(result, valueLength, this.consumed);\n        this.errors?.missingSemicolonAfterCharacterReference();\n        return this.consumed;\n    }\n    /**\n     * Emit a named entity.\n     * @param result The index of the entity in the decode tree.\n     * @param valueLength Encoded value length (header plus any value words).\n     * @param consumed The number of characters consumed.\n     * @returns The number of characters consumed.\n     */\n    emitNamedEntityData(result, valueLength, consumed) {\n        const { decodeTree } = this;\n        this.emitCodePoint(valueLength === 1\n            ? decodeTree[result] & BinTrieFlags.VALUE_MASK\n            : decodeTree[result + 1], consumed);\n        if (valueLength === 3) {\n            // Emit the second UTF-16 code unit.\n            this.emitCodePoint(decodeTree[result + 2], consumed);\n        }\n        return consumed;\n    }\n    /**\n     * Signal to the parser that the end of the input was reached.\n     *\n     * Remaining data will be emitted and relevant errors will be produced.\n     * @returns The number of characters consumed.\n     */\n    end() {\n        switch (this.state) {\n            case EntityDecoderState.NamedEntity: {\n                // Emit a named entity if we have one.\n                return this.result !== 0 &&\n                    (this.decodeMode !== DecodingMode.Attribute ||\n                        this.result === this.treeIndex)\n                    ? this.emitNotTerminatedNamedEntity()\n                    : 0;\n            }\n            // Otherwise, emit a numeric entity if we have one.\n            case EntityDecoderState.NumericDecimal: {\n                return this.emitNumericEntity(0, 2);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.emitNumericEntity(0, 3);\n            }\n            case EntityDecoderState.NumericStart: {\n                this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);\n                return 0;\n            }\n            default: {\n                // EntityStart or unknown — return 0.\n                return 0;\n            }\n        }\n    }\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n *\n * See `BinTrieFlags` for the branch-data layouts handled here.\n * @param decodeTree The trie.\n * @param current The current node's header word.\n * @param nodeIndex Index of the node's first branch-data word (the header\n *   plus any value words have been skipped by the caller).\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nexport function determineBranch(decodeTree, current, nodeIndex, char) {\n    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    // Case 1: Single branch or jump table (jumpOffset encodes the first/only char code).\n    if (jumpOffset) {\n        if (branchCount === 0) {\n            // Single branch encoded inline in the jump offset bits.\n            return char === jumpOffset ? nodeIndex : -1;\n        }\n        /*\n         * Jump table: branchCount consecutive slots starting at jumpOffset.\n         * Unsigned comparison handles both < 0 and >= branchCount in one check.\n         */\n        const slot = char - jumpOffset;\n        if (slot >>> 0 >= branchCount)\n            return -1;\n        const stored = decodeTree[nodeIndex + slot];\n        /*\n         * 0 = empty slot (no branch); otherwise the child's offset from the\n         * end of the branch array, +1 (end-relative pointers compress\n         * better). `& 0xff_ff` mirrors the encoder's uint16 wrap for\n         * backreferences to already-encoded nodes.\n         */\n        return stored === 0\n            ? -1\n            : (nodeIndex + branchCount + stored - 1) & 0xff_ff;\n    }\n    /*\n     * Case 2: Packed dictionary. Linear scan — over 90% of dict nodes have\n     * <= 4 branches in the HTML trie, where the constant-factor savings\n     * dominate over binary search's asymptotic edge.\n     */\n    if (branchCount === 0)\n        return -1;\n    const packedKeySlots = (branchCount + 1) >> 1;\n    const branchEnd = nodeIndex + packedKeySlots + branchCount;\n    for (let index = 0; index < branchCount; index++) {\n        const packed = decodeTree[nodeIndex + (index >> 1)];\n        const key = (packed >> ((index & 1) << 3)) & 0xff;\n        if (key === char) {\n            const pointerIndex = nodeIndex + packedKeySlots + index;\n            // Pointers are relative to the end of the branch data.\n            return (branchEnd + decodeTree[pointerIndex]) & 0xff_ff;\n        }\n        // Keys are sorted; if we've passed `char`, no match is possible.\n        if (key > char)\n            return -1;\n    }\n    return -1;\n}\n/**\n * Read the decoded value from a trie node.\n * @param decodeTree The trie.\n * @param nodeIndex The index of the node.\n * @param valueLength The length of the value (1, 2, or 3).\n * @returns The decoded string.\n */\nfunction readTrieValue(decodeTree, nodeIndex, valueLength) {\n    if (valueLength === 1) {\n        return String.fromCharCode(decodeTree[nodeIndex] & BinTrieFlags.VALUE_MASK);\n    }\n    if (valueLength === 2) {\n        return String.fromCharCode(decodeTree[nodeIndex + 1]);\n    }\n    return String.fromCharCode(decodeTree[nodeIndex + 1], decodeTree[nodeIndex + 2]);\n}\n/**\n * Parse a numeric entity (`&#DDD;` or `&#xHHH;`).\n *\n * Encodes the result as `(consumed << CONSUMED_SHIFT) | codepoint` (see\n * the packing comment at the top of the file; overlong entities spill\n * their length into `longNumericConsumed`). Returns 0 when no digits were\n * found.\n *\n * This is the sync counterpart of the streaming\n * `EntityDecoder#stateNumericDecimal` / `#stateNumericHex`. Digit parsing\n * matches those methods; only this packed result needs a value clamp.\n * @param input       The input string.\n * @param numberStart Index of the `#` character.\n * @param inputLength Cached `input.length`.\n */\nfunction parseNumericEntity(input, numberStart, inputLength) {\n    let offset = numberStart + 1; // Skip \"#\"\n    let cp = 0;\n    let digitStart = offset;\n    /*\n     * Separate decimal and hexadecimal loops: each multiplies by a constant\n     * and runs a single digit test, instead of a per-character base check.\n     */\n    if (offset < inputLength &&\n        (input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n        offset += 1;\n        digitStart = offset;\n        while (offset < inputLength) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char)) {\n                cp = cp * 16 + (char - CharCodes.ZERO);\n            }\n            else if (isHexadecimalCharacter(char)) {\n                cp = cp * 16 + ((char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10);\n            }\n            else {\n                break;\n            }\n            offset += 1;\n        }\n    }\n    else {\n        while (offset < inputLength) {\n            const digit = input.charCodeAt(offset) - CharCodes.ZERO;\n            if (digit >>> 0 > 9)\n                break;\n            cp = cp * 10 + digit;\n            offset += 1;\n        }\n    }\n    if (offset === digitStart)\n        return 0;\n    // Include the semicolon in consumed when present.\n    if (offset < inputLength && input.charCodeAt(offset) === CharCodes.SEMI) {\n        offset += 1;\n    }\n    /*\n     * Clamp out-of-range values to 0x110000 so they fit the 21-bit field\n     * and decode to U+FFFD. Lengths at or above CONSUMED_OVERFLOW use the\n     * side channel described with the packing constants.\n     */\n    if (cp > 0x10_ff_ff)\n        cp = 0x11_00_00;\n    let consumed = offset - numberStart;\n    if (consumed >= CONSUMED_OVERFLOW) {\n        // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- deliberate side channel, see `longNumericConsumed`\n        longNumericConsumed = consumed;\n        consumed = CONSUMED_OVERFLOW;\n    }\n    return (consumed << CONSUMED_SHIFT) | cp;\n}\n/**\n * Decode all entities in `input` using the HTML trie.\n *\n * Hard-wired to `htmlDecodeTree`: the inline root navigation below assumes\n * the HTML root's jump-table shape, so this must not be generalized to\n * other tries (the XML trie's dictionary root would silently match no\n * entities — `decodeXML` has its own hand-coded fast path instead).\n * @param input      The string to decode.\n * @param isStrict Only match semicolon-terminated entities.\n * @param isAttribute Whether to apply attribute-specific parsing rules (disallowing certain non-semicolon terminators).\n * @returns The decoded string.\n */\nfunction decodeWithTrie(input, isStrict, isAttribute) {\n    const decodeTree = htmlDecodeTree;\n    // Fast path: no entities at all — return input without any allocation.\n    let offset = input.indexOf(\"&\");\n    if (offset < 0)\n        return input;\n    const inputLength = input.length;\n    /*\n     * `chunkStart` marks the start of the next pending slice. Rejected\n     * entities don't advance it, so consecutive rejections are stitched\n     * into a single `slice` once a real match (or end of input) is hit.\n     */\n    let chunkStart = 0;\n    let result = \"\";\n    /*\n     * Root navigation fields, hoisted out of the per-entity loop. The HTML\n     * root is a multi-branch jump-table covering [A-Za-z]; see the inline\n     * first-iteration comment below.\n     */\n    const root = decodeTree[0];\n    const rootJumpOffset = root & BinTrieFlags.JUMP_TABLE;\n    const rootBranchCount = (root & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    do {\n        const entityStart = offset + 1;\n        // Quick check: entity names must start with [A-Za-z], numeric with #.\n        const firstChar = input.charCodeAt(entityStart);\n        let consumed;\n        let value;\n        if (firstChar === CharCodes.NUM) {\n            const packed = parseNumericEntity(input, entityStart, inputLength);\n            consumed = unpackConsumed(packed);\n            // In strict mode, require semicolon termination.\n            if (isStrict &&\n                consumed > 0 &&\n                input.charCodeAt(entityStart + consumed - 1) !== CharCodes.SEMI) {\n                consumed = 0;\n            }\n            value =\n                consumed === 0\n                    ? \"\"\n                    : codePointToString(packed & CODE_POINT_MASK);\n        }\n        else if (isAlpha(firstChar)) {\n            consumed = 0;\n            value = \"\";\n            /*\n             * The generator guarantees a jump-table root. Consume the first\n             * character directly, then walk from its child.\n             */\n            const rootSlotIndex = firstChar - rootJumpOffset;\n            let nodeIndex;\n            if (rootSlotIndex >>> 0 < rootBranchCount) {\n                const stored = decodeTree[1 + rootSlotIndex];\n                nodeIndex =\n                    stored === 0 ? -1 : (rootBranchCount + stored) & 0xff_ff;\n            }\n            else {\n                nodeIndex = -1;\n            }\n            /*\n             * Best legacy (no-semicolon) match so far, as trie coordinates.\n             * Deferring `readTrieValue` to the end avoids allocating a\n             * string for matches that longer matches supersede.\n             */\n            let bestNodeIndex = 0;\n            let bestValueLength = 0;\n            let current = nodeIndex < 0 ? 0 : decodeTree[nodeIndex];\n            let index = entityStart + 1;\n            /*\n             * Walk the trie from the root child. The `trie` label lets the\n             * inner descent and compact-run loops abandon the entity (and\n             * fall through to the legacy/reject handling) directly.\n             */\n            trie: while (index < inputLength) {\n                /*\n                 * Inline value-less jump tables and single branches. A miss\n                 * falls through to the recorded legacy match or rejection.\n                 */\n                while (\n                // Value-less, non-run node with a nonzero jump offset.\n                (current &\n                    (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                    0 &&\n                    (current & BinTrieFlags.JUMP_TABLE) !== 0) {\n                    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n                    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                    if (branchCount === 0) {\n                        // Single branch encoded inline in the jump offset bits.\n                        if (input.charCodeAt(index) !== jumpOffset)\n                            break trie;\n                        nodeIndex += 1;\n                    }\n                    else {\n                        const slot = input.charCodeAt(index) - jumpOffset;\n                        if (slot >>> 0 >= branchCount)\n                            break trie;\n                        const stored = decodeTree[nodeIndex + 1 + slot];\n                        if (stored === 0)\n                            break trie;\n                        // End-relative: branch data ends at nodeIndex+1+branchCount.\n                        nodeIndex =\n                            (nodeIndex + branchCount + stored) & 0xff_ff;\n                    }\n                    current = decodeTree[nodeIndex];\n                    index += 1;\n                    /*\n                     * `charCodeAt` past the end returns NaN, which would\n                     * alias to slot 0 after `>>> 0` — bail out explicitly.\n                     */\n                    if (index >= inputLength)\n                        break trie;\n                }\n                // FLAG13 without a value marks a compact run.\n                if ((current &\n                    (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                    BinTrieFlags.FLAG13) {\n                    const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                    // Check first char (stored in JUMP_TABLE bits).\n                    if (input.charCodeAt(index) !==\n                        (current & BinTrieFlags.JUMP_TABLE)) {\n                        // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                        break;\n                    }\n                    index += 1;\n                    // Check remaining characters (packed two per uint16 word).\n                    const remaining = runLength - 1;\n                    let wordIndex = nodeIndex + 1;\n                    let charIndexInPacked = 0;\n                    /*\n                     * Process pairs: read one packed word, compare low byte then high byte.\n                     * No explicit bounds check needed — charCodeAt returns NaN for OOB,\n                     * which never equals an integer, so the mismatch break fires naturally.\n                     */\n                    for (; charIndexInPacked + 1 < remaining; charIndexInPacked += 2) {\n                        const packed = decodeTree[wordIndex];\n                        if (input.charCodeAt(index) !== (packed & 0xff))\n                            break trie;\n                        index += 1;\n                        if (input.charCodeAt(index) !== ((packed >> 8) & 0xff))\n                            break trie;\n                        index += 1;\n                        wordIndex += 1;\n                    }\n                    // Handle odd trailing char.\n                    if (charIndexInPacked < remaining) {\n                        if (input.charCodeAt(index) !==\n                            (decodeTree[wordIndex] & 0xff))\n                            // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                            break;\n                        index += 1;\n                    }\n                    nodeIndex += 1 + (runLength >> 1);\n                    current = decodeTree[nodeIndex];\n                    // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                    continue;\n                }\n                // Header plus out-of-line value words; 0 means no value.\n                const valueLength = current >>> 14;\n                const char = input.charCodeAt(index);\n                /*\n                 * Check current node for a value before navigating.\n                 * This handles both: (a) values reached via compact runs on the\n                 * previous iteration, and (b) values at regular branch targets.\n                 */\n                if (valueLength !== 0) {\n                    // If char is `;`, emit immediately.\n                    if (char === CharCodes.SEMI) {\n                        consumed = index - entityStart + 1;\n                        // Inline leaves carry the value in the low 13 bits.\n                        value =\n                            valueLength === 1\n                                ? String.fromCharCode(current & BinTrieFlags.VALUE_MASK)\n                                : readTrieValue(decodeTree, nodeIndex, valueLength);\n                        // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                        break;\n                    }\n                    // Record non-terminated (legacy) match (FLAG13 clear = semicolon optional).\n                    if (!isStrict && (current & BinTrieFlags.FLAG13) === 0) {\n                        consumed = index - entityStart;\n                        bestNodeIndex = nodeIndex;\n                        bestValueLength = valueLength;\n                    }\n                    /*\n                     * A valueLength of 1 means the value is packed inline in the header\n                     * word — these are always leaf nodes with no branches, so we can\n                     * stop walking the trie.\n                     */\n                    // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                    if (valueLength === 1)\n                        break;\n                }\n                // Navigate to the next node (valueLength || 1: skip past value words, minimum 1 for header).\n                const next = determineBranch(decodeTree, current, nodeIndex + (valueLength || 1), char);\n                // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                if (next < 0)\n                    break;\n                nodeIndex = next;\n                current = decodeTree[nodeIndex];\n                index += 1;\n            }\n            /*\n             * Post-loop: if the semicolon path didn't set value,\n             * check for a final legacy match. The last navigation may\n             * have landed on a legacy node whose value hasn't been\n             * recorded yet (loop exited before the top-of-loop check\n             * could run).\n             */\n            if (value === \"\") {\n                const finalVL = current >>> 14;\n                if (finalVL !== 0 &&\n                    !isStrict &&\n                    (current & BinTrieFlags.FLAG13) === 0) {\n                    consumed = index - entityStart;\n                    bestNodeIndex = nodeIndex;\n                    bestValueLength = finalVL;\n                }\n                if (consumed > 0) {\n                    value = readTrieValue(decodeTree, bestNodeIndex, bestValueLength);\n                }\n            }\n        }\n        else {\n            consumed = 0;\n            value = \"\";\n        }\n        /*\n         * The attribute end-char rule (HTML spec §13.2.5.73) only applies to\n         * unterminated *named* references.  Semicolon-terminated entities and\n         * numeric entities are always accepted, matching EntityDecoder behavior.\n         *\n         * When `attribute` is false (the common case), short-circuit skips all\n         * the unterminated-named checks entirely.\n         */\n        if (consumed === 0 ||\n            (isAttribute &&\n                firstChar !== CharCodes.NUM &&\n                input.charCodeAt(entityStart + consumed - 1) !==\n                    CharCodes.SEMI &&\n                entityStart + consumed < inputLength &&\n                isEntityInAttributeInvalidEnd(input.charCodeAt(entityStart + consumed)))) {\n            // Rejected: leave `&` in the pending chunk, scan past it.\n            offset = entityStart;\n        }\n        else {\n            if (chunkStart < offset) {\n                result += input.slice(chunkStart, offset);\n            }\n            result += value;\n            offset = chunkStart = entityStart + consumed;\n        }\n        /*\n         * Adjacent entities (`&x;&y;`) are common in entity-dense input;\n         * checking the single character at `offset` first skips the\n         * `indexOf` call (and its per-call overhead) for that case.\n         */\n        if (input.charCodeAt(offset) !== CharCodes.AMP) {\n            offset = input.indexOf(\"&\", offset);\n        }\n    } while (offset >= 0);\n    return result + input.slice(chunkStart);\n}\n/**\n * Decodes an HTML string.\n * @param htmlString The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nexport function decodeHTML(htmlString, mode = DecodingMode.Legacy) {\n    return decodeWithTrie(htmlString, mode === DecodingMode.Strict, mode === DecodingMode.Attribute);\n}\n/**\n * Decodes an HTML string in an attribute.\n * @param htmlAttribute The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLAttribute(htmlAttribute) {\n    return decodeWithTrie(htmlAttribute, false, true);\n}\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n * @param htmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLStrict(htmlString) {\n    return decodeWithTrie(htmlString, true, false);\n}\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n *\n * Uses a hand-coded fast path for the 5 XML named entities (amp, lt, gt,\n * quot, apos) plus numeric entities, bypassing the trie entirely.\n * @param xmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeXML(xmlString) {\n    let offset = xmlString.indexOf(\"&\");\n    if (offset < 0)\n        return xmlString;\n    let lastIndex = 0;\n    let result = \"\";\n    do {\n        const start = offset + 1;\n        let consumed = 0;\n        let value = \"\";\n        const c1 = xmlString.charCodeAt(start);\n        if (c1 === CharCodes.NUM) {\n            const packed = parseNumericEntity(xmlString, start, xmlString.length);\n            consumed = unpackConsumed(packed);\n            // XML is always strict — require semicolon.\n            if (consumed === 0 ||\n                xmlString.charCodeAt(start + consumed - 1) !== CharCodes.SEMI) {\n                consumed = 0;\n            }\n            else {\n                const codePoint = packed & CODE_POINT_MASK;\n                // Nonzero BMP values below the surrogate range need no replacement.\n                value =\n                    (codePoint - 1) >>> 0 < 0xd7_ff\n                        ? String.fromCharCode(codePoint)\n                        : String.fromCodePoint(replaceCodePointXML(codePoint));\n            }\n        }\n        else {\n            /* eslint-disable unicorn/no-break-in-nested-loop -- Keep XML name dispatch inline with the decode loop. */\n            switch (c1) {\n                // &lt; / &gt;\n                case 0x6c:\n                case 0x67: {\n                    if (xmlString.charCodeAt(start + 1) === 0x74 &&\n                        xmlString.charCodeAt(start + 2) === CharCodes.SEMI) {\n                        consumed = 3;\n                        value = c1 === 0x6c ? \"<\" : \">\";\n                    }\n                    break;\n                }\n                // &amp; / &apos;\n                case 0x61: {\n                    const c2 = xmlString.charCodeAt(start + 1);\n                    if (c2 === 0x6d &&\n                        xmlString.charCodeAt(start + 2) === 0x70 &&\n                        xmlString.charCodeAt(start + 3) === CharCodes.SEMI) {\n                        consumed = 4;\n                        value = \"&\";\n                    }\n                    else if (c2 === 0x70 &&\n                        xmlString.charCodeAt(start + 2) === 0x6f &&\n                        xmlString.charCodeAt(start + 3) === 0x73 &&\n                        xmlString.charCodeAt(start + 4) === CharCodes.SEMI) {\n                        consumed = 5;\n                        value = \"'\";\n                    }\n                    break;\n                }\n                // &quot;\n                case 0x71: {\n                    if (xmlString.charCodeAt(start + 1) === 0x75 &&\n                        xmlString.charCodeAt(start + 2) === 0x6f &&\n                        xmlString.charCodeAt(start + 3) === 0x74 &&\n                        xmlString.charCodeAt(start + 4) === CharCodes.SEMI) {\n                        consumed = 5;\n                        value = '\"';\n                    }\n                    break;\n                }\n            }\n            /* eslint-enable unicorn/no-break-in-nested-loop */\n        }\n        if (consumed > 0) {\n            if (lastIndex < offset)\n                result += xmlString.slice(lastIndex, offset);\n            result += value;\n            offset = lastIndex = start + consumed;\n        }\n        else {\n            offset = start;\n        }\n        /*\n         * Adjacent entities (`&x;&y;`) are common in entity-dense input;\n         * checking the single character at `lastIndex` first skips the\n         * `indexOf` call (and its per-call overhead) for that case.\n         */\n        offset =\n            xmlString.charCodeAt(offset) === CharCodes.AMP\n                ? offset\n                : xmlString.indexOf(\"&\", offset);\n    } while (offset >= 0);\n    return result + xmlString.slice(lastIndex);\n}\nexport { replaceCodePoint, replaceCodePointXML, } from \"./decode-codepoint.js\";\n// Re-export for use by eg. htmlparser2\nexport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nexport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\n//# sourceMappingURL=decode.js.map","import { DecodingMode, EntityDecoder, htmlDecodeTree, xmlDecodeTree, } from \"entities/decode\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"Tab\"] = 9] = \"Tab\";\n    CharCodes[CharCodes[\"NewLine\"] = 10] = \"NewLine\";\n    CharCodes[CharCodes[\"FormFeed\"] = 12] = \"FormFeed\";\n    CharCodes[CharCodes[\"CarriageReturn\"] = 13] = \"CarriageReturn\";\n    CharCodes[CharCodes[\"Space\"] = 32] = \"Space\";\n    CharCodes[CharCodes[\"ExclamationMark\"] = 33] = \"ExclamationMark\";\n    CharCodes[CharCodes[\"Number\"] = 35] = \"Number\";\n    CharCodes[CharCodes[\"Amp\"] = 38] = \"Amp\";\n    CharCodes[CharCodes[\"SingleQuote\"] = 39] = \"SingleQuote\";\n    CharCodes[CharCodes[\"DoubleQuote\"] = 34] = \"DoubleQuote\";\n    CharCodes[CharCodes[\"Dash\"] = 45] = \"Dash\";\n    CharCodes[CharCodes[\"Slash\"] = 47] = \"Slash\";\n    CharCodes[CharCodes[\"Zero\"] = 48] = \"Zero\";\n    CharCodes[CharCodes[\"Nine\"] = 57] = \"Nine\";\n    CharCodes[CharCodes[\"Semi\"] = 59] = \"Semi\";\n    CharCodes[CharCodes[\"Lt\"] = 60] = \"Lt\";\n    CharCodes[CharCodes[\"Eq\"] = 61] = \"Eq\";\n    CharCodes[CharCodes[\"Gt\"] = 62] = \"Gt\";\n    CharCodes[CharCodes[\"Questionmark\"] = 63] = \"Questionmark\";\n    CharCodes[CharCodes[\"UpperA\"] = 65] = \"UpperA\";\n    CharCodes[CharCodes[\"LowerA\"] = 97] = \"LowerA\";\n    CharCodes[CharCodes[\"UpperF\"] = 70] = \"UpperF\";\n    CharCodes[CharCodes[\"LowerF\"] = 102] = \"LowerF\";\n    CharCodes[CharCodes[\"UpperZ\"] = 90] = \"UpperZ\";\n    CharCodes[CharCodes[\"LowerZ\"] = 122] = \"LowerZ\";\n    CharCodes[CharCodes[\"LowerX\"] = 120] = \"LowerX\";\n    CharCodes[CharCodes[\"OpeningSquareBracket\"] = 91] = \"OpeningSquareBracket\";\n})(CharCodes || (CharCodes = {}));\n/** All the states the tokenizer can be in. */\nvar State;\n(function (State) {\n    State[State[\"Text\"] = 1] = \"Text\";\n    State[State[\"BeforeTagName\"] = 2] = \"BeforeTagName\";\n    State[State[\"InTagName\"] = 3] = \"InTagName\";\n    State[State[\"InSelfClosingTag\"] = 4] = \"InSelfClosingTag\";\n    State[State[\"BeforeClosingTagName\"] = 5] = \"BeforeClosingTagName\";\n    State[State[\"InClosingTagName\"] = 6] = \"InClosingTagName\";\n    State[State[\"AfterClosingTagName\"] = 7] = \"AfterClosingTagName\";\n    // Attributes\n    State[State[\"BeforeAttributeName\"] = 8] = \"BeforeAttributeName\";\n    State[State[\"InAttributeName\"] = 9] = \"InAttributeName\";\n    State[State[\"AfterAttributeName\"] = 10] = \"AfterAttributeName\";\n    State[State[\"BeforeAttributeValue\"] = 11] = \"BeforeAttributeValue\";\n    State[State[\"InAttributeValueDq\"] = 12] = \"InAttributeValueDq\";\n    State[State[\"InAttributeValueSq\"] = 13] = \"InAttributeValueSq\";\n    State[State[\"InAttributeValueNq\"] = 14] = \"InAttributeValueNq\";\n    // Declarations\n    State[State[\"BeforeDeclaration\"] = 15] = \"BeforeDeclaration\";\n    State[State[\"InDeclaration\"] = 16] = \"InDeclaration\";\n    // Processing instructions\n    State[State[\"InProcessingInstruction\"] = 17] = \"InProcessingInstruction\";\n    // Comments & CDATA\n    State[State[\"BeforeComment\"] = 18] = \"BeforeComment\";\n    State[State[\"CDATASequence\"] = 19] = \"CDATASequence\";\n    State[State[\"DeclarationSequence\"] = 20] = \"DeclarationSequence\";\n    State[State[\"InSpecialComment\"] = 21] = \"InSpecialComment\";\n    State[State[\"InCommentLike\"] = 22] = \"InCommentLike\";\n    // Special tags\n    State[State[\"SpecialStartSequence\"] = 23] = \"SpecialStartSequence\";\n    State[State[\"InSpecialTag\"] = 24] = \"InSpecialTag\";\n    State[State[\"InPlainText\"] = 25] = \"InPlainText\";\n    State[State[\"InEntity\"] = 26] = \"InEntity\";\n})(State || (State = {}));\nfunction isWhitespace(c) {\n    return (c === CharCodes.Space ||\n        c === CharCodes.NewLine ||\n        c === CharCodes.Tab ||\n        c === CharCodes.FormFeed ||\n        c === CharCodes.CarriageReturn);\n}\nfunction isEndOfTagSection(c) {\n    return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace(c);\n}\nfunction isASCIIAlpha(c) {\n    return ((c >= CharCodes.LowerA && c <= CharCodes.LowerZ) ||\n        (c >= CharCodes.UpperA && c <= CharCodes.UpperZ));\n}\n/**\n * Quote style used for parsed attributes.\n */\nexport var QuoteType;\n(function (QuoteType) {\n    QuoteType[QuoteType[\"NoValue\"] = 0] = \"NoValue\";\n    QuoteType[QuoteType[\"Unquoted\"] = 1] = \"Unquoted\";\n    QuoteType[QuoteType[\"Single\"] = 2] = \"Single\";\n    QuoteType[QuoteType[\"Double\"] = 3] = \"Double\";\n})(QuoteType || (QuoteType = {}));\n/**\n * Sequences used to match longer strings.\n *\n * We don't have `Script`, `Style`, or `Title` here. Instead, we re-use the *End\n * sequences with an increased offset.\n */\nconst Sequences = {\n    Empty: new Uint8Array(0),\n    Cdata: new Uint8Array([0x43, 0x44, 0x41, 0x54, 0x41, 0x5b]), // CDATA[\n    CdataEnd: new Uint8Array([0x5d, 0x5d, 0x3e]), // ]]>\n    CommentEnd: new Uint8Array([0x2d, 0x2d, 0x21, 0x3e]), // `--!>`\n    Doctype: new Uint8Array([0x64, 0x6f, 0x63, 0x74, 0x79, 0x70, 0x65]), // `doctype`\n    IframeEnd: new Uint8Array([0x3c, 0x2f, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65]), // `</iframe`\n    NoembedEnd: new Uint8Array([\n        0x3c, 0x2f, 0x6e, 0x6f, 0x65, 0x6d, 0x62, 0x65, 0x64,\n    ]), // `</noembed`\n    NoframesEnd: new Uint8Array([\n        0x3c, 0x2f, 0x6e, 0x6f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73,\n    ]), // `</noframes`\n    Plaintext: new Uint8Array([\n        0x3c, 0x2f, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74,\n    ]), // `</plaintext`\n    ScriptEnd: new Uint8Array([0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74]), // `</script`\n    StyleEnd: new Uint8Array([0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65]), // `</style`\n    TitleEnd: new Uint8Array([0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65]), // `</title`\n    TextareaEnd: new Uint8Array([\n        0x3c, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x61, 0x72, 0x65, 0x61,\n    ]), // `</textarea`\n    XmpEnd: new Uint8Array([0x3c, 0x2f, 0x78, 0x6d, 0x70]), // `</xmp`\n};\n/**\n * Maps the first lowercase character of an HTML tag name to the sequence\n * used for special-tag detection.  All sequences share a common layout\n * where index 2 is the first tag-name character, so matching always\n * continues from offset 3.\n */\nconst specialStartSequences = new Map([\n    [Sequences.IframeEnd[2], Sequences.IframeEnd],\n    [Sequences.NoembedEnd[2], Sequences.NoembedEnd],\n    [Sequences.Plaintext[2], Sequences.Plaintext],\n    [Sequences.ScriptEnd[2], Sequences.ScriptEnd],\n    [Sequences.TitleEnd[2], Sequences.TitleEnd],\n    [Sequences.XmpEnd[2], Sequences.XmpEnd],\n]);\n/**\n * Tokenizer implementation used by `Parser`.\n */\nexport default class Tokenizer {\n    cbs;\n    /** The current state the tokenizer is in. */\n    state = State.Text;\n    /** The read buffer. */\n    buffer = \"\";\n    /** The beginning of the section that is currently being read. */\n    sectionStart = 0;\n    /** The index within the buffer that we are currently looking at. */\n    index = 0;\n    /** The start of the last entity. */\n    entityStart = 0;\n    /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */\n    baseState = State.Text;\n    /** For special parsing behavior inside of script and style tags. */\n    isSpecial = false;\n    /** Indicates whether the tokenizer has been paused. */\n    running = true;\n    /** The offset of the current buffer. */\n    offset = 0;\n    xmlMode;\n    decodeEntities;\n    recognizeSelfClosing;\n    entityDecoder;\n    constructor({ xmlMode = false, decodeEntities = true, recognizeSelfClosing = xmlMode, }, cbs) {\n        this.cbs = cbs;\n        this.xmlMode = xmlMode;\n        this.decodeEntities = decodeEntities;\n        this.recognizeSelfClosing = recognizeSelfClosing;\n        this.entityDecoder = new EntityDecoder(xmlMode ? xmlDecodeTree : htmlDecodeTree, (cp, consumed) => this.emitCodePoint(cp, consumed));\n    }\n    reset() {\n        this.state = State.Text;\n        this.buffer = \"\";\n        this.sectionStart = 0;\n        this.index = 0;\n        this.baseState = State.Text;\n        this.isSpecial = false;\n        this.currentSequence = Sequences.Empty;\n        this.sequenceIndex = 0;\n        this.running = true;\n        this.offset = 0;\n    }\n    write(chunk) {\n        this.offset += this.buffer.length;\n        this.buffer = chunk;\n        this.parse();\n    }\n    end() {\n        if (this.running)\n            this.finish();\n    }\n    pause() {\n        this.running = false;\n    }\n    resume() {\n        this.running = true;\n        if (this.index < this.buffer.length + this.offset) {\n            this.parse();\n        }\n    }\n    stateText(c) {\n        if (c === CharCodes.Lt ||\n            (!this.decodeEntities && this.fastForwardTo(CharCodes.Lt))) {\n            if (this.index > this.sectionStart) {\n                this.cbs.ontext(this.sectionStart, this.index);\n            }\n            this.state = State.BeforeTagName;\n            this.sectionStart = this.index;\n        }\n        else if (this.decodeEntities && c === CharCodes.Amp) {\n            this.startEntity();\n        }\n    }\n    currentSequence = Sequences.Empty;\n    sequenceIndex = 0;\n    enterTagBody() {\n        if (this.currentSequence === Sequences.Plaintext) {\n            this.currentSequence = Sequences.Empty;\n            this.state = State.InPlainText;\n        }\n        else if (this.isSpecial) {\n            this.state = State.InSpecialTag;\n            this.sequenceIndex = 0;\n        }\n        else {\n            this.state = State.Text;\n        }\n    }\n    /**\n     * Match the opening tag name against an HTML text-only tag sequence.\n     *\n     * Some tags share an initial prefix (`script`/`style`, `title`/`textarea`,\n     * `noembed`/`noframes`), so we may switch to an alternate sequence at the\n     * first distinguishing byte.  On a successful full match we fall back to\n     * the normal tag-name state; a later `>` will enter raw-text, RCDATA, or\n     * plaintext mode based on `currentSequence` / `isSpecial`.\n     * @param c Current character code point.\n     */\n    stateSpecialStartSequence(c) {\n        const lower = c | 0x20;\n        // Still matching — check for an alternate sequence at branch points.\n        if (this.sequenceIndex < this.currentSequence.length) {\n            if (lower === this.currentSequence[this.sequenceIndex]) {\n                this.sequenceIndex++;\n                return;\n            }\n            if (this.sequenceIndex === 3) {\n                if (this.currentSequence === Sequences.ScriptEnd &&\n                    lower === Sequences.StyleEnd[3]) {\n                    this.currentSequence = Sequences.StyleEnd;\n                    this.sequenceIndex = 4;\n                    return;\n                }\n                if (this.currentSequence === Sequences.TitleEnd &&\n                    lower === Sequences.TextareaEnd[3]) {\n                    this.currentSequence = Sequences.TextareaEnd;\n                    this.sequenceIndex = 4;\n                    return;\n                }\n            }\n            else if (this.sequenceIndex === 4 &&\n                this.currentSequence === Sequences.NoembedEnd &&\n                lower === Sequences.NoframesEnd[4]) {\n                this.currentSequence = Sequences.NoframesEnd;\n                this.sequenceIndex = 5;\n                return;\n            }\n        }\n        else if (isEndOfTagSection(c)) {\n            // Full match on a valid tag boundary — keep the sequence.\n            this.sequenceIndex = 0;\n            this.state = State.InTagName;\n            this.stateInTagName(c);\n            return;\n        }\n        // No match — abandon special-tag detection.\n        this.isSpecial = false;\n        this.currentSequence = Sequences.Empty;\n        this.sequenceIndex = 0;\n        this.state = State.InTagName;\n        this.stateInTagName(c);\n    }\n    stateCDATASequence(c) {\n        if (c === Sequences.Cdata[this.sequenceIndex]) {\n            if (++this.sequenceIndex === Sequences.Cdata.length) {\n                this.state = State.InCommentLike;\n                this.currentSequence = Sequences.CdataEnd;\n                this.sequenceIndex = 0;\n                this.sectionStart = this.index + 1;\n            }\n        }\n        else {\n            this.sequenceIndex = 0;\n            if (this.xmlMode) {\n                this.state = State.InDeclaration;\n                this.stateInDeclaration(c); // Reconsume the character\n            }\n            else {\n                this.state = State.InSpecialComment;\n                this.stateInSpecialComment(c); // Reconsume the character\n            }\n        }\n    }\n    /**\n     * When we wait for one specific character, we can speed things up\n     * by skipping through the buffer until we find it.\n     * @param c Current character code point.\n     * @returns Whether the character was found.\n     */\n    fastForwardTo(c) {\n        while (++this.index < this.buffer.length + this.offset) {\n            if (this.buffer.charCodeAt(this.index - this.offset) === c) {\n                return true;\n            }\n        }\n        /*\n         * We increment the index at the end of the `parse` loop,\n         * so set it to `buffer.length - 1` here.\n         *\n         * TODO: Refactor `parse` to increment index before calling states.\n         */\n        this.index = this.buffer.length + this.offset - 1;\n        return false;\n    }\n    /**\n     * Emit a comment token and return to the text state.\n     * @param offset Number of characters in the end sequence that have already been matched.\n     */\n    emitComment(offset) {\n        this.cbs.oncomment(this.sectionStart, this.index, offset);\n        this.sequenceIndex = 0;\n        this.sectionStart = this.index + 1;\n        this.state = State.Text;\n    }\n    /**\n     * Comments and CDATA end with `-->` and `]]>`.\n     *\n     * Their common qualities are:\n     * - Their end sequences have a distinct character they start with.\n     * - That character is then repeated, so we have to check multiple repeats.\n     * - All characters but the start character of the sequence can be skipped.\n     * @param c Current character code point.\n     */\n    stateInCommentLike(c) {\n        if (!this.xmlMode &&\n            this.currentSequence === Sequences.CommentEnd &&\n            this.sequenceIndex <= 1 &&\n            /*\n             * We're still at the very start of the comment: the only\n             * characters consumed since `<!--` are the dashes that\n             * advanced sequenceIndex (0 for `<!-->`, 1 for `<!--->`).\n             */\n            this.index === this.sectionStart + this.sequenceIndex &&\n            c === CharCodes.Gt) {\n            // Abruptly closed empty HTML comment.\n            this.emitComment(this.sequenceIndex);\n        }\n        else if (this.currentSequence === Sequences.CommentEnd &&\n            this.sequenceIndex === 2 &&\n            c === CharCodes.Gt) {\n            // `!` is optional here, so the same sequence also accepts `-->`.\n            this.emitComment(2);\n        }\n        else if (this.currentSequence === Sequences.CommentEnd &&\n            this.sequenceIndex === this.currentSequence.length - 1 &&\n            c !== CharCodes.Gt) {\n            this.sequenceIndex = Number(c === CharCodes.Dash);\n        }\n        else if (c === this.currentSequence[this.sequenceIndex]) {\n            if (++this.sequenceIndex === this.currentSequence.length) {\n                if (this.currentSequence === Sequences.CdataEnd) {\n                    this.cbs.oncdata(this.sectionStart, this.index, 2);\n                }\n                else {\n                    this.cbs.oncomment(this.sectionStart, this.index, 3);\n                }\n                this.sequenceIndex = 0;\n                this.sectionStart = this.index + 1;\n                this.state = State.Text;\n            }\n        }\n        else if (this.sequenceIndex === 0) {\n            // Fast-forward to the first character of the sequence\n            if (this.fastForwardTo(this.currentSequence[0])) {\n                this.sequenceIndex = 1;\n            }\n        }\n        else if (c !== this.currentSequence[this.sequenceIndex - 1]) {\n            // Allow long sequences, eg. --->, ]]]>\n            this.sequenceIndex = 0;\n        }\n    }\n    /**\n     * HTML only allows ASCII alpha characters (a-z and A-Z) at the beginning of a tag name.\n     *\n     * XML allows a lot more characters here (@see https://www.w3.org/TR/REC-xml/#NT-NameStartChar).\n     * We allow anything that wouldn't end the tag.\n     * @param c Current character code point.\n     */\n    isTagStartChar(c) {\n        return this.xmlMode ? !isEndOfTagSection(c) : isASCIIAlpha(c);\n    }\n    /**\n     * Scan raw-text / RCDATA content for the matching end tag.\n     *\n     * For RCDATA tags (`<title>`, `<textarea>`) entities are decoded inline.\n     * For raw-text tags (`<script>`, `<style>`, etc.) we fast-forward to `<`.\n     * @param c Current character code point.\n     */\n    stateInSpecialTag(c) {\n        if (this.sequenceIndex === this.currentSequence.length) {\n            if (isEndOfTagSection(c)) {\n                const endOfText = this.index - this.currentSequence.length;\n                if (this.sectionStart < endOfText) {\n                    // Spoof the index so that reported locations match up.\n                    const actualIndex = this.index;\n                    this.index = endOfText;\n                    this.cbs.ontext(this.sectionStart, endOfText);\n                    this.index = actualIndex;\n                }\n                this.isSpecial = false;\n                this.sectionStart = endOfText + 2; // Skip over the `</`\n                this.stateInClosingTagName(c);\n                return; // We are done; skip the rest of the function.\n            }\n            this.sequenceIndex = 0;\n        }\n        if ((c | 0x20) === this.currentSequence[this.sequenceIndex]) {\n            this.sequenceIndex += 1;\n        }\n        else if (this.sequenceIndex === 0) {\n            if (this.currentSequence === Sequences.TitleEnd ||\n                this.currentSequence === Sequences.TextareaEnd) {\n                // RCDATA tags have to parse entities while still looking for their end tag.\n                if (this.decodeEntities && c === CharCodes.Amp) {\n                    this.startEntity();\n                }\n            }\n            else if (this.fastForwardTo(CharCodes.Lt)) {\n                // Outside of RCDATA tags, we can fast-forward.\n                this.sequenceIndex = 1;\n            }\n        }\n        else {\n            // If we see a `<`, set the sequence index to 1; useful for eg. `<</script>`.\n            this.sequenceIndex = Number(c === CharCodes.Lt);\n        }\n    }\n    stateBeforeTagName(c) {\n        if (c === CharCodes.ExclamationMark) {\n            this.state = State.BeforeDeclaration;\n            this.sectionStart = this.index + 1;\n        }\n        else if (c === CharCodes.Questionmark) {\n            if (this.xmlMode) {\n                this.state = State.InProcessingInstruction;\n                this.sequenceIndex = 0;\n                this.sectionStart = this.index + 1;\n            }\n            else {\n                this.state = State.InSpecialComment;\n                this.sectionStart = this.index;\n            }\n        }\n        else if (this.isTagStartChar(c)) {\n            this.sectionStart = this.index;\n            const special = this.xmlMode || this.cbs.isInForeignContext?.()\n                ? undefined\n                : specialStartSequences.get(c | 0x20);\n            if (special === undefined) {\n                this.state = State.InTagName;\n            }\n            else {\n                this.isSpecial = true;\n                this.currentSequence = special;\n                this.sequenceIndex = 3;\n                this.state = State.SpecialStartSequence;\n            }\n        }\n        else if (c === CharCodes.Slash) {\n            this.state = State.BeforeClosingTagName;\n        }\n        else {\n            this.state = State.Text;\n            this.stateText(c);\n        }\n    }\n    stateInTagName(c) {\n        if (isEndOfTagSection(c)) {\n            this.cbs.onopentagname(this.sectionStart, this.index);\n            this.sectionStart = -1;\n            this.state = State.BeforeAttributeName;\n            this.stateBeforeAttributeName(c);\n        }\n    }\n    stateBeforeClosingTagName(c) {\n        if (isWhitespace(c)) {\n            if (this.xmlMode) {\n                // Ignore\n            }\n            else {\n                this.state = State.InSpecialComment;\n                this.sectionStart = this.index;\n            }\n        }\n        else if (c === CharCodes.Gt) {\n            this.state = State.Text;\n            if (!this.xmlMode) {\n                this.sectionStart = this.index + 1;\n            }\n        }\n        else {\n            this.state = this.isTagStartChar(c)\n                ? State.InClosingTagName\n                : State.InSpecialComment;\n            this.sectionStart = this.index;\n        }\n    }\n    stateInClosingTagName(c) {\n        if (isEndOfTagSection(c)) {\n            this.cbs.onclosetag(this.sectionStart, this.index);\n            this.sectionStart = -1;\n            this.state = State.AfterClosingTagName;\n            this.stateAfterClosingTagName(c);\n        }\n    }\n    stateAfterClosingTagName(c) {\n        // Skip everything until \">\"\n        if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n    }\n    stateBeforeAttributeName(c) {\n        if (c === CharCodes.Gt) {\n            this.cbs.onopentagend(this.index);\n            this.enterTagBody();\n            this.sectionStart = this.index + 1;\n        }\n        else if (c === CharCodes.Slash) {\n            this.state = State.InSelfClosingTag;\n        }\n        else if (!isWhitespace(c)) {\n            this.state = State.InAttributeName;\n            this.sectionStart = this.index;\n        }\n    }\n    /**\n     * Handle `/` before `>` in an opening tag.\n     *\n     * In HTML mode, text-only tags ignore the self-closing flag and still enter\n     * their raw-text/RCDATA/plaintext state unless self-closing tags are being\n     * recognized. In XML mode, or for ordinary tags, the tokenizer returns to\n     * regular text parsing after emitting the self-closing callback.\n     * @param c Current character code point.\n     */\n    stateInSelfClosingTag(c) {\n        if (c === CharCodes.Gt) {\n            this.cbs.onselfclosingtag(this.index);\n            this.sectionStart = this.index + 1;\n            if (!this.recognizeSelfClosing) {\n                this.enterTagBody();\n                return;\n            }\n            this.state = State.Text;\n            this.isSpecial = false; // Reset special state, in case of self-closing special tags\n            this.currentSequence = Sequences.Empty;\n        }\n        else if (!isWhitespace(c)) {\n            this.state = State.BeforeAttributeName;\n            this.stateBeforeAttributeName(c);\n        }\n    }\n    stateInAttributeName(c) {\n        if (c === CharCodes.Eq || isEndOfTagSection(c)) {\n            this.cbs.onattribname(this.sectionStart, this.index);\n            this.sectionStart = this.index;\n            this.state = State.AfterAttributeName;\n            this.stateAfterAttributeName(c);\n        }\n    }\n    stateAfterAttributeName(c) {\n        if (c === CharCodes.Eq) {\n            this.state = State.BeforeAttributeValue;\n        }\n        else if (c === CharCodes.Slash || c === CharCodes.Gt) {\n            this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);\n            this.sectionStart = -1;\n            this.state = State.BeforeAttributeName;\n            this.stateBeforeAttributeName(c);\n        }\n        else if (!isWhitespace(c)) {\n            this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);\n            this.state = State.InAttributeName;\n            this.sectionStart = this.index;\n        }\n    }\n    stateBeforeAttributeValue(c) {\n        if (c === CharCodes.DoubleQuote) {\n            this.state = State.InAttributeValueDq;\n            this.sectionStart = this.index + 1;\n        }\n        else if (c === CharCodes.SingleQuote) {\n            this.state = State.InAttributeValueSq;\n            this.sectionStart = this.index + 1;\n        }\n        else if (!isWhitespace(c)) {\n            this.sectionStart = this.index;\n            this.state = State.InAttributeValueNq;\n            this.stateInAttributeValueNoQuotes(c); // Reconsume token\n        }\n    }\n    handleInAttributeValue(c, quote) {\n        if (c === quote ||\n            (!this.decodeEntities && this.fastForwardTo(quote))) {\n            this.cbs.onattribdata(this.sectionStart, this.index);\n            this.sectionStart = -1;\n            this.cbs.onattribend(quote === CharCodes.DoubleQuote\n                ? QuoteType.Double\n                : QuoteType.Single, this.index + 1);\n            this.state = State.BeforeAttributeName;\n        }\n        else if (this.decodeEntities && c === CharCodes.Amp) {\n            this.startEntity();\n        }\n    }\n    stateInAttributeValueDoubleQuotes(c) {\n        this.handleInAttributeValue(c, CharCodes.DoubleQuote);\n    }\n    stateInAttributeValueSingleQuotes(c) {\n        this.handleInAttributeValue(c, CharCodes.SingleQuote);\n    }\n    stateInAttributeValueNoQuotes(c) {\n        if (isWhitespace(c) || c === CharCodes.Gt) {\n            this.cbs.onattribdata(this.sectionStart, this.index);\n            this.sectionStart = -1;\n            this.cbs.onattribend(QuoteType.Unquoted, this.index);\n            this.state = State.BeforeAttributeName;\n            this.stateBeforeAttributeName(c);\n        }\n        else if (this.decodeEntities && c === CharCodes.Amp) {\n            this.startEntity();\n        }\n    }\n    /**\n     * Distinguish between CDATA, declarations, HTML comments, and HTML bogus\n     * comments after `<!`.\n     *\n     * In HTML mode, only real comments and doctypes stay on declaration paths;\n     * everything else becomes a bogus comment terminated by the next `>`.\n     * @param c Current character code point.\n     */\n    stateBeforeDeclaration(c) {\n        if (c === CharCodes.OpeningSquareBracket) {\n            this.state = State.CDATASequence;\n            this.sequenceIndex = 0;\n        }\n        else if (this.xmlMode) {\n            this.state =\n                c === CharCodes.Dash\n                    ? State.BeforeComment\n                    : State.InDeclaration;\n        }\n        else if ((c | 0x20) === Sequences.Doctype[0]) {\n            this.state = State.DeclarationSequence;\n            this.currentSequence = Sequences.Doctype;\n            this.sequenceIndex = 1;\n        }\n        else if (c === CharCodes.Gt) {\n            this.cbs.oncomment(this.sectionStart, this.index, 0);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n        else if (c === CharCodes.Dash) {\n            this.state = State.BeforeComment;\n        }\n        else {\n            this.state = State.InSpecialComment;\n        }\n    }\n    /**\n     * Continue matching `doctype` after `<!d`.\n     *\n     * A full `doctype` match stays on the declaration path; any other name falls\n     * back to an HTML bogus comment, which matches browser behavior for\n     * non-doctype `<!...>` constructs.\n     * @param c Current character code point.\n     */\n    stateDeclarationSequence(c) {\n        if (this.sequenceIndex === this.currentSequence.length) {\n            this.state = State.InDeclaration;\n            this.stateInDeclaration(c);\n        }\n        else if ((c | 0x20) === this.currentSequence[this.sequenceIndex]) {\n            this.sequenceIndex += 1;\n        }\n        else if (c === CharCodes.Gt) {\n            this.cbs.oncomment(this.sectionStart, this.index, 0);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n        else {\n            this.state = State.InSpecialComment;\n        }\n    }\n    stateInDeclaration(c) {\n        if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {\n            this.cbs.ondeclaration(this.sectionStart, this.index);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n    }\n    /**\n     * XML processing instructions (`<?...?>`).\n     *\n     * In HTML mode `<?` is routed to `InSpecialComment` instead, so this\n     * state is only reachable in XML mode.\n     * @param c Current character code point.\n     */\n    stateInProcessingInstruction(c) {\n        if (c === CharCodes.Questionmark) {\n            // Remember that we just consumed `?`, so the next `>` closes the PI.\n            this.sequenceIndex = 1;\n        }\n        else if (c === CharCodes.Gt && this.sequenceIndex === 1) {\n            this.cbs.onprocessinginstruction(this.sectionStart, this.index - 1);\n            this.sequenceIndex = 0;\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n        else {\n            // Keep scanning for the next `?`, which can start a closing `?>`.\n            this.sequenceIndex = Number(this.fastForwardTo(CharCodes.Questionmark));\n        }\n    }\n    stateBeforeComment(c) {\n        if (c === CharCodes.Dash) {\n            this.state = State.InCommentLike;\n            this.currentSequence = Sequences.CommentEnd;\n            this.sequenceIndex = 0;\n            this.sectionStart = this.index + 1;\n        }\n        else if (this.xmlMode) {\n            this.state = State.InDeclaration;\n        }\n        else if (c === CharCodes.Gt) {\n            this.cbs.oncomment(this.sectionStart, this.index, 0);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n        else {\n            this.state = State.InSpecialComment;\n        }\n    }\n    stateInSpecialComment(c) {\n        if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {\n            this.cbs.oncomment(this.sectionStart, this.index, 0);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n    }\n    startEntity() {\n        this.baseState = this.state;\n        this.state = State.InEntity;\n        this.entityStart = this.index;\n        this.entityDecoder.startEntity(this.xmlMode\n            ? DecodingMode.Strict\n            : this.baseState === State.Text ||\n                this.baseState === State.InSpecialTag\n                ? DecodingMode.Legacy\n                : DecodingMode.Attribute);\n    }\n    stateInEntity() {\n        const indexInBuffer = this.index - this.offset;\n        const length = this.entityDecoder.write(this.buffer, indexInBuffer);\n        // If `length` is positive, we are done with the entity.\n        if (length >= 0) {\n            this.state = this.baseState;\n            if (length === 0) {\n                this.index -= 1;\n            }\n        }\n        else {\n            if (indexInBuffer < this.buffer.length &&\n                this.buffer.charCodeAt(indexInBuffer) === CharCodes.Amp) {\n                this.state = this.baseState;\n                this.index -= 1;\n                return;\n            }\n            // Mark buffer as consumed.\n            this.index = this.offset + this.buffer.length - 1;\n        }\n    }\n    /**\n     * Remove data that has already been consumed from the buffer.\n     */\n    cleanup() {\n        // If we are inside of text or attributes, emit what we already have.\n        if (this.running && this.sectionStart !== this.index) {\n            if (this.state === State.Text ||\n                this.state === State.InPlainText ||\n                (this.state === State.InSpecialTag && this.sequenceIndex === 0)) {\n                this.cbs.ontext(this.sectionStart, this.index);\n                this.sectionStart = this.index;\n            }\n            else if (this.state === State.InAttributeValueDq ||\n                this.state === State.InAttributeValueSq ||\n                this.state === State.InAttributeValueNq) {\n                this.cbs.onattribdata(this.sectionStart, this.index);\n                this.sectionStart = this.index;\n            }\n        }\n    }\n    shouldContinue() {\n        return this.index < this.buffer.length + this.offset && this.running;\n    }\n    /**\n     * Iterates through the buffer, calling the function corresponding to the current state.\n     *\n     * States that are more likely to be hit are higher up, as a performance improvement.\n     */\n    parse() {\n        while (this.shouldContinue()) {\n            const c = this.buffer.charCodeAt(this.index - this.offset);\n            switch (this.state) {\n                case State.Text: {\n                    this.stateText(c);\n                    break;\n                }\n                case State.InPlainText: {\n                    // Skip to end of buffer; cleanup() emits the text.\n                    this.index = this.buffer.length + this.offset - 1;\n                    break;\n                }\n                case State.SpecialStartSequence: {\n                    this.stateSpecialStartSequence(c);\n                    break;\n                }\n                case State.InSpecialTag: {\n                    this.stateInSpecialTag(c);\n                    break;\n                }\n                case State.CDATASequence: {\n                    this.stateCDATASequence(c);\n                    break;\n                }\n                case State.DeclarationSequence: {\n                    this.stateDeclarationSequence(c);\n                    break;\n                }\n                case State.InAttributeValueDq: {\n                    this.stateInAttributeValueDoubleQuotes(c);\n                    break;\n                }\n                case State.InAttributeName: {\n                    this.stateInAttributeName(c);\n                    break;\n                }\n                case State.InCommentLike: {\n                    this.stateInCommentLike(c);\n                    break;\n                }\n                case State.InSpecialComment: {\n                    this.stateInSpecialComment(c);\n                    break;\n                }\n                case State.BeforeAttributeName: {\n                    this.stateBeforeAttributeName(c);\n                    break;\n                }\n                case State.InTagName: {\n                    this.stateInTagName(c);\n                    break;\n                }\n                case State.InClosingTagName: {\n                    this.stateInClosingTagName(c);\n                    break;\n                }\n                case State.BeforeTagName: {\n                    this.stateBeforeTagName(c);\n                    break;\n                }\n                case State.AfterAttributeName: {\n                    this.stateAfterAttributeName(c);\n                    break;\n                }\n                case State.InAttributeValueSq: {\n                    this.stateInAttributeValueSingleQuotes(c);\n                    break;\n                }\n                case State.BeforeAttributeValue: {\n                    this.stateBeforeAttributeValue(c);\n                    break;\n                }\n                case State.BeforeClosingTagName: {\n                    this.stateBeforeClosingTagName(c);\n                    break;\n                }\n                case State.AfterClosingTagName: {\n                    this.stateAfterClosingTagName(c);\n                    break;\n                }\n                case State.InAttributeValueNq: {\n                    this.stateInAttributeValueNoQuotes(c);\n                    break;\n                }\n                case State.InSelfClosingTag: {\n                    this.stateInSelfClosingTag(c);\n                    break;\n                }\n                case State.InDeclaration: {\n                    this.stateInDeclaration(c);\n                    break;\n                }\n                case State.BeforeDeclaration: {\n                    this.stateBeforeDeclaration(c);\n                    break;\n                }\n                case State.BeforeComment: {\n                    this.stateBeforeComment(c);\n                    break;\n                }\n                case State.InProcessingInstruction: {\n                    this.stateInProcessingInstruction(c);\n                    break;\n                }\n                case State.InEntity: {\n                    this.stateInEntity();\n                    break;\n                }\n            }\n            this.index++;\n        }\n        this.cleanup();\n    }\n    finish() {\n        if (this.state === State.InEntity) {\n            this.entityDecoder.end();\n            this.state = this.baseState;\n        }\n        this.handleTrailingData();\n        this.cbs.onend();\n    }\n    handleTrailingCommentLikeData(endIndex) {\n        if (this.state !== State.InCommentLike) {\n            return false;\n        }\n        if (this.currentSequence === Sequences.CdataEnd) {\n            if (this.xmlMode) {\n                if (this.sectionStart < endIndex) {\n                    this.cbs.oncdata(this.sectionStart, endIndex, 0);\n                }\n            }\n            else {\n                /* In HTML mode, unclosed CDATA is a bogus comment. */\n                const cdataStart = this.sectionStart - Sequences.Cdata.length - 1;\n                this.cbs.oncomment(cdataStart, endIndex, 0);\n            }\n        }\n        else {\n            const offset = this.xmlMode\n                ? 0\n                : Math.min(this.sequenceIndex, Sequences.CommentEnd.length - 1);\n            this.cbs.oncomment(this.sectionStart, endIndex, offset);\n        }\n        return true;\n    }\n    handleTrailingMarkupDeclaration(endIndex) {\n        if (this.xmlMode) {\n            switch (this.state) {\n                case State.InSpecialComment:\n                case State.BeforeComment:\n                case State.CDATASequence:\n                case State.DeclarationSequence:\n                case State.InDeclaration: {\n                    this.cbs.ontext(this.sectionStart, endIndex);\n                    return true;\n                }\n                default: {\n                    return false;\n                }\n            }\n        }\n        switch (this.state) {\n            case State.BeforeDeclaration:\n            case State.InSpecialComment:\n            case State.BeforeComment:\n            case State.CDATASequence: {\n                this.cbs.oncomment(this.sectionStart, endIndex, 0);\n                return true;\n            }\n            case State.DeclarationSequence: {\n                if (this.sequenceIndex !== Sequences.Doctype.length) {\n                    this.cbs.oncomment(this.sectionStart, endIndex, 0);\n                }\n                return true;\n            }\n            case State.InDeclaration: {\n                return true;\n            }\n            default: {\n                return false;\n            }\n        }\n    }\n    /** Handle any trailing data. */\n    handleTrailingData() {\n        const endIndex = this.buffer.length + this.offset;\n        if (this.handleTrailingCommentLikeData(endIndex) ||\n            this.handleTrailingMarkupDeclaration(endIndex)) {\n            return;\n        }\n        // If there is no remaining data, we are done.\n        if (this.sectionStart >= endIndex) {\n            return;\n        }\n        switch (this.state) {\n            case State.InTagName:\n            case State.BeforeAttributeName:\n            case State.BeforeAttributeValue:\n            case State.AfterAttributeName:\n            case State.InAttributeName:\n            case State.InAttributeValueSq:\n            case State.InAttributeValueDq:\n            case State.InAttributeValueNq:\n            case State.InClosingTagName: {\n                /*\n                 * If we are currently in an opening or closing tag, us not calling the\n                 * respective callback signals that the tag should be ignored.\n                 */\n                break;\n            }\n            default: {\n                this.cbs.ontext(this.sectionStart, endIndex);\n            }\n        }\n    }\n    emitCodePoint(cp, consumed) {\n        if (this.baseState !== State.Text &&\n            this.baseState !== State.InSpecialTag) {\n            if (this.sectionStart < this.entityStart) {\n                this.cbs.onattribdata(this.sectionStart, this.entityStart);\n            }\n            this.sectionStart = this.entityStart + consumed;\n            this.index = this.sectionStart - 1;\n            this.cbs.onattribentity(cp);\n        }\n        else {\n            if (this.sectionStart < this.entityStart) {\n                this.cbs.ontext(this.sectionStart, this.entityStart);\n            }\n            this.sectionStart = this.entityStart + consumed;\n            this.index = this.sectionStart - 1;\n            this.cbs.ontextentity(cp, this.sectionStart);\n        }\n    }\n}\n//# sourceMappingURL=Tokenizer.js.map","const { fromCodePoint } = String;\nimport Tokenizer, { QuoteType } from \"./Tokenizer.js\";\nconst formTags = new Set([\n    \"input\",\n    \"option\",\n    \"optgroup\",\n    \"select\",\n    \"button\",\n    \"datalist\",\n    \"textarea\",\n]);\nconst pTag = new Set([\"p\"]);\nconst headingTags = new Set([\"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"p\"]);\nconst tableSectionTags = new Set([\"thead\", \"tbody\"]);\nconst ddtTags = new Set([\"dd\", \"dt\"]);\nconst rtpTags = new Set([\"rt\", \"rp\"]);\nconst openImpliesClose = new Map([\n    [\"tr\", new Set([\"tr\", \"th\", \"td\"])],\n    [\"th\", new Set([\"th\"])],\n    [\"td\", new Set([\"thead\", \"th\", \"td\"])],\n    [\"body\", new Set([\"head\", \"link\", \"script\"])],\n    [\"a\", new Set([\"a\"])],\n    [\"li\", new Set([\"li\"])],\n    [\"p\", pTag],\n    [\"h1\", headingTags],\n    [\"h2\", headingTags],\n    [\"h3\", headingTags],\n    [\"h4\", headingTags],\n    [\"h5\", headingTags],\n    [\"h6\", headingTags],\n    [\"select\", formTags],\n    [\"input\", formTags],\n    [\"output\", formTags],\n    [\"button\", formTags],\n    [\"datalist\", formTags],\n    [\"textarea\", formTags],\n    [\"option\", new Set([\"option\"])],\n    [\"optgroup\", new Set([\"optgroup\", \"option\"])],\n    [\"dd\", ddtTags],\n    [\"dt\", ddtTags],\n    [\"address\", pTag],\n    [\"article\", pTag],\n    [\"aside\", pTag],\n    [\"blockquote\", pTag],\n    [\"details\", pTag],\n    [\"div\", pTag],\n    [\"dl\", pTag],\n    [\"fieldset\", pTag],\n    [\"figcaption\", pTag],\n    [\"figure\", pTag],\n    [\"footer\", pTag],\n    [\"form\", pTag],\n    [\"header\", pTag],\n    [\"hr\", pTag],\n    [\"main\", pTag],\n    [\"nav\", pTag],\n    [\"ol\", pTag],\n    [\"pre\", pTag],\n    [\"section\", pTag],\n    [\"table\", pTag],\n    [\"ul\", pTag],\n    [\"rt\", rtpTags],\n    [\"rp\", rtpTags],\n    [\"tbody\", tableSectionTags],\n    [\"tfoot\", tableSectionTags],\n]);\nconst DOCUMENT_TYPE = \"doctype\";\nconst voidElements = new Set([\n    \"area\",\n    \"base\",\n    \"basefont\",\n    \"br\",\n    \"col\",\n    \"command\",\n    \"embed\",\n    \"frame\",\n    \"hr\",\n    \"img\",\n    \"input\",\n    \"isindex\",\n    \"keygen\",\n    \"link\",\n    \"meta\",\n    \"param\",\n    \"source\",\n    \"track\",\n    \"wbr\",\n]);\nconst foreignContextElements = new Set([\"math\", \"svg\"]);\n/**\n * Elements that can be used to integrate HTML content within foreign namespaces (e.g., SVG or MathML).\n *\n * Entries must use the SVG-adjusted casing (e.g. \"foreignObject\" not\n * \"foreignobject\") since they are compared against adjusted tag names.\n */\nconst htmlIntegrationElements = new Set([\n    \"mi\",\n    \"mo\",\n    \"mn\",\n    \"ms\",\n    \"mtext\",\n    \"annotation-xml\",\n    \"foreignObject\",\n    \"desc\",\n    \"title\",\n]);\nconst svgTagNameAdjustments = new Map([\n    [\"altglyph\", \"altGlyph\"],\n    [\"altglyphdef\", \"altGlyphDef\"],\n    [\"altglyphitem\", \"altGlyphItem\"],\n    [\"animatecolor\", \"animateColor\"],\n    [\"animatemotion\", \"animateMotion\"],\n    [\"animatetransform\", \"animateTransform\"],\n    [\"clippath\", \"clipPath\"],\n    [\"feblend\", \"feBlend\"],\n    [\"fecolormatrix\", \"feColorMatrix\"],\n    [\"fecomponenttransfer\", \"feComponentTransfer\"],\n    [\"fecomposite\", \"feComposite\"],\n    [\"feconvolvematrix\", \"feConvolveMatrix\"],\n    [\"fediffuselighting\", \"feDiffuseLighting\"],\n    [\"fedisplacementmap\", \"feDisplacementMap\"],\n    [\"fedistantlight\", \"feDistantLight\"],\n    [\"fedropshadow\", \"feDropShadow\"],\n    [\"feflood\", \"feFlood\"],\n    [\"fefunca\", \"feFuncA\"],\n    [\"fefuncb\", \"feFuncB\"],\n    [\"fefuncg\", \"feFuncG\"],\n    [\"fefuncr\", \"feFuncR\"],\n    [\"fegaussianblur\", \"feGaussianBlur\"],\n    [\"feimage\", \"feImage\"],\n    [\"femerge\", \"feMerge\"],\n    [\"femergenode\", \"feMergeNode\"],\n    [\"femorphology\", \"feMorphology\"],\n    [\"feoffset\", \"feOffset\"],\n    [\"fepointlight\", \"fePointLight\"],\n    [\"fespecularlighting\", \"feSpecularLighting\"],\n    [\"fespotlight\", \"feSpotLight\"],\n    [\"fetile\", \"feTile\"],\n    [\"feturbulence\", \"feTurbulence\"],\n    [\"foreignobject\", \"foreignObject\"],\n    [\"glyphref\", \"glyphRef\"],\n    [\"lineargradient\", \"linearGradient\"],\n    [\"radialgradient\", \"radialGradient\"],\n    [\"textpath\", \"textPath\"],\n]);\nvar ForeignContext;\n(function (ForeignContext) {\n    ForeignContext[ForeignContext[\"None\"] = 0] = \"None\";\n    ForeignContext[ForeignContext[\"Svg\"] = 1] = \"Svg\";\n    ForeignContext[ForeignContext[\"MathML\"] = 2] = \"MathML\";\n})(ForeignContext || (ForeignContext = {}));\nconst reNameEnd = /\\s|\\//;\n/**\n * Incremental parser implementation.\n */\nexport class Parser {\n    options;\n    /** The start index of the last event. */\n    startIndex = 0;\n    /** The end index of the last event. */\n    endIndex = 0;\n    /**\n     * Store the start index of the current open tag,\n     * so we can update the start index for attributes.\n     */\n    openTagStart = 0;\n    tagname = \"\";\n    attribname = \"\";\n    attribvalue = \"\";\n    attribs = null;\n    stack = [];\n    foreignContext;\n    cbs;\n    lowerCaseTagNames;\n    lowerCaseAttributeNames;\n    recognizeSelfClosing;\n    /** We are parsing HTML. Inverse of the `xmlMode` option. */\n    htmlMode;\n    tokenizer;\n    buffers = [];\n    bufferOffset = 0;\n    /** The index of the last written buffer. Used when resuming after a `pause()`. */\n    writeIndex = 0;\n    /** Indicates whether the parser has finished running / `.end` has been called. */\n    ended = false;\n    constructor(cbs, options = {}) {\n        this.options = options;\n        this.cbs = cbs ?? {};\n        this.htmlMode = !this.options.xmlMode;\n        this.lowerCaseTagNames = options.lowerCaseTags ?? this.htmlMode;\n        this.lowerCaseAttributeNames =\n            options.lowerCaseAttributeNames ?? this.htmlMode;\n        this.recognizeSelfClosing =\n            options.recognizeSelfClosing ?? !this.htmlMode;\n        this.tokenizer = new (options.Tokenizer ?? Tokenizer)(this.options, this);\n        this.foreignContext = [ForeignContext.None];\n        this.cbs.onparserinit?.(this);\n    }\n    // Tokenizer event handlers\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    ontext(start, endIndex) {\n        const data = this.getSlice(start, endIndex);\n        this.endIndex = endIndex - 1;\n        this.cbs.ontext?.(data);\n        this.startIndex = endIndex;\n    }\n    /**\n     * @param cp Current Unicode code point.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    ontextentity(cp, endIndex) {\n        this.endIndex = endIndex - 1;\n        this.cbs.ontext?.(fromCodePoint(cp));\n        this.startIndex = endIndex;\n    }\n    /** @internal */\n    isInForeignContext() {\n        return this.foreignContext[0] !== ForeignContext.None;\n    }\n    /**\n     * Checks if the current tag is a void element. Override this if you want\n     * to specify your own additional void elements.\n     * @param name Name of the pseudo selector.\n     */\n    isVoidElement(name) {\n        return this.htmlMode && voidElements.has(name);\n    }\n    /**\n     * Read a tag name from the buffer.\n     *\n     * When `lowerCaseTagNames` is enabled (the default in HTML mode), the name\n     * is lowercased and may be adjusted for SVG casing or the `image` → `img`\n     * alias.\n     * @param start Start index of the tag name in the buffer.\n     * @param endIndex End index of the tag name in the buffer.\n     */\n    readTagName(start, endIndex) {\n        const name = this.lowerCaseTagNames\n            ? this.getSlice(start, endIndex).toLowerCase()\n            : this.getSlice(start, endIndex);\n        if (!(this.lowerCaseTagNames && this.htmlMode)) {\n            return name;\n        }\n        if (this.foreignContext[0] === ForeignContext.Svg) {\n            return svgTagNameAdjustments.get(name) ?? name;\n        }\n        /*\n         * Closing tags for SVG elements inside HTML integration points\n         * (e.g. </foreignObject> while inside its own content) need case\n         * adjustment so the name matches what was pushed to the stack.\n         * `foreignContext.length > 1` means a foreign ancestor exists —\n         * the base [None] entry plus at least one pushed context.\n         */\n        if (this.foreignContext.length > 1) {\n            const adjusted = svgTagNameAdjustments.get(name);\n            if (adjusted !== undefined && this.stack.includes(adjusted)) {\n                return adjusted;\n            }\n        }\n        if (!this.isInForeignContext()) {\n            return name === \"image\" ? \"img\" : name;\n        }\n        return name;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onopentagname(start, endIndex) {\n        this.endIndex = endIndex;\n        this.emitOpenTag(this.readTagName(start, endIndex));\n    }\n    emitOpenTag(name) {\n        this.openTagStart = this.startIndex;\n        this.tagname = name;\n        /*\n         * The spec ignores a second <form> when one is already open.\n         * Setting tagname to \"\" suppresses all downstream effects: attribs\n         * stays null so endOpenTag is a no-op, and closeCurrentTag can't\n         * match \"\" on the stack.\n         */\n        if (this.htmlMode && name === \"form\" && this.stack.includes(\"form\")) {\n            this.tagname = \"\";\n            return;\n        }\n        const impliesClose = this.htmlMode && openImpliesClose.get(name);\n        if (impliesClose) {\n            while (this.stack.length > 0 && impliesClose.has(this.stack[0])) {\n                this.popElement(true);\n            }\n        }\n        if (!this.isVoidElement(name)) {\n            this.stack.unshift(name);\n            if (this.htmlMode) {\n                if (name === \"svg\") {\n                    this.foreignContext.unshift(ForeignContext.Svg);\n                }\n                else if (name === \"math\") {\n                    this.foreignContext.unshift(ForeignContext.MathML);\n                }\n                else if (htmlIntegrationElements.has(name)) {\n                    this.foreignContext.unshift(ForeignContext.None);\n                }\n            }\n        }\n        this.cbs.onopentagname?.(name);\n        if (this.cbs.onopentag)\n            this.attribs = {};\n    }\n    endOpenTag(isImplied) {\n        this.startIndex = this.openTagStart;\n        if (this.attribs) {\n            this.cbs.onopentag?.(this.tagname, this.attribs, isImplied);\n            this.attribs = null;\n        }\n        if (this.cbs.onclosetag && this.isVoidElement(this.tagname)) {\n            this.cbs.onclosetag(this.tagname, true);\n        }\n        this.tagname = \"\";\n    }\n    /**\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onopentagend(endIndex) {\n        this.endIndex = endIndex;\n        this.endOpenTag(false);\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onclosetag(start, endIndex) {\n        this.endIndex = endIndex;\n        const name = this.readTagName(start, endIndex);\n        if (!this.isVoidElement(name)) {\n            const pos = this.stack.indexOf(name);\n            if (pos !== -1) {\n                for (let index = 0; index < pos; index++) {\n                    this.popElement(true);\n                }\n                this.popElement(false);\n            }\n            else if (this.htmlMode && name === \"p\") {\n                // Implicit open before close\n                this.emitOpenTag(\"p\");\n                this.closeCurrentTag(true);\n            }\n        }\n        else if (this.htmlMode && name === \"br\") {\n            // We can't use `emitOpenTag` for implicit open, as `br` would be implicitly closed.\n            this.cbs.onopentagname?.(\"br\");\n            this.cbs.onopentag?.(\"br\", {}, true);\n            this.cbs.onclosetag?.(\"br\", false);\n        }\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onselfclosingtag(endIndex) {\n        this.endIndex = endIndex;\n        if (this.recognizeSelfClosing || this.isInForeignContext()) {\n            this.closeCurrentTag(false);\n            // Set `startIndex` for next node\n            this.startIndex = endIndex + 1;\n        }\n        else {\n            // Ignore the fact that the tag is self-closing.\n            this.onopentagend(endIndex);\n        }\n    }\n    /**\n     * Pop the top element off the stack, emit a close event, and maintain\n     * the foreign context stack.\n     * @param implied Whether this close is implied (not from an explicit end tag).\n     */\n    popElement(implied) {\n        // biome-ignore lint/style/noNonNullAssertion: The element is guaranteed to exist.\n        const element = this.stack.shift();\n        if (this.htmlMode &&\n            (foreignContextElements.has(element) ||\n                htmlIntegrationElements.has(element))) {\n            this.foreignContext.shift();\n        }\n        this.cbs.onclosetag?.(element, implied);\n    }\n    closeCurrentTag(isOpenImplied) {\n        const name = this.tagname;\n        this.endOpenTag(isOpenImplied);\n        // Self-closing tags will be on the top of the stack\n        if (this.stack[0] === name) {\n            this.popElement(!isOpenImplied);\n        }\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onattribname(start, endIndex) {\n        this.startIndex = start;\n        const name = this.getSlice(start, endIndex);\n        this.attribname = this.lowerCaseAttributeNames\n            ? name.toLowerCase()\n            : name;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onattribdata(start, endIndex) {\n        this.attribvalue += this.getSlice(start, endIndex);\n    }\n    /**\n     * @param cp Current Unicode code point.\n     * @internal\n     */\n    onattribentity(cp) {\n        this.attribvalue += fromCodePoint(cp);\n    }\n    /**\n     * @param quote Quote type used for the current attribute.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onattribend(quote, endIndex) {\n        this.endIndex = endIndex;\n        this.cbs.onattribute?.(this.attribname, this.attribvalue, quote === QuoteType.Double\n            ? '\"'\n            : quote === QuoteType.Single\n                ? \"'\"\n                : quote === QuoteType.NoValue\n                    ? undefined\n                    : null);\n        if (this.attribs && !Object.hasOwn(this.attribs, this.attribname)) {\n            this.attribs[this.attribname] = this.attribvalue;\n        }\n        this.attribvalue = \"\";\n    }\n    getInstructionName(value) {\n        const index = value.search(reNameEnd);\n        let name = index < 0 ? value : value.substr(0, index);\n        if (this.lowerCaseTagNames) {\n            name = name.toLowerCase();\n        }\n        return name;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    ondeclaration(start, endIndex) {\n        this.endIndex = endIndex;\n        const value = this.getSlice(start, endIndex);\n        if (this.cbs.onprocessinginstruction) {\n            /*\n             * In HTML mode, ondeclaration is only reached for DOCTYPE\n             * (the tokenizer routes everything else to bogus comments).\n             */\n            const name = this.htmlMode\n                ? this.lowerCaseTagNames\n                    ? DOCUMENT_TYPE\n                    : value.slice(0, DOCUMENT_TYPE.length)\n                : this.getInstructionName(value);\n            this.cbs.onprocessinginstruction(`!${name}`, `!${value}`);\n        }\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onprocessinginstruction(start, endIndex) {\n        this.endIndex = endIndex;\n        const value = this.getSlice(start, endIndex);\n        if (this.cbs.onprocessinginstruction) {\n            const name = this.getInstructionName(value);\n            this.cbs.onprocessinginstruction(`?${name}`, `?${value}`);\n        }\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @param offset Offset applied when computing parser indices.\n     * @internal\n     */\n    oncomment(start, endIndex, offset) {\n        this.endIndex = endIndex;\n        this.cbs.oncomment?.(this.getSlice(start, endIndex - offset));\n        this.cbs.oncommentend?.();\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @param offset Offset applied when computing parser indices.\n     * @internal\n     */\n    oncdata(start, endIndex, offset) {\n        this.endIndex = endIndex;\n        const value = this.getSlice(start, endIndex - offset);\n        if (!this.htmlMode || this.options.recognizeCDATA) {\n            this.cbs.oncdatastart?.();\n            this.cbs.ontext?.(value);\n            this.cbs.oncdataend?.();\n        }\n        else if (this.isInForeignContext()) {\n            this.cbs.ontext?.(value);\n        }\n        else {\n            this.cbs.oncomment?.(`[CDATA[${value}]]`);\n            this.cbs.oncommentend?.();\n        }\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /** @internal */\n    onend() {\n        if (this.cbs.onclosetag) {\n            // Set the end index for all remaining tags\n            this.endIndex = this.startIndex;\n            for (let index = 0; index < this.stack.length; index++) {\n                this.cbs.onclosetag(this.stack[index], true);\n            }\n        }\n        this.cbs.onend?.();\n    }\n    /**\n     * Resets the parser to a blank state, ready to parse a new HTML document\n     */\n    reset() {\n        this.cbs.onreset?.();\n        this.tokenizer.reset();\n        this.tagname = \"\";\n        this.attribname = \"\";\n        this.attribvalue = \"\";\n        this.attribs = null;\n        this.stack.length = 0;\n        this.startIndex = 0;\n        this.endIndex = 0;\n        this.cbs.onparserinit?.(this);\n        this.buffers.length = 0;\n        this.foreignContext.length = 0;\n        this.foreignContext.unshift(ForeignContext.None);\n        this.bufferOffset = 0;\n        this.writeIndex = 0;\n        this.ended = false;\n    }\n    /**\n     * Resets the parser, then parses a complete document and\n     * pushes it to the handler.\n     * @param data Document to parse.\n     */\n    parseComplete(data) {\n        this.reset();\n        this.end(data);\n    }\n    getSlice(start, end) {\n        if (start === end) {\n            return \"\";\n        }\n        while (start - this.bufferOffset >= this.buffers[0].length) {\n            this.shiftBuffer();\n        }\n        let slice = this.buffers[0].slice(start - this.bufferOffset, end - this.bufferOffset);\n        while (end - this.bufferOffset > this.buffers[0].length) {\n            this.shiftBuffer();\n            slice += this.buffers[0].slice(0, end - this.bufferOffset);\n        }\n        return slice;\n    }\n    shiftBuffer() {\n        this.bufferOffset += this.buffers[0].length;\n        this.writeIndex--;\n        this.buffers.shift();\n    }\n    /**\n     * Parses a chunk of data and calls the corresponding callbacks.\n     * @param chunk Chunk to parse.\n     */\n    write(chunk) {\n        if (this.ended) {\n            this.cbs.onerror?.(new Error(\".write() after done!\"));\n            return;\n        }\n        this.buffers.push(chunk);\n        if (this.tokenizer.running) {\n            this.tokenizer.write(chunk);\n            this.writeIndex++;\n        }\n    }\n    /**\n     * Parses the end of the buffer and clears the stack, calls onend.\n     * @param chunk Optional final chunk to parse.\n     */\n    end(chunk) {\n        if (this.ended) {\n            this.cbs.onerror?.(new Error(\".end() after done!\"));\n            return;\n        }\n        if (chunk)\n            this.write(chunk);\n        this.ended = true;\n        this.tokenizer.end();\n    }\n    /**\n     * Pauses parsing. The parser won't emit events until `resume` is called.\n     */\n    pause() {\n        this.tokenizer.pause();\n    }\n    /**\n     * Resumes parsing after `pause` was called.\n     */\n    resume() {\n        this.tokenizer.resume();\n        while (this.tokenizer.running &&\n            this.writeIndex < this.buffers.length) {\n            this.tokenizer.write(this.buffers[this.writeIndex++]);\n        }\n        if (this.ended)\n            this.tokenizer.end();\n    }\n}\n//# sourceMappingURL=Parser.js.map"],"x_google_ignoreList":[0,1,2,3,4,5,6,7],"mappings":"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"}
+{"version":3,"file":"htmlparser-ClUZ6waR.js","names":["CharCodes","c1","isInvalidCodePoint","codePoint","replaceCodePoint","replaceCodePointXML","BASE91_INVERSE","table","code","char","decodeTrieDict","inputLength","input","twoCharBias","dictSize","pos","readSlotCode","dict2AtomCount","atomCount","dict1AtomCount","slotCount","ngramCount","single","start","length","decodeDelta","previous","slot","off","end","count","runLength","next","references","poolSize","ngramIndex","readNgramReferences","index","startSlot","a","b","entryLength","pool","write","half","source","value","read","readEnd","out","resultLength","outIndex","htmlDecodeTree","xmlDecodeTree","BinTrieFlags","\"VALUE_LENGTH\"","\"FLAG13\"","\"BRANCH_LENGTH\"","\"JUMP_TABLE\"","\"VALUE_MASK\"","CharCodes$1","\"AMP\"","\"NUM\"","\"SEMI\"","\"EQUALS\"","\"ZERO\"","\"NINE\"","\"LOWER_A\"","\"LOWER_X\"","TO_LOWER_BIT","isNumber","isHexadecimalCharacter","isAlpha","isEntityInAttributeInvalidEnd","EntityDecoderState","\"EntityStart\"","\"NumericStart\"","\"NumericDecimal\"","\"NumericHex\"","\"NamedEntity\"","DecodingMode","\"Legacy\"","\"Strict\"","\"Attribute\"","EntityDecoder","decodeTree","emitCodePoint","errors","decodeMode","offset","digit","result","consumed","expectedLength","lastCp","excess","valueLength","isStrict","current","treeIndex","jumpOffset","branchCount","stored","runConsumed","charIndexInPacked","expectedChar","determineBranch","nodeIndex","packedKeySlots","branchEnd","key","CharCodes","\"Tab\"","\"NewLine\"","\"FormFeed\"","\"CarriageReturn\"","\"Space\"","\"ExclamationMark\"","\"Number\"","\"Amp\"","\"SingleQuote\"","\"DoubleQuote\"","\"Dash\"","\"Slash\"","\"Zero\"","\"Nine\"","\"Semi\"","\"Lt\"","\"Eq\"","\"Gt\"","\"Questionmark\"","\"UpperA\"","\"LowerA\"","\"UpperF\"","\"LowerF\"","\"UpperZ\"","\"LowerZ\"","\"LowerX\"","\"OpeningSquareBracket\"","State","\"Text\"","\"BeforeTagName\"","\"InTagName\"","\"InSelfClosingTag\"","\"BeforeClosingTagName\"","\"InClosingTagName\"","\"AfterClosingTagName\"","\"BeforeAttributeName\"","\"InAttributeName\"","\"AfterAttributeName\"","\"BeforeAttributeValue\"","\"InAttributeValueDq\"","\"InAttributeValueSq\"","\"InAttributeValueNq\"","\"BeforeDeclaration\"","\"InDeclaration\"","\"InProcessingInstruction\"","\"BeforeComment\"","\"CDATASequence\"","\"DeclarationSequence\"","\"InSpecialComment\"","\"InCommentLike\"","\"SpecialStartSequence\"","\"InSpecialTag\"","\"InPlainText\"","\"InEntity\"","isWhitespace","c","isEndOfTagSection","isASCIIAlpha","QuoteType","\"NoValue\"","\"Unquoted\"","\"Single\"","\"Double\"","Sequences","specialStartSequences","Tokenizer","xmlMode","cbs","decodeEntities","recognizeSelfClosing","cp","chunk","lower","endOfText","actualIndex","special","quote","indexInBuffer","endIndex","cdataStart","formTags","pTag","headingTags","tableSectionTags","ddtTags","rtpTags","openImpliesClose","DOCUMENT_TYPE","voidElements","foreignContextElements","htmlIntegrationElements","svgTagNameAdjustments","ForeignContext","\"None\"","\"Svg\"","\"MathML\"","reNameEnd","Parser","options","data","fromCodePoint","name","adjusted","impliesClose","isImplied","element","implied","isOpenImplied","slice"],"sources":["../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/decode-codepoint.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/internal/decode-shared.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/generated/decode-data-html.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/generated/decode-data-xml.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/internal/bin-trie-flags.js","../../../../../node_modules/.pnpm/entities@8.1.0/node_modules/entities/dist/decode.js","../../../../../node_modules/.pnpm/htmlparser2@12.0.0/node_modules/htmlparser2/dist/Tokenizer.js","../../../../../node_modules/.pnpm/htmlparser2@12.0.0/node_modules/htmlparser2/dist/Parser.js"],"sourcesContent":["// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\n/**\n * C1 Unicode control character reference replacements (code points 128–159).\n * Index i gives the replacement for code point 128+i; 0 means \"no replacement\".\n */\nconst c1 = [\n    8364, 0, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 0,\n    381, 0, 0, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250,\n    339, 0, 382, 376,\n];\n/**\n * True for NUL, UTF-16 surrogates, and values past U+10FFFF.\n * @param codePoint Unicode code point to check.\n */\nfunction isInvalidCodePoint(codePoint) {\n    return (codePoint === 0 ||\n        (codePoint >= 0xd8_00 && codePoint <= 0xdf_ff) ||\n        codePoint > 0x10_ff_ff);\n}\n/**\n * Replace the given code point with U+FFFD if it is NUL (0), a surrogate, or\n * outside the valid Unicode range. Code points in the C1 controls range\n * (128–159) are remapped to their Windows-1252 equivalents, following the\n * HTML spec. All other code points are returned unchanged.\n * @param codePoint Unicode code point to convert.\n */\nexport function replaceCodePoint(codePoint) {\n    if (isInvalidCodePoint(codePoint)) {\n        return 0xff_fd;\n    }\n    if (codePoint >= 128 && codePoint <= 159) {\n        return c1[codePoint - 128] || codePoint;\n    }\n    return codePoint;\n}\n/**\n * XML numeric character references are the referenced Unicode code point.\n * Invalid values still become U+FFFD; the HTML Windows-1252 C1 remap is not\n * applied.\n * @see https://www.w3.org/TR/xml/#NT-CharRef\n * @param codePoint Unicode code point to convert.\n */\nexport function replaceCodePointXML(codePoint) {\n    return isInvalidCodePoint(codePoint) ? 0xff_fd : codePoint;\n}\n/**\n * Convert the code point of a decoded numeric entity to a string, replacing\n * invalid values.\n *\n * Fast path for plain BMP code points: [1..0x7F] and [0xA0..0xD7FF] pass\n * `replaceCodePoint` unchanged (no NUL, C1 remap, surrogate, or out-of-range\n * handling) and fit a single charCode. 0xd760 = 0xD800 (the first surrogate)\n * - 0xA0.\n * @param codePoint Unicode code point to convert.\n */\nexport function codePointToString(codePoint) {\n    return (codePoint - 1) >>> 0 < 0x7f || (codePoint - 0xa0) >>> 0 < 0xd7_60\n        ? String.fromCharCode(codePoint)\n        : String.fromCodePoint(replaceCodePoint(codePoint));\n}\n//# sourceMappingURL=decode-codepoint.js.map","/*\n * Inverse of the encoder's SAFE alphabet (0x21..0x7E minus 0x22, 0x24, 0x5C),\n * precomputed once at module load. Entries for excluded chars stay 0 but\n * are never read.\n */\nconst BASE91_INVERSE = /* #__PURE__ */ (() => {\n    const table = new Uint8Array(127);\n    let code = 0;\n    for (let char = 0x21; char <= 0x7e; char++) {\n        if (char !== 0x22 && char !== 0x24 && char !== 0x5c) {\n            table[char] = code++;\n        }\n    }\n    return table;\n})();\n/**\n * Decode a dictionary-encoded trie string back into its Uint16Array.\n *\n * Stream layout (consumed in this order):\n *   1. dict1 atoms — `dict1AtomCount` uint16 values, delta+RLE encoded.\n *   2. dict2 atoms — `atomCount - dict1AtomCount` values, delta+RLE.\n *   3. dict2 ngrams — `ngramCount - (dictSize - dict1AtomCount)` entries,\n *      each a pair of slot codes that resolve to earlier slots.\n *   4. dict1 ngrams — `dictSize - dict1AtomCount` entries, same shape.\n *   5. data — slot codes, each expanding to one or more uint16 values.\n *\n * Codes use a 91-char base (printable ASCII minus `\"`, `$`, `\\`):\n *   - char1 < dictSize  → 1-char code, slot = char1\n *   - char1 ≥ dictSize  → 2-char code, slot = dictSize + (char1 - dictSize)*91 + char2\n *\n * Slot index → token kind:\n *   [0, A)                  dict1 atoms     (1-char codes)\n *   [A, dictSize)           dict1 ngrams    (1-char codes)\n *   [dictSize, dictSize+D)  dict2 atoms     (2-char codes)\n *   [dictSize+D, end)       dict2 ngrams    (2-char codes)\n *\n * Both atom dicts decode before any ngram, and dict2 ngrams decode before\n * dict1 ngrams. So every ngram entry references slots whose contents are\n * already filled — no forward references to handle.\n *\n * This runs on library import. Flat typed arrays store each slot as either\n * a plain value (`single`, covering every atom) or a range in a shared\n * `pool` (ngrams).\n * @param input Packed trie string.\n * @param resultLength Expected number of uint16 values in the output.\n * @param atomCount Total number of distinct uint16 values in the trie.\n * @param dict1AtomCount Atoms in the 1-char range (`A` above).\n * @param ngramCount Total number of ngram entries (dict1 + dict2).\n * @param dictSize Number of 1-char code slots; the rest of `BASE - dictSize`\n *   first-byte values are 2-char codes.\n */\nexport function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCount, dictSize) {\n    const base = 91;\n    const inputLength = input.length;\n    // For 2-char codes, slot = char1 * base - twoCharBias + char2.\n    const twoCharBias = dictSize * (base - 1);\n    let pos = 0;\n    /** Read one slot code at `pos` and return its slot index, advancing pos. */\n    const readSlotCode = () => {\n        const c1 = BASE91_INVERSE[input.charCodeAt(pos++)];\n        return c1 < dictSize\n            ? c1\n            : c1 * base - twoCharBias + BASE91_INVERSE[input.charCodeAt(pos++)];\n    };\n    const dict2AtomCount = atomCount - dict1AtomCount;\n    const slotCount = atomCount + ngramCount;\n    /*\n     * Per-slot contents: atoms (always a single value) live directly in\n     * `single`; ngram slots hold -1 there and expand to\n     * `pool[start[slot] .. start[slot] + length[slot])`.\n     */\n    const single = new Int32Array(slotCount);\n    single.fill(-1, dict1AtomCount, dictSize);\n    single.fill(-1, dictSize + dict2AtomCount, slotCount);\n    const start = new Int32Array(slotCount);\n    const length = new Int32Array(slotCount);\n    /**\n     * Decode `count` ascending uint16 values from a delta+RLE stream into\n     * `single[off..off+count)`.\n     *\n     *   code < 89   → delta = code\n     *   code == 89  → run-length: next char encodes runLength-2; emit `runLength` consecutive +1 values\n     *   code == 90, next < 90  → escape: delta = 89 + next * BASE + after-next\n     *   code == 90, next == 90 → double-escape: extra char for very large deltas\n     * @param count\n     * @param off\n     */\n    function decodeDelta(count, off) {\n        let previous = 0;\n        let slot = off;\n        const end = off + count;\n        while (slot < end) {\n            const code = BASE91_INVERSE[input.charCodeAt(pos++)];\n            if (code < 89) {\n                previous += code;\n                single[slot++] = previous;\n            }\n            else if (code === 89) {\n                let runLength = BASE91_INVERSE[input.charCodeAt(pos++)] + 2;\n                while (runLength--)\n                    single[slot++] = ++previous;\n            }\n            else {\n                const next = BASE91_INVERSE[input.charCodeAt(pos++)];\n                previous +=\n                    89 +\n                        // eslint-disable-next-line unicorn/prefer-minimal-ternary -- branches read a different number of side-effecting input bytes\n                        (next < 90\n                            ? next * base + BASE91_INVERSE[input.charCodeAt(pos++)]\n                            : BASE91_INVERSE[input.charCodeAt(pos++)] * 8281 +\n                                BASE91_INVERSE[input.charCodeAt(pos++)] * base +\n                                BASE91_INVERSE[input.charCodeAt(pos++)]);\n                single[slot++] = previous;\n            }\n        }\n    }\n    // Streams 1 & 2: atoms decoded into their slot ranges.\n    decodeDelta(dict1AtomCount, 0);\n    decodeDelta(dict2AtomCount, dictSize);\n    /*\n     * Streams 3 & 4 are read in two passes: first collect every ngram's two\n     * references and derive its expanded length (each ref resolves to an earlier\n     * slot, so lengths are already known), which sizes the shared pool.\n     * Pool ranges are handed out in decode order, so the second pass fills\n     * the pool contiguously with a single write cursor.\n     */\n    const references = new Int32Array(ngramCount * 2);\n    let poolSize = 0;\n    let ngramIndex = 0;\n    /**\n     * Read `count` ngram entries (each = 2 slot-code references) for the slots\n     * starting at `startSlot`, recording references and assigning pool ranges.\n     * @param count\n     * @param startSlot\n     */\n    function readNgramReferences(count, startSlot) {\n        for (let index = 0; index < count; index++) {\n            const slot = startSlot + index;\n            const a = readSlotCode();\n            const b = readSlotCode();\n            references[ngramIndex * 2] = a;\n            references[ngramIndex * 2 + 1] = b;\n            ngramIndex += 1;\n            start[slot] = poolSize;\n            const entryLength = (single[a] < 0 ? length[a] : 1) +\n                (single[b] < 0 ? length[b] : 1);\n            length[slot] = entryLength;\n            poolSize += entryLength;\n        }\n    }\n    readNgramReferences(ngramCount - dictSize + dict1AtomCount, dictSize + dict2AtomCount);\n    readNgramReferences(dictSize - dict1AtomCount, dict1AtomCount);\n    // Second pass: concatenate each ngram's two halves into the pool.\n    const pool = new Uint16Array(poolSize);\n    let write = 0;\n    for (let index = 0; index < ngramIndex; index++) {\n        for (let half = 0; half < 2; half++) {\n            const source = references[index * 2 + half];\n            const value = single[source];\n            if (value < 0) {\n                let read = start[source];\n                const readEnd = read + length[source];\n                while (read < readEnd)\n                    pool[write++] = pool[read++];\n            }\n            else {\n                pool[write++] = value;\n            }\n        }\n    }\n    // Stream 5: data. Each code expands to its slot's stored values.\n    const out = new Uint16Array(resultLength);\n    let outIndex = 0;\n    while (pos < inputLength) {\n        let slot = BASE91_INVERSE[input.charCodeAt(pos++)];\n        if (slot >= dictSize) {\n            slot =\n                slot * base -\n                    twoCharBias +\n                    BASE91_INVERSE[input.charCodeAt(pos++)];\n        }\n        const value = single[slot];\n        if (value < 0) {\n            let read = start[slot];\n            const readEnd = read + length[slot];\n            while (read < readEnd)\n                out[outIndex++] = pool[read++];\n        }\n        else {\n            out[outIndex++] = value;\n        }\n    }\n    return out;\n}\n//# sourceMappingURL=decode-shared.js.map","// Generated using scripts/write-decode-map.ts\nimport { decodeTrieDict } from \"../internal/decode-shared.js\";\n/** Packed HTML decode trie data. */\nexport const htmlDecodeTree = /* #__PURE__ */ decodeTrieDict(\"!}.&u%}'&}*'~!6*)%&,~!J~!J~%L~y<~!R,~~%Lu~~#GD~~#|)1#%}^%}2%+#.##%##%}&%##%'#%##&%#%#'%#&#%#&#'#%%#&#%##%#)%''%&%#%#'%#%%#%%}%%%#%#&(23#%%#&-%0%('1#(##%#'##+%'*.:1}#%#6-+(%'%%#%%%}#L'2351&('%}&/N'(0(/*-%(%%}#'+&T%7.2}#&%&#%#36/5##%&%%#&#%%#))2%%##%&&'0~!#*+&'%1~!%).'3q?&%'1~!.##%6(~!+%%%(Gw'rT~!E#<nA%#jZ~!H%(~!42##~!*31&~!G%U~#)5~#`3~!J~!Z~%]~%Y~%C~!q~!u~#kz~%#~!6'~!D~!U~!?~#T~!c%~!G#'~%7|~!G~!J~!G&~#pb~(Df}#%}*&}#%##%##%##&#-}&'#'&%#.++}%mI,#,@&(}*%}*'%&##&#%##%}&0}#.},U},%}+%}&%}#%##&}B%(}(%}+%)})%##%#&}&%##%&}<%}>%#%&}*%}(%}9%}/%})%}*%}*%}?&}&%}3%}&*#%})%#%#)}#&#-#+*%E%%'%'#%}#*V##&##I}#&&##%&%#&&Qf%%))w/0+&%#(#.%-''''++++7}>%4'',##1,#%#&%##&#'##&#*#9)%&%}#*}%,#+P(%A&%#'&##wSD',9E00#y#@}(+}&%&>~!#~!X}#*}(&&}(&}(,%}%&#+&}#&}I%#%}%)#(},'%#*}4%%#%}(''}#/##(##),%-##%%)#&}(.}&%#&}%%}*&#%},&&}&%}#%*'#%})%}D&}&%}-&}6&#&}-,%}#%})-(~+`~,=?~I9'9%~!,#%})%})%}@%}?%}(~!?~#<~#pP~#BG~#=1#%K+~#?#~%;)~#A~#mF1~#A'~'X%'~#lR~#N~'N~#r~#m#-~#i'?%#'%~#B%##%,%#~#_%#0%~#]732~,w~2+#:&#%&'0%&>%}#>##F+)#%&&#(+_}4&}-%}(&}@&}O7Fdf0@+/v4}&WU##&/0#&'('B#%}.%}'+#%}#%%&#&%#%##+#&#)#6#'#.},%}c%},%#%##%&#&%#&~#>'*-.%##%##%}#%%}%'~#)D1}#%*&~#_%%'(~#S2%'.}#~#=##*'*-%}&'%'##&&~'E%.#&~#M4}%%##&'%#~#O1##%&#'+~#<B%##%%'%+~#;#@%}#&%#&&%#(~#H1}'%'##&&~#?A}&'~#D#%32}'&&&&~#[}'(#%}'~#;C})&}%%#%~#=&%,3}%'(#%%~#^'#&&)#%'~#Y%-~#d-%'~#^%%&#&&&}#~#b~2t*&'~&(~&@~0%~e~3}%*''0})&}+~!9##-}#%-hD*)1fC#%/&/fB#40~!+#)*4~!+~!K'&:~!/*7~!.#~!H~!L':~%x&~!H#~!*~%1~!I#~!+A~#p'~!F~~#-#~,,(~.Z~!V~%;'B'mq-W~!N~%I%#&&#&}#%},%%}'%}+X#%}#&}(%}'%}<%}#%}%%'}'%}:~![)9@~%>~#UA%-%##&~!C%~!-.9:~!1~!-^2/:a~!y,D*J#-5)/4~%23,~#G~!L1~!0X3`~!2+~!!0-~&E~!W~!o,>Y&]~%cZx_&~#O*9#A#'#+I'%#)~!0B*-5A+-((F&*M#)(-7-5+'-3a5Vi~!Y~!?+[)%3),ERHm~!+:D,VG.+)?fB%%*(%)'(#&80%1'8`K8?`+'Z#&O&'H5#*9)A%%5&3))0%39+.*7#()&&*=4@**L)<'_&*+..;(#*+)./&0#3)%')-8(4ixD(&.}%,('aI:,)%,k2231T)I'#/-W7,/'Q#.'Y24+h')37</31&83##&0#),H(?'&?/1##%#&&#%''-%&&&#(&''&#.-'%#%%(,')*'&#&#'##%(%(#%('#&##%%%%('%#%#%%#%#&%##h>w+v<ayvyvcg.uuhKr}g/v|g>u9i[~>g5uI~=RvdwEg;v/g;uk!!TTSx]@RT!U!#!@VBRUU!'UTe-d0c`e&gSdicedFcrdTaqb.kYcAohdYd@a3e+d}dMdtd.aJ#bqcK`dle/e.e'dwdPdodddjbEb}ogd^ofdpduc6j?l%d{drdqc)d7bacOdQ%T#Y)X.sR[yH>6Vyv3[xwLu>vo'!*.[yBacahoj>6Rew3[xqdZa#!a&#^(X-[yG>6Vyu3[xvg3sEr|g.u/Ri9db0T#^(Xa)!-[y;>6Vylg4wKs{JwNZt3@3r=c4Z([xlg;wKt!cpq's@v7A'*a(a+!-a#[y<3Dt?3Dt'>6Vym3[xmg9rxsNJwLZt4~?r?db1T#`-!(Xa,!0[yS>6Vz%NuQs.g4wKtnJwNZtS@3r>c4Z([y%g;wKtrdga8!a(!#&T*Y-Xa#!a0<or[yc3Dtq>6Vz43[y3JwNZtf@3s!Ju}!%Dti:pm3c_%X#tjB5pkd6q!r]u?voC'*-a.a2!0a&a+[yI3DtI3Ds~3DtH>6Vyw3[xx;:s#~<5pKJwNZtE@3r~d`a)!a2T#a.(!+U.X1[yT3Dt`3Dtv>6Vz&3[y&g9rxwzcxstPu.<rAJwLZtT~?r@dZa%!a.&^*Za(/Reu[ya>6Vz23[y1g3sEr}wkg{NuQRg{ci(U#5@b`~,cg#U(2WnH5wugcRh7dX#T(Y,a'Ta!!a,[yZ<]mj>6Vz,3[y+Pv#5ReZKu+=,%!H}7ABwkaS?Rh:BcW(X#<]mrj:ubv/ARekdg%!(!a.*Ta(Y.X1!#sP>Rl*Dt6[y>>6Vyo3Wf*jOvuumvuRgRJuq*!:9<B@bX~3jVv&v@s@5Re[d/rQt{uAvo&a&a*)a2!,0Wf!3Dt0=Bs'>6Re}3[xy~<5s%JwJZt1~Gs)c;&!#2sJkNuXvzq7rxu,Re8dka4!a8(aEZ+a@Y.X1Xa)[yd=Bs(3DtP>6Vz53[y4cX#X&Re:avRe9~<5s&JwJZtQ~Gs*i^rzvdRg+Jv{%!2sbB@bX}kdga,!Za?&^*T1/!a'Dt+[y6>6Vyf3Wf%g/u;s4hGu6?Rh-JvZ,!c%#&RoX54Rivj7uyvf8RgTKvZB%*!2sGh<vu5Rgq<=C::9bb~#dZ#T&Ta6Y.X*Dt>[y93Wf)coZ(T,6VyifluvRgC@95@B@bX~/hFu34cC#T,k/unq8w8Q5RkUklwQuzunq8w8Q5Rk8d/rJu?v8w9)-&!a0a;a&aIWejg3sEr/h1s<DtDJvyZqY5aws3Jvy!&Wei~Hr1:au5@Bag>23E~5c:Z&bX};kKv?w&unuVu5Rjc;>bs)#~@:Rh.=ay<a]C;b`}Vd6s/t{uAvoaxa()!a,a7%-a#a2Dt,[yF2Wo[>6Vyt3[xuNuPRi&NuPwpi#RoWh?vf8Ri%Jv]!%Ri:KvxD!.'2WeAjZu`q9rxu,Re7woeAg-unLq(qA_/*2Wg_g3u5q^9:4E}/jTrxrzv=Wkkd~0UX#^^Xa-a1a5T&a=U1a'*aEa]!a*aPaA-adok[y54Rn>;:p3~Dp5g9rpsFNvZqjg3uJp4~<5p0Pw;5qlJwNZt*@3p1Pw:5p/Ou!5p2JvG'!6Vye=<qnJvh_[xhg3v,Rh3kOwOw-sDuev/Re^dha[a%!%!a+#Ta7)-5TaCaO!aka!a)sf[yb2>Rl!9ARiq5E}Qg=ucRkBE|oJrJ_@Wk~@Wk{JrJ_@Wk|@WkyJrJ_@Wk}@WkzJvO_[y2g-vMRmiKuYC!)&>Ri;>Ri<@3RkNc](X#@9Rk=g5vuRmhKvDB!+'=]meg3u4Rmgd)#Y'Vz3CARmfd`a+!%T'!+#Ta1Ta6TaM-sTDt9[yA9sYd'%Y#s[[xpj:ueunaXRgEjRq,v-vuqdd2'`#6Rev<32@5>:2<E}5xIo9a*X#Y(;5RePJvD_g>vyRgNj8w)v8<wggs:RgXiZt|vjx,hSq3ah!-(~@:Ro/Ou!5RhWj^v(pyw8unRhUdx-UY#^Ua.a3a70!)%UX1TaDa)'omRiRRhE[y:3Dsz=Br,>6Vyj3[xkg6ruwjcqsrPw;5r*Ku]D'Zt-@3r(~?r.i[vwv]dU1a--U#`a4(g/vsRhPOu!5RhLj:rmu9Wo!~@:wdh@g/vsRiTjXuvvNr}:RhBj^v(pyw8unRn]dz1UYa'a+^Y(!aETZalaRY.Ta?a4[yDJw1!#qLsW>6Vyrfzq-pLflpwRe|Js>%!Dt@3Dt&Jvy_[xs~HrnjMuwpsw'RecKu+D#'!t<~Grl~?rjg5u-x,gwp{ah!-(~@:Rg~Ou!5Rh'jXuvvNr}:Rh#cW#X/c;&!#2sLi[v7u7RgpJv)(!iLrxu,Re6j7v@s@5Se[e7d`aW!Za(a`T.a#!a3!&aDa-!9)Dt_=6s+3[x~~DR|h~DS6avhGun5RkZj3w)v-]mkKunB!&*]kb97R|i<ARk<c:Z(6Vy}Juh'!wziMRoS:F|vkLuauJv5vtvQRh1d='T+Y#VyO~DR|jcF#T'7R|g97R|kJv3'!ay<Rj,Jvh&!:ReXcsa6*a+#a#_aIRf9aLRf?c,Z&Rf5Rf7c.Z&Rf;Rf>cQ#%T'p-Rf8Rf=ct#%'(*!,p,Rf4p+Rf6Rf:Rf<d~'Ua%U*^UYa(!a,-!#a4YaTalaEX0a8a<Weo3Dt/3Dsx=Br93Wen~Dr;~<5p<JwNZt2@3p=Pw:5p;Ou!5r3c7&!#:p>3Ds}KvGB)_6Vyk2sM=<r7x'eovA(!hFu1ARf}cV#X&@r5j6rvwQa^Rf3c=Za'wkghJv__g;unRggA53B9=b^}%j6uduo5Jq;!(hIv%2Re`Ou4ARe_e%a#^^^Xa&!a*a2!&a6YaP!*ad!#a:aE/5Rn?[y@>6Vyp;:pE~DrY~<5pBJwNZt8@3pCh=rt3rWPw:5pAJup_[xoNuPpF9c!#'45pD5ARn)d8#X'X*3@rU72s]h>v<<sSjJpqvewOJq/(!hNw'5ReBk0s2u3w/w'5ReE5@Jq.!a+JQ!&WeU23d(#Y&RjG5]jBk!u7w&u0udARjEe#+^^^Ub#!a2/a`Z(agT1!a-a;|@TaG!aS[yV=Re~fow'RguNuPRe?bz#'>RoUWeL>:Cbb|?JwPZtVg6ruRmzJvD'!6Vz(g/vmRh~Jvy_[y(g9voRgyx*cy(#2>Ri2B9b]~9kIw9u7rluJu3Rg]dI#a%UY'@=p%CAx.gQZ&RhwwygtRm{x5g_Z'+ABqR9Woa=Bp&dV#^*Xa'!&@o{g4v]Rk;Jv{!%Rk[wkkiA5RkiwwfUB=x,fUuqC&*!>RfTg8v0RfV~ARfSd;rJsAuAv9wR'ae+/aO!a@aza/a#[yQ@Wg!2Wemg3sEr0JvB_g>uvReWg2v+Re=KupB_+[y!2AbY~-~Hr2AJwD!(h<~El>h<~El?Kun@+_:9b`}Kg-v/Ri3g;vtwyk_9]k_d=&T#*U.6qh@Ab`|K9:H|CJv[!&3Dtex'fDwC%!Rf[9WlMd[(^X,!a%Z06Vz!@WgBg=v~Rgvg,QRe@awd,#Y+jTv|Q~EfWj]uNr|~FRfXdy#Y&^Ua%!aO.!(a)Ua;=!a@aKap!a-,a!Ta]a[rSa]p?[y82sK=Bq~;:p:~<5p8Pw:5p7d'#Y'Wf(;RnRi[u4w&RgJJvG'!6Vyh=<r#ijuuv/sIKuYD'ZtG@3p9~Gr&d2#`(g<vtRgFj`u5w&rqpxRf2CJuY!+:wfnTOu!5Rg}jNs1ucv&RfwJvA!&3@q|BDcC#T,k/unq8w8Q5RkTklwQuzunq8w8Q5Rk9dga#!a'!a=#a0!:+Tb*b@aO.a4!aba8aFJv^}?!VyR~Dr<g;u%Rn.~<5p[x'e`wNZtR@3p]Pw:5pZhNvjBp.woe_g5u-r4JwF!%DtO3:ooc7&!#:p^3DtpLuGw(!+%)Dtk6Vz#2sd=<r8d'#Y([y#<x3gJt`w@!)%}MRiowzikRij=]ilxAf3,U(#B2Rf#g0v-Rm[ck{`U#]giKv3>)!&6Ri154s,KuGB_%@r68r:dJ|t`#X(9<E|u2@H|rx3gJu?w'!+'1Nu7Reg4=H~+9<wxgY95Rm]xLggZ-`(X}U2:Ri4h<uOawRmsJv__5@bb{jbV~3dka#a'a]!,#a+U=a>b6a3b%!/aKa/)!arwve^VyJ;:pR~DpTg3uJpS~<5pOPw;5qmPw:5pNOu!5pQJvG'!6Vyx=<qoJvA!{~Jup!%@qk7Rn/KvyD!}''[xz;>wkh'?Rh,x8gyt`w5D!&),(SgyccRgztJ@3pPB5p#d'(Y#<]mmifubw&RgoJvE&!82s^JvF&!8Rf,ADb]~;x=h'rNu]vK!,%'*0RnORh)4Rh*AqQg-vaRnNg;wHwkh'ba~4cE#Ta*x3gctyw@'!+%RnFRnD<4Rn@hFvK5RnCxWg[#`&a0Ua()`1Rm75Rg[c]%X#qi8Rg^NvdRj>BwzgZauwji7Rm6A4wgg]d1#&(*,.0a#Rm;Rm<Rm=Rm>Rm?Rm@RmARmBe%#^^^Xaea?aC/b+(,!a+a#!a/!>a&Ta<aKbD!2wphBRnk[yPw}hE|.=Br-3Dtm>6Vy~g6urRf.x,hPrNav!%'RnqRo%Ro#Nu;q[Pw;5r+JwNZtM@3r)d'#Y'Weh;xChL#`&RnmRnoKu}>%(!Rne~Bs-;2wjcussJv+'!aYSO}6@B<5?ba~8LrNvj!.%*ROwungw~ng~:9;Ri^>wtnig;wHRnixDh@|(UZ.x1h@|)!#:2<H|*xHn]#-UX'3Ro)z=iT}6ARns=Bwsn_wpnaRncw]aR(#UXa&Ua*a/=]iPd'#Y&Ro'WnXf{QRm2hNvj]nZd`'T~&1`{|`#9b]{}c:'!#Wl{>@=be}]?cl{{U#:5Abb}Jds#^YaF!a*b4a#a3aPa>&Tb!bH!*a_!Eau?/a&RjY<]gj>6Vz*;:pe~DrZg,QRj1JwNZtX@wihspcJvZ&!VyX9WmOJu|!|N2WmHJvh&!]ht~Bpbcn&T(!#RmQ<s7Nu;padH#X'`+WmJ@>RmKCARhnKup=!)&Wf+:RhqNuPpf9c!#'45pd5AwghpARn(Ls@w!%,)!RmP@Wfe<E|IJva!&WmNg8vsRmLd`*.`#Y'Xa!axRn*]hrA8Rhug5s@rXg8u!RmMd8#X'X*3@rV72smdI*#UY&RmICARho~GsgxVgd)Ta'U-Y&Xa!T#RnEWnA@Wffg1uDRi0hFvK5RnBxGnG&#`%owp)@wsf+bX}Ze-*1!a*^^^Ua|!#a.aq&Ya2!a>.a6!a:aO`aJDtL[y`@Wg#>6Vz12@wzoYRoZNuPRi!NuPRhzg=ucRi,@=b`{Yg=ucRi-ACJvB!&Sh[ebSh]ebi`wUuFRm4Jw2_[y0JvB!.<Ju(!&SoG}6Shd}6<Ju(!&SoH}6She}6Kur@._g5vHRieJvx!{L2G{Kx6gd'T#?Rh82Wi5cZ#X(g1w)Rm5dW-Y(Ta#!a)!#aYa=wnfE=su2>>bU{0j9udv:<svj8uQv-7RgHdE%#^'sq9sp=>Bb_{TJv`!&g/r|snj6v(us5d,#Y(56H}[978H}]Jw5!&g1rushJvB!+j;v{u5?zDhd}6}bj;v{u5?zDhe}6}ce*#`(^^^a[aea!=!a6a*aoXb1a.!aAbL!b>,b'aL!aV@Wf|2Wlg3[y/JwNZt^@3piPw:5pgJunZou3@rsJva&!Vy_g<v~Rm#JvG'!6Vz0=<r{Ju{%!:pj@WfsiXuJu3Rm:JvZ&!WfA~Bph@c4Z&Dtwax5rubx(#:awRk1@d,#Y&RfjRfid1#,Y(@Wfp2Wlrg5s@ryKu[@!,'=]ig9wlk?Rk>g5u-rqJvy'!@9RkQcH(T#=>Ri~@<wkj(Wj(KuZB*!&<7rw@9RkRcH(T#=>Ri}@<wkj)Wj)dg(Ta2Xa9X#`-!a*CARhg@@=I}d9x;c~#X%so=<sj>2@@=aybb}XjWv0Q~EfEj3vLv;<d,#Y(56H}`978H}_dgaPaFa'a/!#a3Y0a_a;a|!1(a7-[yE3[xt;:pJNvZrrg3uJrvJwNZt=@3pIh=rt3rxPw:5pGOu!5rpJvG'!6Vys=<rz@c4Z&Dt(ax5rtJvZ!&~BpH@wsfNg-vaRlNci*U#=<wei<F}a5@Jq.!a*JQ!%@qZ23d(#Y&RjH5]jCk!u7w&u0udARjFd/prq=tyvpaEa(a:.!a1aZ(@@=I}:9wpd%=<sX55w_h}@@=I{t=ay<aU@@=I}T=ay<2@@=I})?C9:9au@9Cb]}DP~=x-fAZ(2Wl1=ay<aU@@=I}>5@d##Y+jTv|vV~EfFj]uNpn~FRfGdgaK!Z2&!a8a-Tb({E!acTbM*!a(DtY[yYd'%Y#sl[y*hHvh>Re5x2c{Z}.j4uCvcawRiMd+#X+_x&d!},<5RkX;2Hzw@x,gavfB-!{CcF&T#Roe;RodwWbBg5urRgaKvHC*_6Vz+<4opieuew&Rmq@d]&Y)X,T#X0Rh}<BqP=4qS9:ReMg/ujReNJw0!/<Jui%!bd{kawwnemRelAxUa?a3#*.&UX(Ya+a/RhvRnQ<o}9Wmtd-#Y&RgSRmw9;Rmxay=Rmyg-vaRmuxEhSrNu,v-voC!%(aR.a(a7+1Ro1>Ro5CE{A9b]{@;5x#eO{:g;urRi+KrNA!%(Ro3>Ro79;Ri_Ku@>{;&!x%gX|{KunA_+g5QRj/g3u5Rj#g>uERj%wio/xRhS&!,!#^1U}wba{8>>@=be}qC@:D5ba{7Ku+A&!}x?ba}t>>@=be}se(aA^^^Uat!b0#{pa+awUazbGa#aLb9bgaWac'a5TbS=Br!d1#`%scp_Jvl!#rT>Re0JvX&!VyN=H{Fcm#U&:pY=ReaJv2&!]h0=]nUJvG'!6Vy|=<r%JrM_=]h2@Wlud'#)U'Wf'b]{i=]h/Jvh!&~BpWg=v]RnMx+ny#'Nu;pVwjnu=]nwxJnx,T#`&Reqwjnt=]nvieu9vrRjLLuYwP(#+!th@wih5pX~Gr'g5v/Rh4KunA'!-CARnP@wwiN:Rm_9x'cvw>!|l=<saKvAA!0&3@q}>w^e1bp#&Re2Re3BDx7gH#T|f5H|eKuZ>!%(:qNAH{]Jv6!+3B2B9=b^{X<5<B92:E{ZLvhwA(a;a%!igQuyRmad+#Y}m@3Rh5d8#X'X*:AqUAHzmaxwbh<aXRnVcF}RT#Nw&cj#U(BWnug/vsRntdka)(a3+.Zb7aYYan1!bVa@Xa}[y^@b[{G=H{+hFu73Rj&Pv#5ReQcK%T#sig1v{Rj'Ku+D#'!t]~Grm~?rkKuMB!01d5#`'Vy.ta3Dtu~Hroc8#'{^45s85AwZbP&!#Rn!wghxWn#KvEA!)&2RlA2RlBx:h|#(T,=]j09Wobz>x]z/@awRoTd+#Y(az]hFhCrm4d,#Y+jTv|Q~EfMj]uNr|~FRfOdCa!Xa9_X#@<plJvf!%b`{(9;Rgwc;.!#2x7cw#T|UDb]|T5Ju={(!=@E{&Jv)&!Ab`{'awJvf!~*>>@=be{#KuY>!+&4Ezyi[ugv&RjIdea+T)#UXa&T-T&a!Rh9auRmW=]kLg5vuRn+g3u4Rn-Ow6ARn,hHus5xNk?#UX(U~)/g8v0RkD~AwkkF?Ri.OuNBwkkA?Ri/d|a2`a*^UYa.!aBTZaTa'Xa;!(!2!-a#b2[yC>6Vyq3[xr2Wi?g1rusVh%s?DtF~<5rbJs;%!DtBfswKtCj[uvuSsEu3RgVx3o:u+wN'*Zt;@3rd~Grh~?rfg8w)Lq)qE&-a%!>bI|`jWv0vV~EfCjTv|vV~Ef@j]uNpn~FRfBcK#T']gWNu7x,k7q4ai(0!hHv8<RhmkMu9vrsBuev/RhlCJvB!,g<v{wchh~@:Rhji[vrv{wchi~@:RhkdS&a5UY#Ta!RgPwwiI5BwciI~@:Rh`x'iJvj'!5]iJPu8Bwch]~@:Rhach)U#h3rp]gLh@t|Ax,hTq3ah!-(~@:Ro0Ou!5RhXj^v(pyw8unRhVd|)`,^UYas!a?/a2Z'a^Ta{Tb7Ta(a#!a,Wf&9sZ3DtAadamov=Bqt3[xig8vsRm~>waiL2b`{QJv*_Ouv2qgj<v]v2BqfdR'X*X#Y-@3qr~Gqv~?p6hHv-]glPup5Lq+q?_%*b_{qF{n9b^{rOu4ARhpKvCD!+&~Bqp:5Dbb}nwoiKl&unuTuBv]v+ueunaXRf0=Jvh!0nKufu8v1w&w7q%w&uHrz:Rgnj5w,uxDJq/(!hNw'5ReCk0s2u3w/w'5ReFd>Za&!*UaA=<wkgsRnSJv^!%Refifw3vyRgOKu_B'!,<]gkiiu:w&Rh<=C@a^<B57@2F{[<B5@aW:=3away9A5aW=<B=C@a^<B57@2F{Ie-#`(^^^bCara.b8aza6!/bZ,!adTbnTbOb+aFaS!aAT9@Wf~2Wli3Dtl2@d,#Y&RfnRfmJwJZtN~GqyJva&!VyMg<v~Rm%iXuJu3Rm9Jv[_=]ih9wlkDRkCd1#`(@Wg>2Wls3cH#T(@<Rj*=>Ri|b~'#23s9h<~El.d'#Y&Dtxi^rzvdRl#d*#U%(o|B2s`hJwSaxRmDKv4B&!1:Rmdd5#`'Vx}to~Hq{x'f1v3(!BA5ba|bJv_&!Wfug1v]ReIdO+U/Y#&G}-8wze=Rh{g1v]ReHg/uQRf/by#)ibQwERl/cH#T(@<Rj+=>Ri{cNu+vlax-!(#a0qa9<Rii2;;bU{H;x<i=&X#Rk`<4wwi=C9H~8xAI(Y#<azRi@45wXI<B9;5bb~7dL(X#Xa(+!aL6Vy{g5QqOau:5au2@ay547EzbxOcU(UX-T#Ta#:Cbb|A?wjh/b_|SOw6ARgtihr}u7Rhy<d1#T)X1@@=I|~=ay<2@@=aybb}Sj3vLv;<d,#Y(56H}A978H}@dGpvs@uAu`vcw9*!aFa+ai%(b!aXa8.a?a[ozWey=sU2@G}Nch&U#Rf_WexKu+D#'!t:~Gr`~?r^j]uNr|~FRg*j^psurwJt|RmcKv)@&!)7Rkv~Br[@wxfO:Rl3co#U'6Rezj_q#vIuavjRltwzeyh@vr5JqD0!>aY?C9:9au@9Cb]}9cl#U*5;5<H||jbuus1ucv&Rfvg1v~d/pppzqFr^a--a~!aMat1(hFv;Wiz@@=Izoj5uuv-7Rix~Cw`fk2WlVcZ#X,k)u3vWs@u2]ktg;wEx'fBq(_2Wg/jTv|vV~EfoJv]!15x'hzqG!(P~EfU~CRl_j6v(us5x4i-#T(2WmZ?C2F|d>Kq<aj1!*jTqIsBv=Wl`~Cw`fi2WlWj`v0u*~>RlR=c>Z,k#u3vWs@u2]kr<c1Z+jTqIsBv=Wla~Cw`fm2WlXdmb3!a{(arZa`bkTa%TbQTa-a9+c'!aM!/[yL=Bqug.w'RifhFvyDRj.g>vgwyk^9]k^Jv3_@WfbAARkhJw2_[x|JvB_wkoIRoKwkoJRoLd'(Y#<]gm=<9<H|yd'%_X#skDtb3awwqkgNulRkgdB#^',9:p'hJwSaxRmEBwVb8@4=H|qLu+w50&!)@3qs~?pU>Awwn;;Rn=c:Z'ARn<=<qwKvC@!/&~BqqJv6!&]eVb^z^xRge'/a%+^`#Sge}6<4Rn3=]n0Pw2>Rn8Jw0!&>Rn:>Rn6cY#a7+!a&=<wkaNw~h3z_c5Z{=wjh#=]nLKv^D!&)Vyz=bW|swYb<WetcG#T(2wxa@qVx@gD#Y&b^|V5JwG&!5bb|pg/w&RgD@x=kHs=uAvn!a%%/'+RmSRh694Ro`g-vaRmRhHv-]mlxCcS#`&ba~.5cD#Ta)P~=d,#Y(56H{>978H{Dd_#{2^Y%_+qbbb{6g3sERhsbU{?dfa.,`a(Xa<!aiX#(55RiG54RiHcI#T'WiU3RiVNvdwtfcRlKNvdd,#Y&RlHRlExQgf.1*^T'X#Sgf}6Wn4=]hfPrk>Rn7Jw0!&>Rn5>Rn9Lunw?&a2!,5<oq@@wqfdRlJj5Q~=d,#Y(~ARfcOuN]fdDKw;ay(}i!547E}j?cI#T(@5bV}iCbV}hdv(^^Tb?a40,b##Tbo!a*bR!a<b|a/!aKai!aU[yK=]o^g:v>ReGJwPZtK<7Rh+h<~El,Pv#5ReR@awwxjCg,ulRjDJv6&!]j!z?aQeeg>w=Sh<eeJw;!&axEzOg,Qosc!#*:wkeJ]eJ>x'h-u(!%Ro.w~h.zPdNZ(X,Ya![x{;9ReY;wkgxRiF:x?ap#Y&RmUg<s2Rkod]+UY0TZ'!a&A9sw<=bczLNvuw{gqzNhJwSaxRmCKuLay!#&s_Rf-55b^{uJvZa!!c%#(55Ri654wmiu5RiuawLu,vp!+}^%b_}Y9;wkgxba}o>A9:=b^}zKuh=a''!3awRk3c*'!#aHRk6c+Z&Rk5Rk4Jv)&!awRjSawd9*`#0?C2@EzMj8u<uJ5RmbjQrquJu3x,k>uq@_+=ayb^|W~ARkEOuN]k@7dhzV^X/X&a-#zRzSb`zXcJzTT#2WkVKvDBzW!%FzY9;5bbzWjQrquJu3Jw3%!b`zU=ayb^zQd:#X(T-a!6Vyywxh}=b]{Jg=u1RiAdGp~qHtzv!w(wA+a+a;<!aJaYai'anasb(=azRmV:Cbb{MLq2vb!%')RjuRjrRjtRjqx3jnqCw3!%')Rk(Rk+Rk&Rk)Lq2vb!%')Rj{RjxRjzRjwLq2vb!%')RjsRjpRjfRjex3jcqCw3!%')Rk'Rk*RjkRjl9<CbbzfOu4ARhxLq2vb!%')RjyRjvRjhRjgx=joq*uKvb!%')+-Rk.Rk%Rj~Rk-Rk#Rj}x=jdq*uKvb!%')+-Rk,Rk!Rj|RjmRjjRjidAq&qKs@uAv8Aa.'*-a@a&0!aM@a5[y73Dsy3Ds|3Dt):wxgI2sHJwJZt.~Gqxwsf0ikrzt}Rl0Jvy_[xj~HqzKv_A|D!&WfP8axRoVcf,U#k(v]v+ueunaXRf1Ju}'!g8u#Ri=jQw!sCunLprq>!,')~<5qeGzq9F{W=c##%s5au:5aU3CBE|;d4#X(D!a&6Vygx(b;#(=]ed?C2F{N<capoq2r[a&!aPa9,'Pw;5s:@@=I|,55w_h|@@=IzcP~=x'fCqB_2Wl2>aU@@=I|1OuNBc1Z+jTqIsBv=Wlc~Cw`fl2WlZ~AcTa%!Z+jTqIsBv=Wlb~Cw`fh2WlYk+uNqJsBv=WlSg,u3dca3#UXaMYa)TaB-=cM|7T#<bI}l5@B932:aV2G{BOuNBJq:|M!5Ezt=<B=C@a^<B57@2F{v>cB{/T#=ay<bI{3Jv6!a.6BKq0ah&+!5E}HP~Ef{978BaU@@=Iza<7d#.Y#978BaU@@=IzH~AJq0!(@@=IzG978BaU@@=IzFe,aU*Y&^^^bvJb,b:bFad!a,c2Ta>aL.bo6!a#CbTa'T#Re{2Wlh2@G{yg6t~Ro_NvdRfticuRQRllJv3&!x&c|zs@Jw3!%RflwpfkRlpKuL;%(!Re<@G|C2GzdhIvuBwgjAg-u0RjAKQB%!(GzZ@G|5NuuRl7d='T+Y#Vy[g<v~Rm!==G|>JvA!)@wma=]m1ifuaw&RmnLs@vT'!|/+[y,g:v>ReTJw1!#qX=x!eC{bLu+wT&)ZtZauq_~Graci&U#F|89:r_Lupvq!.)&2RlG8RfaC=x!eF{_h?rpWlmd&'!#X|&]k::xJey#`'T|+<E|&2@H|%dE#(^,g;u.RiEg6vjRiC9xCkA{O|zY#g=ucRmXKs0@!&*@G|m@awRknJuh!,3d(}gY}eJvj!%Rm):Jw3!%Rm+Rm-Ls0w(&!a(a#@b[|6cZ#X'7RkxWgAOu4ARn'dH'U#Y*Vz-Wm'CARm}d]*#a%^a*T'aK!a<9bV{PC=p*Jw4!&SgxcbB5r]idw(wBRmF7xFkt#&`(Rm/Rm8E|!JuY_9:Rl5=wrgr2:bbxd@xXfB(a*#T+!.X0X1Ta/a'T&RlDRfL>RlyARl9b[z[>RfZ:RlL:RfRwlg/ARl;9;RlxKv,A/!%7s69<74=BA5ba{-8Bde#`a<XaKYa1,a'P~=wxfB2bZ}}?C972@@=I}r8@55B9;5bb}G978B2@@=aybb}3j3vLv;<Jw3&!>Rfk=ayb^}4~Ad1#`*@@=aybb{w2@>==<bbz]dx+UY#^UaF!a9!bB'Ya1.!ajXa#%olRhD[y=3Dt#Ov5BrHKuMB%!(Rf^Wep~HrJwkiQjKr|~FRg)Ku+D#'!t5~GrF~?rDdV)UY,Z/_7RkuG{<~BrBg,rlsO:235B@bX}|d?a1!#`(6Vyn5@d##Y+jTv|vV~EfIj]uNpn~FRfH7Lq2vb1!a9-978BaU@@=Iz9978BbU}#~AJq0!(@@=Iz8978BaU@@=Iz7~AJQ|}!978BbU}!JvkaK!AdUa21-U#`a+(g/vsRn~Ou!5RPj:rmu9WhOjXuvvNr}:RhAj^v(pyw8unRn[kPr}p|u7vwv]RiSBd;pppzq@qHQa?(b.!a.a`@.|xa(hFv;Wiyj5uuv-7Riw~Cw`fg2WlU978BbU|wOuNBJqG!(P~EfD~CRlQcZ#X,k)u3vWs@u2]ksg;wEx'f@q1_2Wg.j]uNpn~FRfqJv]!15x'h{qG!(@@=IzK~CRl^j6v(us5x4i,#T(2WmY?C2F{1>Kq<aj1!*jTqIsBv=Wld~Cw`fj2Wl[j`v0u*~>RlT=c>Z,k#u3vWs@u2]kq<c1Z+jTqIsBv=Wle~Cw`fn2Wl]dn1#c(a(b^a2!b/bAT(bj!aDa7bu,a_a{c0!2T0g:v>ReD2@G{42@G{5~DpM~<5rc=Bx6i>{RT#RnI@zCx]y]z:2Jv[!zr5Awyk]9]k]dD(Y+X#6Vz.g=wKtgwhaCwgmTWj2Lu,w%_+/[y-B;b^xeg3u3Rj-2@bX{*KrJ<!+'@Wg(g?QRlC@Jv`!%b[zIwsfII}8JQ_@w|kW|=Jv(%!AqcOuNBJvEzh!bYzjLs@wP#(0!oy@>RkdJwMZtc3Dtd@BcG#T'9bWxg2@2Fznd*#Y+;2x'c}w<zizixNgwa#Z'U+!/!a'!a+w~g~z6wcn{Rn}wcnzRn|5Rh%=]nJg5vuRmvNvdRlvcprJu}w*az*a#!%.a.'Bot9qT]kj@Wg'ay2Gzv@Jv`!%b[zEwsfHI}1;ck#Ux`<Cbbx_Lu+w!a&0*!wko*wwo,So,}6Juqxf!E}PigQuyRm`d3(`#8>Rn%:A5B;bZ~%KvhCa!a2!x>k7#Uxb@b{#xaRk7Jw0!)>wwhlShl}6>wwhmShm}6CJvB!.x'hhvj{!!5Bwkhhbaz}x'hivjz~!5Bwkhibaz|xEhTrNu,v-vpD!a%&/)a3a.,%Ro2t[CE{)@3re9b]{%wjo09:rgc:Z&Ro6=<riifuaw&RmoKrNA!%(Ro4>Ro89;Ri`dSaL'UYzxZb)7Rka3xRhT&!,!#^1U}vbaz{>>@=be}yC@:D5bazzKu+A&!}{?ba}y>>@=be}wxBh[t`u~vJvr!%a!a()a,a0a4RoC=]o;Ju(!%RoGRhdwjh`=]oAg>w#Ro?g5vuRo=NvdRl|Ku]C.!&;RoEJvB!%RoORoMBx'h[v+_?w~h`}~5?w~hd~!xKh]oiptu-utv.vp!#%&a30a@a'a+(a/aOp(o~p!RoDJu(!%RoHRhewjha=]oBNvdRl}g>w#Ro@g5vuRo>c[#X']o<CauRoRAd-#Y':RkpauRoQKu]C.!&;RoFJvB!%RoNRoPBx'h]v+_?w~ha}t5?w~he}ue!/UbhYacXaW^Tc&a;b:a-c/#b&aja1(!cL+!bKbt!bmcRc9aIc?8[yW3Dtt94Rg`Jv}!&SiRMzBhEebShEMNuPRe>x7gL#TzuwjirRipc<Z&>on;>z=h-MSh.Mwqczx'a7vj&!>Re4@=ResJt__NuPRi*NuPRi)j]uNr|~FRfzKrJ>_+@Wfy@Wf]2WocKrJ<!+'@Wg%g/QRl@@Jv`!&awRl<wsfFIzgLu(w*!.*&ShBMwvhIRhI9;RhNx1hK'!#Sn]Mx1hK~0!#:2<H~7cNu+w7D*'1ZtW>Rn1~?rOc:Z&Rn2=<rQ<7wjh&=BSnLMc]#X(6Vz)w[b=a!U#9wzgMc3#&(RgMRitRis<x,gKt`ax!&+SioM=BSilMc3#&(RgKRinRimKurB,!&SiQMzBhDebShDM6BJQ!(P~Efx978B2@@=I}WLrJw!!,a*&@G}O@9wkibRid@@x'fKwC!&SlDMSfLMjUv~Q~EfKKv3@a+!(hFv-]mpx/hYZ(C5RiWz<o/MwkhY?So/M@x,gbvfB*&!SgEM:SoeeehFu3:Rgbda(,^TZa)X/7Sg[eb:2RgI~BrMC@wgkc:wwkcRerx3h(uUvK!&*,SnOM4Sh*MArRg;wHRh(x=h;rJvPwI!a4',a'0@Wg&=BSh/Mg>w=Rh=g3w*wwgGRgGcW(X#;Sg}M2Gzk@Jv`!&awRl=wsfGIz`dKZ*T'Y-:RhR7RhQg5u-p`j6v(us5d,#Y+~Awkia?RicOuNBwkibba}Ld6p~tyu_vbAa'a+!a/'a3aEa8a!>Sh,ebJv{!&Sh@ebSaReb9;SgwebNuPRi(NvdRl)NuPRi'hHu^<Rm^Jvv_@Wl(g;u1Si/ebKu'B&!*Sh?eb@Wl'z@aPeb95Si.ebcpputyvjB)!,&a+0a%ShAMWeK@G}C@WfJ9;RhMwvhH9w{ia}ix,hJvRA1(!zAn[MRhHx1hJ~*!#hFv(BSn[MBJQ!(@@=I~'978B2@@=I}2db.Ua<'X}+T#a0XaG2G}E;wkg|wuh!Rh!x,hZu,@)!&So0MVy)C5RiXACJvB!&5RiY5RiZg8w)cG}*T#2@bU}=KsA>(!a.3wkhZba~(x,h^u(A!&(SoCMRhb5Bz=h[eb?w~hb~6x,h_u(A!&(SoDMRhc5Bz=h]eb?w~hc~6e)aA1T#T,^^^c-bMb&blcPaP(a/!0!bA=b5c@a(!bfbrc#2afwmhARnjwchORnp2Wlf3DtsNvdRl-2@wpa<]m0bx(#:awRk2@Jw3!%RfhwpfgRlnKQB%!(G{V@G|'NuuRl6d='T+Y#VyUg<v~Rl~==G|<Jv+'!aYShC}6@B<5?ba~8@Jw3'!g2QRljhLrpWlOd+#Y'g.w'rIg>w*wgj@g-u0Rj@Lu+wT&)ZtUauq]~GrGci&U#F|39:rELrNvj!.%*RhCwunfw~nf~:9;Ri]>wtnhg;wHRnhx3hDs@v~!/+'@Wfr@9RkSNu&Rlo=@<5GzoKs0@_+@Wl+@awRkmJuh!-3d(}pY#qWJvj!%Rm(:Jw3!%Rm,Rm*de&!1U-U#`)Re;@G|.@9Ri82@wjfvRlq=@<5GzpLvOvr!).&2RlF8Rf`C=x!eE{.Jw3_g2QRlkhLrpWlPde(!#U{s,UXa*Ta'[y'g:v>ReS;x0PZ&RnlRnn~HrKJw1}f!=x!eB|2w]aP(#Xa&a*Ta.Ua2a7=]iOd'#Y&Ro&WnWg;u.RiDg6vjRiBNvdRlzhNvj]nYJuW_2Wm3x)kFze{9d])!a.!,Y01!#&aC!a3RndC=ox~BrC@2b^{pg,rlse7x'ksuq!%Rm.E{xidw(wBRmGx9o+)X#wwo-So-}69:Rl4@xSf@a#XZ'X)X,Ta(/ARl8b[xc>RfY:RlI:RfQwlg.ARl:9;Rlwdn'#^XafaQa1X1TaHTa)@b[{zcZ#X'7RkwWg@Ou4ARn&x)kG#{,g7u/RkGdH'U#Y*Vz'Wm&CARm|bx#(A]gUbUzJj9Q~=d,#Y(56H}l978H{U7d,0#U*2>ABb_xZ978BbU{e~AJQ{g!978BbU{hxMh?ad{oUYZ.x1h?{l!#:2<H{mx3n[t{vl!,&a%3Ro(z=iS}6ARnr=Bwsn^wvn`Rnbd`*T}B0!#^X'BG{c9b]{a>>@=be}F?JvS!&BG{d7BG}(Bde#`a1X,Ya@!a'P~=wxf@2bZ}I56B2@@=aybb}08@55B9;5bb}<j3vLv;<Jw3&!>Rfg=ayb^}&OuNBKuLA!)a!P~=x#fD{f2@>==<bbzl?C972@@=Ix^d6rSu,v7w*C(0a)a6#B+a%!sQ[y?3Dt%3[xn~<5rLOu!5p@Ku+D#'!t7~GrP~?rNKvlaya7'!h+v-5qMg=t|cd,U#5AAaa5Abb{S@52B5@a[@52B5Gx[iXueu;d<#`a(!/549C;ag>23ExY5@Dah89b^~689Jv)!~2b[~1Lv'w(%*!a#bX|aPrmawRe]keu7uhv-q6rxu,q`xTo]/a5aU!bNaDXbi!b-!ao!b<bwA!#5@B932:aV2G|:d-)Y#hJrL>RhG<7@C5<H|_=Cau:5aj5@B932:bJ|ng>vIbs)#?C2F|9jPv0w.vISh-MKvUaz(.!9ABbb|[5;5<H|Eg>unwfh;9:4E|YjQsBt|vjx'hYq3!(?C2F|J:2<BaY?C2F|GOu!5x,g|p{ah!-(?C2F|c9:4E|OjXuvvNr}:Rh&i[w*t|cd+U#jJvsu)vsSn~Mkfrmu9p}u7vwv]So!McW#Xa!ax5@A5aY:5;5<H|>kJv~vYrquJu3x4ib#T)2@SmZM?C2F|Bj:rmu9@xPhI(a*a#U#`a3-5Abb|L~@:RhK9:4E|0@52B5G|#C::aY?C2F|-:2<BaY?C2F|.5Jvk!a)javYrquJu3x4ia#T)2@SmYM?C2F|HAxPhH(!a#U#`a*-5Abb|4~@:RhJ9:4E|R@52B5G|F:2<BaY?C2F|Sc^#Xa2j=Qq5CJvB!-g<v{z;hhM?C2F|Zi[vrv{z;hiM?C2F|XKsA>!a)-g<v{z;h[eb?C2F|]i[vrv{z;h]eb?C2F|^iZu.vix,hZq3ah!.(?C2F|QOu!5ShXM:2<BaY?C2F|P\", 13_494, 2713, 49, 25, 61);\n//# sourceMappingURL=decode-data-html.js.map","// Generated using scripts/write-decode-map.ts\n/** Packed XML decode trie data. */\nexport const xmlDecodeTree = /* #__PURE__ */ new Uint16Array([\n    512, 26_465, 29_036, 7, 0, 2, 4, 116, 24_638, 116, 24_636, 8693, 29_807,\n    24_610, 621, 1, 0, 0, 3, 112, 24_614, 111, 115, 24_615,\n]);\n//# sourceMappingURL=decode-data-xml.js.map","/**\n * Bit flags & masks for the binary trie encoding used for entity decoding.\n *\n * The trie is a flat `Uint16Array`. Every node starts with one header word:\n *\n *   15..14 VALUE_LENGTH   Number of words the value occupies, +1.\n *                         0 = no value; 1 = value inline in bits 12..0;\n *                         2/3 = value in the 1/2 words after the header.\n *   13     FLAG13         If VALUE_LENGTH > 0: semicolon required (\"strict\"\n *                         entity; `;` is never stored as a branch).\n *                         If VALUE_LENGTH == 0: this node is a compact run.\n *   12..7  BRANCH_LENGTH  Number of branches (or run length for runs).\n *   6..0   JUMP_TABLE     Jump-table offset / single-branch char / first\n *                         run char (see below).\n *\n * Branch data follows the header and any value words. Its shape is selected\n * by (JUMP_TABLE, BRANCH_LENGTH) in the header:\n *\n *   Single branch  JUMP_TABLE = the only child's char, BRANCH_LENGTH = 0.\n *                  No branch words; the child node follows immediately.\n *   Jump table     JUMP_TABLE = first covered char (> 0), BRANCH_LENGTH =\n *                  table length. One word per covered char: 0 = no branch,\n *                  otherwise the child's offset from the END of the table,\n *                  +1 (so 0 stays the no-branch sentinel).\n *   Dictionary     JUMP_TABLE = 0, BRANCH_LENGTH = number of branches.\n *                  ceil(n/2) words of sorted keys packed two per word\n *                  (low byte first), then n pointer words storing the\n *                  child's offset from the END of the branch data.\n *   Compact run    VALUE_LENGTH = 0, FLAG13 set. BRANCH_LENGTH = run\n *                  length (3..63), JUMP_TABLE = first char; remaining run\n *                  chars packed two per word after the header. The target\n *                  node follows the packed words immediately.\n *\n * Pointers are end-relative (rather than relative to the pointer's own\n * position) because that makes the common \"child encoded right after the\n * branch data\" case a small constant, which compresses far better. Offsets\n * to already-encoded (shared) nodes wrap via uint16 modulo arithmetic; the\n * decoder masks navigation results with `& 0xff_ff` to match.\n */\nexport var BinTrieFlags;\n(function (BinTrieFlags) {\n    BinTrieFlags[BinTrieFlags[\"VALUE_LENGTH\"] = 49152] = \"VALUE_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"FLAG13\"] = 8192] = \"FLAG13\";\n    BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 8064] = \"BRANCH_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n    /** Bits 12..0: the inline value of a VALUE_LENGTH = 1 header word. */\n    BinTrieFlags[BinTrieFlags[\"VALUE_MASK\"] = 8191] = \"VALUE_MASK\";\n})(BinTrieFlags || (BinTrieFlags = {}));\n//# sourceMappingURL=bin-trie-flags.js.map","import { codePointToString, replaceCodePoint, replaceCodePointXML, } from \"./decode-codepoint.js\";\nimport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nimport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\nimport { BinTrieFlags } from \"./internal/bin-trie-flags.js\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"AMP\"] = 38] = \"AMP\";\n    CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n    CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n    CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n    CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n    CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n    CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n    CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nconst TO_LOWER_BIT = 0b10_0000;\n/*\n * `parseNumericEntity` packs its two results into one 32-bit integer:\n * `(consumed << CONSUMED_SHIFT) | codePoint`. The 21-bit code point field\n * fits any valid Unicode value (max 0x10FFFF, clamped before packing); the\n * consumed count excludes `&` and gets the remaining 11 bits. Extract it\n * with `>>>` so the topmost bit isn't treated as a sign.\n *\n * Plain consts rather than a `const enum`: with `isolatedModules`, enum\n * member reads compile to runtime property loads.\n */\nconst CONSUMED_SHIFT = 21;\nconst CODE_POINT_MASK = 0x1f_ff_ff;\n/**\n * Reserved consumed field for counts of at least 2047 characters after `&`.\n * The true count is in `longNumericConsumed`.\n */\nconst CONSUMED_OVERFLOW = 0x7_ff;\n/**\n * Side channel for numeric entities of at least 2048 characters including\n * `&`. Set by `parseNumericEntity` when its consumed count reaches the\n * reserved value `CONSUMED_OVERFLOW`; callers read the true count from here.\n * A module-level slot avoids a tuple allocation on the hot path.\n */\nlet longNumericConsumed = 0;\n/**\n * Extract the consumed count from a `parseNumericEntity` packed result,\n * recovering the true length from `longNumericConsumed` when the packed\n * field contains the sentinel. Read it before the next `parseNumericEntity`\n * call, which may overwrite the side channel. This helper owns that protocol.\n * @param packed Packed result of `parseNumericEntity`.\n */\nfunction unpackConsumed(packed) {\n    const consumed = packed >>> CONSUMED_SHIFT;\n    return consumed === CONSUMED_OVERFLOW ? longNumericConsumed : consumed;\n}\n/**\n * Unsigned subtraction trick: (code - lo) >>> 0 wraps negatives to large\n * values, so a single `<=` covers the entire [lo..hi] range check.\n * @param code Code point to check.\n */\nfunction isNumber(code) {\n    return (code - CharCodes.ZERO) >>> 0 <= 9;\n}\nfunction isHexadecimalCharacter(code) {\n    return ((code | TO_LOWER_BIT) - CharCodes.LOWER_A) >>> 0 <= 5; // F - a\n}\nfunction isAlpha(code) {\n    return ((code | TO_LOWER_BIT) - CharCodes.LOWER_A) >>> 0 <= 25; // Z - a\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n * @param code Code point to check.\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n    return code === CharCodes.EQUALS || isAlpha(code) || isNumber(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n    EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n    EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n    EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\n/**\n * Decoding mode for named entities.\n */\nexport var DecodingMode;\n(function (DecodingMode) {\n    /** Entities in text nodes that can end with any character. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Only allow entities terminated with a semicolon. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n    /** Entities in attributes have limitations on ending characters. */\n    DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode || (DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nexport class EntityDecoder {\n    decodeTree;\n    emitCodePoint;\n    errors;\n    /** The current state of the decoder. */\n    state = EntityDecoderState.EntityStart;\n    /** Characters that were consumed while parsing an entity. */\n    consumed = 1;\n    /**\n     * The result of the entity.\n     *\n     * For named entities: the trie index of the best legacy match so far\n     * (0 = none). For numeric entities: the accumulated code point.\n     */\n    result = 0;\n    /** The current index in the decode tree. */\n    treeIndex = 0;\n    /**\n     * Characters consumed since the last recorded legacy match, plus one.\n     * Invariant at the top of the `stateNamedEntity` loop: `excess` equals\n     * the number of unrecorded consumed characters + 1.\n     */\n    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: False positive (read via destructuring)\n    excess = 1;\n    /** The mode in which the decoder is operating. */\n    decodeMode = DecodingMode.Strict;\n    /** The number of characters that have been consumed in the current run. */\n    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: False positive\n    runConsumed = 0;\n    constructor(\n    /** The predefined HTML or XML decode tree. */\n    decodeTree, \n    /**\n     * The function that is called when a codepoint is decoded.\n     *\n     * For named entities that decode to multiple code points, this will\n     * be called multiple times, with the second codepoint, and the same\n     * `consumed` value.\n     * @param codepoint The decoded codepoint.\n     * @param consumed The number of characters consumed by the decoder.\n     */\n    emitCodePoint, \n    /** An object that is used to produce errors. */\n    errors) {\n        this.decodeTree = decodeTree;\n        this.emitCodePoint = emitCodePoint;\n        this.errors = errors;\n    }\n    /**\n     * Resets the instance to make it reusable.\n     * @param decodeMode Entity decoding mode to use.\n     */\n    startEntity(decodeMode) {\n        this.decodeMode = decodeMode;\n        this.state = EntityDecoderState.EntityStart;\n        this.result = 0;\n        this.treeIndex = 0;\n        this.excess = 1;\n        this.consumed = 1;\n        this.runConsumed = 0;\n    }\n    /**\n     * Write an entity to the decoder. This can be called multiple times with partial entities.\n     * If the entity is incomplete, the decoder will return -1.\n     *\n     * Mirrors the non-streaming `decodeWithTrie`, but with the ability to stop decoding if the\n     * entity is incomplete, and resume when the next string is written.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    write(input, offset) {\n        switch (this.state) {\n            case EntityDecoderState.EntityStart: {\n                if (input.charCodeAt(offset) === CharCodes.NUM) {\n                    this.state = EntityDecoderState.NumericStart;\n                    this.consumed += 1;\n                    return this.stateNumericStart(input, offset + 1);\n                }\n                this.state = EntityDecoderState.NamedEntity;\n                return this.stateNamedEntity(input, offset);\n            }\n            case EntityDecoderState.NumericStart: {\n                return this.stateNumericStart(input, offset);\n            }\n            case EntityDecoderState.NumericDecimal: {\n                return this.stateNumericDecimal(input, offset);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.stateNumericHex(input, offset);\n            }\n            default: {\n                // NamedEntity — the only remaining state.\n                return this.stateNamedEntity(input, offset);\n            }\n        }\n    }\n    /**\n     * Switches between the numeric decimal and hexadecimal states.\n     *\n     * Equivalent to the `Numeric character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    // eslint-disable-next-line unicorn/consistent-class-member-order\n    stateNumericStart(input, offset) {\n        if (offset >= input.length) {\n            return -1;\n        }\n        if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n            this.state = EntityDecoderState.NumericHex;\n            this.consumed += 1;\n            return this.stateNumericHex(input, offset + 1);\n        }\n        this.state = EntityDecoderState.NumericDecimal;\n        return this.stateNumericDecimal(input, offset);\n    }\n    /**\n     * Parses a hexadecimal numeric entity.\n     *\n     * Equivalent to the `Hexademical character reference state` in the HTML\n     * spec. Digit parsing matches the hex loop in `parseNumericEntity`.\n     * The accumulated value is preserved for numeric validation callbacks.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericHex(input, offset) {\n        const inputLength = input.length;\n        // Local accumulators; flushed before any exit (see stateNamedEntity).\n        let { result } = this;\n        let { consumed } = this;\n        while (offset < inputLength) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char) || isHexadecimalCharacter(char)) {\n                // Convert hex digit to value (0-15); 'a'/'A' -> 10.\n                const digit = char <= CharCodes.NINE\n                    ? char - CharCodes.ZERO\n                    : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;\n                result = result * 16 + digit;\n                consumed += 1;\n                offset += 1;\n            }\n            else {\n                this.result = result;\n                this.consumed = consumed;\n                return this.emitNumericEntity(char, 3);\n            }\n        }\n        this.result = result;\n        this.consumed = consumed;\n        return -1; // Incomplete entity\n    }\n    /**\n     * Parses a decimal numeric entity.\n     *\n     * Equivalent to the `Decimal character reference state` in the HTML\n     * spec. Digit parsing matches the decimal loop in `parseNumericEntity`.\n     * The accumulated value is preserved for numeric validation callbacks.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericDecimal(input, offset) {\n        const inputLength = input.length;\n        // Local accumulators; flushed before any exit (see stateNamedEntity).\n        let { result } = this;\n        let { consumed } = this;\n        while (offset < inputLength) {\n            const digit = input.charCodeAt(offset) - CharCodes.ZERO;\n            if (digit >>> 0 > 9) {\n                this.result = result;\n                this.consumed = consumed;\n                return this.emitNumericEntity(digit + CharCodes.ZERO, 2);\n            }\n            result = result * 10 + digit;\n            consumed += 1;\n            offset += 1;\n        }\n        this.result = result;\n        this.consumed = consumed;\n        return -1; // Incomplete entity\n    }\n    /**\n     * Validate and emit a numeric entity.\n     *\n     * Implements the logic from the `Hexademical character reference start\n     * state` and `Numeric character reference end state` in the HTML spec.\n     * @param lastCp The last code point of the entity. Used to see if the\n     *               entity was terminated with a semicolon.\n     * @param expectedLength The minimum number of characters that should be\n     *                       consumed. Used to validate that at least one digit\n     *                       was consumed.\n     * @returns The number of characters that were consumed.\n     */\n    emitNumericEntity(lastCp, expectedLength) {\n        // Ensure we consumed at least one digit.\n        if (this.consumed <= expectedLength) {\n            this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);\n            return 0;\n        }\n        // Figure out if this is a legit end of the entity\n        if (lastCp === CharCodes.SEMI) {\n            this.consumed += 1;\n        }\n        else if (this.decodeMode === DecodingMode.Strict) {\n            return 0;\n        }\n        this.emitCodePoint((this.decodeTree === xmlDecodeTree\n            ? replaceCodePointXML\n            : replaceCodePoint)(this.result), this.consumed);\n        if (this.errors) {\n            if (lastCp !== CharCodes.SEMI) {\n                this.errors.missingSemicolonAfterCharacterReference();\n            }\n            this.errors.validateNumericCharacterReference(this.result);\n        }\n        return this.consumed;\n    }\n    /**\n     * Flush locally-tracked walk state back to the fields, then emit the\n     * recorded legacy match or reject (cold path — at most once per\n     * entity). Called after failed navigation (leaf node, branch miss, or\n     * compact-run mismatch). In attribute mode, reject if no legacy was\n     * recorded at the current node, if we descended past it, or if the\n     * pending input character is an invalid attribute terminator.\n     * @param consumed Locally-tracked consumed count.\n     * @param excess Locally-tracked excess count.\n     * @param char Pending input character (may be the mismatching char).\n     * @param valueLength Value length at the current trie node.\n     */\n    flushAndEmitLegacyOrReject(consumed, excess, char, valueLength) {\n        this.consumed = consumed;\n        this.excess = excess;\n        return this.result === 0 ||\n            (this.decodeMode === DecodingMode.Attribute &&\n                (valueLength === 0 ||\n                    excess > 1 ||\n                    isEntityInAttributeInvalidEnd(char)))\n            ? 0\n            : this.emitNotTerminatedNamedEntity();\n    }\n    /**\n     * Parses a named entity.\n     *\n     * Equivalent to the `Named character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNamedEntity(input, offset) {\n        const { decodeTree } = this;\n        const inputLength = input.length;\n        const isStrict = this.decodeMode === DecodingMode.Strict;\n        /*\n         * Local copies of the resumable walk state avoid per-character\n         * field writes. They are flushed back to the fields\n         * on every exit (chunk end, and before any emit helper that reads\n         * them). `this.result` is only written at the (rare) record points,\n         * so it stays a direct field write.\n         *\n         * Legacy-match recording happens in two idempotent places: at the\n         * loop top when sitting on a value node, and in the chunk-end\n         * epilogue (so `end()` sees matches that land exactly on a chunk\n         * boundary). Recording applies `consumed += excess - 1; excess = 1`,\n         * which is a no-op when repeated — the loop-top invariant is\n         * `excess` = unrecorded consumed characters + 1.\n         */\n        let { treeIndex } = this;\n        let { excess } = this;\n        let { consumed } = this;\n        let current = decodeTree[treeIndex];\n        while (offset < inputLength) {\n            /*\n             * Descend through value-less jump-table nodes (including the\n             * single-branch encoding) inline, mirroring `decodeWithTrie`:\n             * this avoids a `determineBranch` call per level for the\n             * dominant node shape — including the root on the first write.\n             */\n            while ((current &\n                (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                0 &&\n                (current & BinTrieFlags.JUMP_TABLE) !== 0) {\n                const char = input.charCodeAt(offset);\n                const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n                const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                if (branchCount === 0) {\n                    // Single branch encoded inline in the jump offset bits.\n                    if (char !== jumpOffset) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    treeIndex += 1;\n                }\n                else {\n                    const slot = char - jumpOffset;\n                    if (slot >>> 0 >= branchCount) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    const stored = decodeTree[treeIndex + 1 + slot];\n                    if (stored === 0) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    // End-relative: branch data ends at treeIndex+1+branchCount.\n                    treeIndex = (treeIndex + branchCount + stored) & 0xff_ff;\n                }\n                current = decodeTree[treeIndex];\n                offset += 1;\n                excess += 1;\n                /*\n                 * `charCodeAt` past the end returns NaN, which would alias\n                 * to slot 0 after `>>> 0` — bail out explicitly.\n                 */\n                // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                if (offset >= inputLength)\n                    break;\n            }\n            if (offset >= inputLength)\n                break;\n            // Handle compact runs (resumable across chunks).\n            if ((current &\n                (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                BinTrieFlags.FLAG13) {\n                const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7; /* 3..63 */\n                let { runConsumed } = this;\n                // If we are starting a run, check the first char.\n                if (runConsumed === 0) {\n                    const char = input.charCodeAt(offset);\n                    if (char !== (current & BinTrieFlags.JUMP_TABLE)) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    offset += 1;\n                    excess += 1;\n                    runConsumed = 1;\n                }\n                // Check remaining characters in the run (packed two per uint16 word).\n                while (runConsumed < runLength) {\n                    if (offset >= inputLength) {\n                        this.treeIndex = treeIndex;\n                        this.excess = excess;\n                        this.consumed = consumed;\n                        this.runConsumed = runConsumed;\n                        return -1;\n                    }\n                    const charIndexInPacked = runConsumed - 1;\n                    const packedWord = decodeTree[treeIndex + 1 + (charIndexInPacked >> 1)];\n                    const expectedChar = (packedWord >> ((charIndexInPacked & 1) << 3)) & 0xff;\n                    const char = input.charCodeAt(offset);\n                    if (char !== expectedChar) {\n                        this.runConsumed = 0;\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    offset += 1;\n                    excess += 1;\n                    runConsumed += 1;\n                }\n                this.runConsumed = 0;\n                treeIndex += 1 + (runLength >> 1);\n                current = decodeTree[treeIndex];\n                // Loop top handles the landed-on node (record/emit/branch).\n                continue;\n            }\n            // Header plus out-of-line value words; 0 means no value.\n            const valueLength = current >>> 14;\n            const char = input.charCodeAt(offset);\n            if (valueLength !== 0) {\n                // Record a legacy match (FLAG13 clear = semicolon optional).\n                if (!isStrict && (current & BinTrieFlags.FLAG13) === 0) {\n                    this.result = treeIndex;\n                    consumed += excess - 1;\n                    excess = 1;\n                }\n                /*\n                 * Implicit semicolon handling: emit immediately. Covers both\n                 * strict (FLAG13 set) and legacy entities — neither stores\n                 * an explicit `;` branch in the trie.\n                 */\n                if (char === CharCodes.SEMI) {\n                    return this.emitNamedEntityData(treeIndex, valueLength, consumed + excess);\n                }\n                /*\n                 * `valueLength === 1` packs the codepoint into the header\n                 * word's low 13 bits, where branch metadata also lives. Skip\n                 * the branch lookup on leaves so those value bits aren't\n                 * reinterpreted as branch offsets.\n                 */\n                if (valueLength === 1) {\n                    return this.flushAndEmitLegacyOrReject(consumed, excess, char, valueLength);\n                }\n            }\n            // Value-bearing or dictionary node: dispatch through determineBranch.\n            const next = determineBranch(decodeTree, current, treeIndex + (valueLength || 1), char);\n            if (next < 0) {\n                return this.flushAndEmitLegacyOrReject(consumed, excess, char, valueLength);\n            }\n            treeIndex = next;\n            current = decodeTree[treeIndex];\n            offset += 1;\n            excess += 1;\n        }\n        /*\n         * Chunk exhausted. Record a legacy match we may be sitting on, so a\n         * subsequent `end()` emits it, then persist the walk state.\n         */\n        if (!isStrict &&\n            current >>> 14 !== 0 &&\n            (current & BinTrieFlags.FLAG13) === 0) {\n            this.result = treeIndex;\n            consumed += excess - 1;\n            excess = 1;\n        }\n        this.treeIndex = treeIndex;\n        this.excess = excess;\n        this.consumed = consumed;\n        return -1;\n    }\n    /**\n     * Emit a named entity that was not terminated with a semicolon.\n     * @returns The number of characters consumed.\n     */\n    emitNotTerminatedNamedEntity() {\n        const { result, decodeTree } = this;\n        const valueLength = decodeTree[result] >>> 14;\n        this.emitNamedEntityData(result, valueLength, this.consumed);\n        this.errors?.missingSemicolonAfterCharacterReference();\n        return this.consumed;\n    }\n    /**\n     * Emit a named entity.\n     * @param result The index of the entity in the decode tree.\n     * @param valueLength Encoded value length (header plus any value words).\n     * @param consumed The number of characters consumed.\n     * @returns The number of characters consumed.\n     */\n    emitNamedEntityData(result, valueLength, consumed) {\n        const { decodeTree } = this;\n        this.emitCodePoint(valueLength === 1\n            ? decodeTree[result] & BinTrieFlags.VALUE_MASK\n            : decodeTree[result + 1], consumed);\n        if (valueLength === 3) {\n            // Emit the second UTF-16 code unit.\n            this.emitCodePoint(decodeTree[result + 2], consumed);\n        }\n        return consumed;\n    }\n    /**\n     * Signal to the parser that the end of the input was reached.\n     *\n     * Remaining data will be emitted and relevant errors will be produced.\n     * @returns The number of characters consumed.\n     */\n    end() {\n        switch (this.state) {\n            case EntityDecoderState.NamedEntity: {\n                // Emit a named entity if we have one.\n                return this.result !== 0 &&\n                    (this.decodeMode !== DecodingMode.Attribute ||\n                        this.result === this.treeIndex)\n                    ? this.emitNotTerminatedNamedEntity()\n                    : 0;\n            }\n            // Otherwise, emit a numeric entity if we have one.\n            case EntityDecoderState.NumericDecimal: {\n                return this.emitNumericEntity(0, 2);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.emitNumericEntity(0, 3);\n            }\n            case EntityDecoderState.NumericStart: {\n                this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);\n                return 0;\n            }\n            default: {\n                // EntityStart or unknown — return 0.\n                return 0;\n            }\n        }\n    }\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n *\n * See `BinTrieFlags` for the branch-data layouts handled here.\n * @param decodeTree The trie.\n * @param current The current node's header word.\n * @param nodeIndex Index of the node's first branch-data word (the header\n *   plus any value words have been skipped by the caller).\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nexport function determineBranch(decodeTree, current, nodeIndex, char) {\n    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    // Case 1: Single branch or jump table (jumpOffset encodes the first/only char code).\n    if (jumpOffset) {\n        if (branchCount === 0) {\n            // Single branch encoded inline in the jump offset bits.\n            return char === jumpOffset ? nodeIndex : -1;\n        }\n        /*\n         * Jump table: branchCount consecutive slots starting at jumpOffset.\n         * Unsigned comparison handles both < 0 and >= branchCount in one check.\n         */\n        const slot = char - jumpOffset;\n        if (slot >>> 0 >= branchCount)\n            return -1;\n        const stored = decodeTree[nodeIndex + slot];\n        /*\n         * 0 = empty slot (no branch); otherwise the child's offset from the\n         * end of the branch array, +1 (end-relative pointers compress\n         * better). `& 0xff_ff` mirrors the encoder's uint16 wrap for\n         * backreferences to already-encoded nodes.\n         */\n        return stored === 0\n            ? -1\n            : (nodeIndex + branchCount + stored - 1) & 0xff_ff;\n    }\n    /*\n     * Case 2: Packed dictionary. Linear scan — over 90% of dict nodes have\n     * <= 4 branches in the HTML trie, where the constant-factor savings\n     * dominate over binary search's asymptotic edge.\n     */\n    if (branchCount === 0)\n        return -1;\n    const packedKeySlots = (branchCount + 1) >> 1;\n    const branchEnd = nodeIndex + packedKeySlots + branchCount;\n    for (let index = 0; index < branchCount; index++) {\n        const packed = decodeTree[nodeIndex + (index >> 1)];\n        const key = (packed >> ((index & 1) << 3)) & 0xff;\n        if (key === char) {\n            const pointerIndex = nodeIndex + packedKeySlots + index;\n            // Pointers are relative to the end of the branch data.\n            return (branchEnd + decodeTree[pointerIndex]) & 0xff_ff;\n        }\n        // Keys are sorted; if we've passed `char`, no match is possible.\n        if (key > char)\n            return -1;\n    }\n    return -1;\n}\n/**\n * Read the decoded value from a trie node.\n * @param decodeTree The trie.\n * @param nodeIndex The index of the node.\n * @param valueLength The length of the value (1, 2, or 3).\n * @returns The decoded string.\n */\nfunction readTrieValue(decodeTree, nodeIndex, valueLength) {\n    if (valueLength === 1) {\n        return String.fromCharCode(decodeTree[nodeIndex] & BinTrieFlags.VALUE_MASK);\n    }\n    if (valueLength === 2) {\n        return String.fromCharCode(decodeTree[nodeIndex + 1]);\n    }\n    return String.fromCharCode(decodeTree[nodeIndex + 1], decodeTree[nodeIndex + 2]);\n}\n/**\n * Parse a numeric entity (`&#DDD;` or `&#xHHH;`).\n *\n * Encodes the result as `(consumed << CONSUMED_SHIFT) | codepoint` (see\n * the packing comment at the top of the file; overlong entities spill\n * their length into `longNumericConsumed`). Returns 0 when no digits were\n * found.\n *\n * This is the sync counterpart of the streaming\n * `EntityDecoder#stateNumericDecimal` / `#stateNumericHex`. Digit parsing\n * matches those methods; only this packed result needs a value clamp.\n * @param input       The input string.\n * @param numberStart Index of the `#` character.\n * @param inputLength Cached `input.length`.\n */\nfunction parseNumericEntity(input, numberStart, inputLength) {\n    let offset = numberStart + 1; // Skip \"#\"\n    let cp = 0;\n    let digitStart = offset;\n    /*\n     * Separate decimal and hexadecimal loops: each multiplies by a constant\n     * and runs a single digit test, instead of a per-character base check.\n     */\n    if (offset < inputLength &&\n        (input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n        offset += 1;\n        digitStart = offset;\n        while (offset < inputLength) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char)) {\n                cp = cp * 16 + (char - CharCodes.ZERO);\n            }\n            else if (isHexadecimalCharacter(char)) {\n                cp = cp * 16 + ((char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10);\n            }\n            else {\n                break;\n            }\n            offset += 1;\n        }\n    }\n    else {\n        while (offset < inputLength) {\n            const digit = input.charCodeAt(offset) - CharCodes.ZERO;\n            if (digit >>> 0 > 9)\n                break;\n            cp = cp * 10 + digit;\n            offset += 1;\n        }\n    }\n    if (offset === digitStart)\n        return 0;\n    // Include the semicolon in consumed when present.\n    if (offset < inputLength && input.charCodeAt(offset) === CharCodes.SEMI) {\n        offset += 1;\n    }\n    /*\n     * Clamp out-of-range values to 0x110000 so they fit the 21-bit field\n     * and decode to U+FFFD. Lengths at or above CONSUMED_OVERFLOW use the\n     * side channel described with the packing constants.\n     */\n    if (cp > 0x10_ff_ff)\n        cp = 0x11_00_00;\n    let consumed = offset - numberStart;\n    if (consumed >= CONSUMED_OVERFLOW) {\n        // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- deliberate side channel, see `longNumericConsumed`\n        longNumericConsumed = consumed;\n        consumed = CONSUMED_OVERFLOW;\n    }\n    return (consumed << CONSUMED_SHIFT) | cp;\n}\n/**\n * Decode all entities in `input` using the HTML trie.\n *\n * Hard-wired to `htmlDecodeTree`: the inline root navigation below assumes\n * the HTML root's jump-table shape, so this must not be generalized to\n * other tries (the XML trie's dictionary root would silently match no\n * entities — `decodeXML` has its own hand-coded fast path instead).\n * @param input      The string to decode.\n * @param isStrict Only match semicolon-terminated entities.\n * @param isAttribute Whether to apply attribute-specific parsing rules (disallowing certain non-semicolon terminators).\n * @returns The decoded string.\n */\nfunction decodeWithTrie(input, isStrict, isAttribute) {\n    const decodeTree = htmlDecodeTree;\n    // Fast path: no entities at all — return input without any allocation.\n    let offset = input.indexOf(\"&\");\n    if (offset < 0)\n        return input;\n    const inputLength = input.length;\n    /*\n     * `chunkStart` marks the start of the next pending slice. Rejected\n     * entities don't advance it, so consecutive rejections are stitched\n     * into a single `slice` once a real match (or end of input) is hit.\n     */\n    let chunkStart = 0;\n    let result = \"\";\n    /*\n     * Root navigation fields, hoisted out of the per-entity loop. The HTML\n     * root is a multi-branch jump-table covering [A-Za-z]; see the inline\n     * first-iteration comment below.\n     */\n    const root = decodeTree[0];\n    const rootJumpOffset = root & BinTrieFlags.JUMP_TABLE;\n    const rootBranchCount = (root & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    do {\n        const entityStart = offset + 1;\n        // Quick check: entity names must start with [A-Za-z], numeric with #.\n        const firstChar = input.charCodeAt(entityStart);\n        let consumed;\n        let value;\n        if (firstChar === CharCodes.NUM) {\n            const packed = parseNumericEntity(input, entityStart, inputLength);\n            consumed = unpackConsumed(packed);\n            // In strict mode, require semicolon termination.\n            if (isStrict &&\n                consumed > 0 &&\n                input.charCodeAt(entityStart + consumed - 1) !== CharCodes.SEMI) {\n                consumed = 0;\n            }\n            value =\n                consumed === 0\n                    ? \"\"\n                    : codePointToString(packed & CODE_POINT_MASK);\n        }\n        else if (isAlpha(firstChar)) {\n            consumed = 0;\n            value = \"\";\n            /*\n             * The generator guarantees a jump-table root. Consume the first\n             * character directly, then walk from its child.\n             */\n            const rootSlotIndex = firstChar - rootJumpOffset;\n            let nodeIndex;\n            if (rootSlotIndex >>> 0 < rootBranchCount) {\n                const stored = decodeTree[1 + rootSlotIndex];\n                nodeIndex =\n                    stored === 0 ? -1 : (rootBranchCount + stored) & 0xff_ff;\n            }\n            else {\n                nodeIndex = -1;\n            }\n            /*\n             * Best legacy (no-semicolon) match so far, as trie coordinates.\n             * Deferring `readTrieValue` to the end avoids allocating a\n             * string for matches that longer matches supersede.\n             */\n            let bestNodeIndex = 0;\n            let bestValueLength = 0;\n            let current = nodeIndex < 0 ? 0 : decodeTree[nodeIndex];\n            let index = entityStart + 1;\n            /*\n             * Walk the trie from the root child. The `trie` label lets the\n             * inner descent and compact-run loops abandon the entity (and\n             * fall through to the legacy/reject handling) directly.\n             */\n            trie: while (index < inputLength) {\n                /*\n                 * Inline value-less jump tables and single branches. A miss\n                 * falls through to the recorded legacy match or rejection.\n                 */\n                while (\n                // Value-less, non-run node with a nonzero jump offset.\n                (current &\n                    (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                    0 &&\n                    (current & BinTrieFlags.JUMP_TABLE) !== 0) {\n                    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n                    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                    if (branchCount === 0) {\n                        // Single branch encoded inline in the jump offset bits.\n                        if (input.charCodeAt(index) !== jumpOffset)\n                            break trie;\n                        nodeIndex += 1;\n                    }\n                    else {\n                        const slot = input.charCodeAt(index) - jumpOffset;\n                        if (slot >>> 0 >= branchCount)\n                            break trie;\n                        const stored = decodeTree[nodeIndex + 1 + slot];\n                        if (stored === 0)\n                            break trie;\n                        // End-relative: branch data ends at nodeIndex+1+branchCount.\n                        nodeIndex =\n                            (nodeIndex + branchCount + stored) & 0xff_ff;\n                    }\n                    current = decodeTree[nodeIndex];\n                    index += 1;\n                    /*\n                     * `charCodeAt` past the end returns NaN, which would\n                     * alias to slot 0 after `>>> 0` — bail out explicitly.\n                     */\n                    if (index >= inputLength)\n                        break trie;\n                }\n                // FLAG13 without a value marks a compact run.\n                if ((current &\n                    (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                    BinTrieFlags.FLAG13) {\n                    const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                    // Check first char (stored in JUMP_TABLE bits).\n                    if (input.charCodeAt(index) !==\n                        (current & BinTrieFlags.JUMP_TABLE)) {\n                        // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                        break;\n                    }\n                    index += 1;\n                    // Check remaining characters (packed two per uint16 word).\n                    const remaining = runLength - 1;\n                    let wordIndex = nodeIndex + 1;\n                    let charIndexInPacked = 0;\n                    /*\n                     * Process pairs: read one packed word, compare low byte then high byte.\n                     * No explicit bounds check needed — charCodeAt returns NaN for OOB,\n                     * which never equals an integer, so the mismatch break fires naturally.\n                     */\n                    for (; charIndexInPacked + 1 < remaining; charIndexInPacked += 2) {\n                        const packed = decodeTree[wordIndex];\n                        if (input.charCodeAt(index) !== (packed & 0xff))\n                            break trie;\n                        index += 1;\n                        if (input.charCodeAt(index) !== ((packed >> 8) & 0xff))\n                            break trie;\n                        index += 1;\n                        wordIndex += 1;\n                    }\n                    // Handle odd trailing char.\n                    if (charIndexInPacked < remaining) {\n                        if (input.charCodeAt(index) !==\n                            (decodeTree[wordIndex] & 0xff))\n                            // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                            break;\n                        index += 1;\n                    }\n                    nodeIndex += 1 + (runLength >> 1);\n                    current = decodeTree[nodeIndex];\n                    // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                    continue;\n                }\n                // Header plus out-of-line value words; 0 means no value.\n                const valueLength = current >>> 14;\n                const char = input.charCodeAt(index);\n                /*\n                 * Check current node for a value before navigating.\n                 * This handles both: (a) values reached via compact runs on the\n                 * previous iteration, and (b) values at regular branch targets.\n                 */\n                if (valueLength !== 0) {\n                    // If char is `;`, emit immediately.\n                    if (char === CharCodes.SEMI) {\n                        consumed = index - entityStart + 1;\n                        // Inline leaves carry the value in the low 13 bits.\n                        value =\n                            valueLength === 1\n                                ? String.fromCharCode(current & BinTrieFlags.VALUE_MASK)\n                                : readTrieValue(decodeTree, nodeIndex, valueLength);\n                        // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                        break;\n                    }\n                    // Record non-terminated (legacy) match (FLAG13 clear = semicolon optional).\n                    if (!isStrict && (current & BinTrieFlags.FLAG13) === 0) {\n                        consumed = index - entityStart;\n                        bestNodeIndex = nodeIndex;\n                        bestValueLength = valueLength;\n                    }\n                    /*\n                     * A valueLength of 1 means the value is packed inline in the header\n                     * word — these are always leaf nodes with no branches, so we can\n                     * stop walking the trie.\n                     */\n                    // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                    if (valueLength === 1)\n                        break;\n                }\n                // Navigate to the next node (valueLength || 1: skip past value words, minimum 1 for header).\n                const next = determineBranch(decodeTree, current, nodeIndex + (valueLength || 1), char);\n                // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                if (next < 0)\n                    break;\n                nodeIndex = next;\n                current = decodeTree[nodeIndex];\n                index += 1;\n            }\n            /*\n             * Post-loop: if the semicolon path didn't set value,\n             * check for a final legacy match. The last navigation may\n             * have landed on a legacy node whose value hasn't been\n             * recorded yet (loop exited before the top-of-loop check\n             * could run).\n             */\n            if (value === \"\") {\n                const finalVL = current >>> 14;\n                if (finalVL !== 0 &&\n                    !isStrict &&\n                    (current & BinTrieFlags.FLAG13) === 0) {\n                    consumed = index - entityStart;\n                    bestNodeIndex = nodeIndex;\n                    bestValueLength = finalVL;\n                }\n                if (consumed > 0) {\n                    value = readTrieValue(decodeTree, bestNodeIndex, bestValueLength);\n                }\n            }\n        }\n        else {\n            consumed = 0;\n            value = \"\";\n        }\n        /*\n         * The attribute end-char rule (HTML spec §13.2.5.73) only applies to\n         * unterminated *named* references.  Semicolon-terminated entities and\n         * numeric entities are always accepted, matching EntityDecoder behavior.\n         *\n         * When `attribute` is false (the common case), short-circuit skips all\n         * the unterminated-named checks entirely.\n         */\n        if (consumed === 0 ||\n            (isAttribute &&\n                firstChar !== CharCodes.NUM &&\n                input.charCodeAt(entityStart + consumed - 1) !==\n                    CharCodes.SEMI &&\n                entityStart + consumed < inputLength &&\n                isEntityInAttributeInvalidEnd(input.charCodeAt(entityStart + consumed)))) {\n            // Rejected: leave `&` in the pending chunk, scan past it.\n            offset = entityStart;\n        }\n        else {\n            if (chunkStart < offset) {\n                result += input.slice(chunkStart, offset);\n            }\n            result += value;\n            offset = chunkStart = entityStart + consumed;\n        }\n        /*\n         * Adjacent entities (`&x;&y;`) are common in entity-dense input;\n         * checking the single character at `offset` first skips the\n         * `indexOf` call (and its per-call overhead) for that case.\n         */\n        if (input.charCodeAt(offset) !== CharCodes.AMP) {\n            offset = input.indexOf(\"&\", offset);\n        }\n    } while (offset >= 0);\n    return result + input.slice(chunkStart);\n}\n/**\n * Decodes an HTML string.\n * @param htmlString The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nexport function decodeHTML(htmlString, mode = DecodingMode.Legacy) {\n    return decodeWithTrie(htmlString, mode === DecodingMode.Strict, mode === DecodingMode.Attribute);\n}\n/**\n * Decodes an HTML string in an attribute.\n * @param htmlAttribute The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLAttribute(htmlAttribute) {\n    return decodeWithTrie(htmlAttribute, false, true);\n}\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n * @param htmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLStrict(htmlString) {\n    return decodeWithTrie(htmlString, true, false);\n}\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n *\n * Uses a hand-coded fast path for the 5 XML named entities (amp, lt, gt,\n * quot, apos) plus numeric entities, bypassing the trie entirely.\n * @param xmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeXML(xmlString) {\n    let offset = xmlString.indexOf(\"&\");\n    if (offset < 0)\n        return xmlString;\n    let lastIndex = 0;\n    let result = \"\";\n    do {\n        const start = offset + 1;\n        let consumed = 0;\n        let value = \"\";\n        const c1 = xmlString.charCodeAt(start);\n        if (c1 === CharCodes.NUM) {\n            const packed = parseNumericEntity(xmlString, start, xmlString.length);\n            consumed = unpackConsumed(packed);\n            // XML is always strict — require semicolon.\n            if (consumed === 0 ||\n                xmlString.charCodeAt(start + consumed - 1) !== CharCodes.SEMI) {\n                consumed = 0;\n            }\n            else {\n                const codePoint = packed & CODE_POINT_MASK;\n                // Nonzero BMP values below the surrogate range need no replacement.\n                value =\n                    (codePoint - 1) >>> 0 < 0xd7_ff\n                        ? String.fromCharCode(codePoint)\n                        : String.fromCodePoint(replaceCodePointXML(codePoint));\n            }\n        }\n        else {\n            /* eslint-disable unicorn/no-break-in-nested-loop -- Keep XML name dispatch inline with the decode loop. */\n            switch (c1) {\n                // &lt; / &gt;\n                case 0x6c:\n                case 0x67: {\n                    if (xmlString.charCodeAt(start + 1) === 0x74 &&\n                        xmlString.charCodeAt(start + 2) === CharCodes.SEMI) {\n                        consumed = 3;\n                        value = c1 === 0x6c ? \"<\" : \">\";\n                    }\n                    break;\n                }\n                // &amp; / &apos;\n                case 0x61: {\n                    const c2 = xmlString.charCodeAt(start + 1);\n                    if (c2 === 0x6d &&\n                        xmlString.charCodeAt(start + 2) === 0x70 &&\n                        xmlString.charCodeAt(start + 3) === CharCodes.SEMI) {\n                        consumed = 4;\n                        value = \"&\";\n                    }\n                    else if (c2 === 0x70 &&\n                        xmlString.charCodeAt(start + 2) === 0x6f &&\n                        xmlString.charCodeAt(start + 3) === 0x73 &&\n                        xmlString.charCodeAt(start + 4) === CharCodes.SEMI) {\n                        consumed = 5;\n                        value = \"'\";\n                    }\n                    break;\n                }\n                // &quot;\n                case 0x71: {\n                    if (xmlString.charCodeAt(start + 1) === 0x75 &&\n                        xmlString.charCodeAt(start + 2) === 0x6f &&\n                        xmlString.charCodeAt(start + 3) === 0x74 &&\n                        xmlString.charCodeAt(start + 4) === CharCodes.SEMI) {\n                        consumed = 5;\n                        value = '\"';\n                    }\n                    break;\n                }\n            }\n            /* eslint-enable unicorn/no-break-in-nested-loop */\n        }\n        if (consumed > 0) {\n            if (lastIndex < offset)\n                result += xmlString.slice(lastIndex, offset);\n            result += value;\n            offset = lastIndex = start + consumed;\n        }\n        else {\n            offset = start;\n        }\n        /*\n         * Adjacent entities (`&x;&y;`) are common in entity-dense input;\n         * checking the single character at `lastIndex` first skips the\n         * `indexOf` call (and its per-call overhead) for that case.\n         */\n        offset =\n            xmlString.charCodeAt(offset) === CharCodes.AMP\n                ? offset\n                : xmlString.indexOf(\"&\", offset);\n    } while (offset >= 0);\n    return result + xmlString.slice(lastIndex);\n}\nexport { replaceCodePoint, replaceCodePointXML, } from \"./decode-codepoint.js\";\n// Re-export for use by eg. htmlparser2\nexport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nexport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\n//# sourceMappingURL=decode.js.map","import { DecodingMode, EntityDecoder, htmlDecodeTree, xmlDecodeTree, } from \"entities/decode\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"Tab\"] = 9] = \"Tab\";\n    CharCodes[CharCodes[\"NewLine\"] = 10] = \"NewLine\";\n    CharCodes[CharCodes[\"FormFeed\"] = 12] = \"FormFeed\";\n    CharCodes[CharCodes[\"CarriageReturn\"] = 13] = \"CarriageReturn\";\n    CharCodes[CharCodes[\"Space\"] = 32] = \"Space\";\n    CharCodes[CharCodes[\"ExclamationMark\"] = 33] = \"ExclamationMark\";\n    CharCodes[CharCodes[\"Number\"] = 35] = \"Number\";\n    CharCodes[CharCodes[\"Amp\"] = 38] = \"Amp\";\n    CharCodes[CharCodes[\"SingleQuote\"] = 39] = \"SingleQuote\";\n    CharCodes[CharCodes[\"DoubleQuote\"] = 34] = \"DoubleQuote\";\n    CharCodes[CharCodes[\"Dash\"] = 45] = \"Dash\";\n    CharCodes[CharCodes[\"Slash\"] = 47] = \"Slash\";\n    CharCodes[CharCodes[\"Zero\"] = 48] = \"Zero\";\n    CharCodes[CharCodes[\"Nine\"] = 57] = \"Nine\";\n    CharCodes[CharCodes[\"Semi\"] = 59] = \"Semi\";\n    CharCodes[CharCodes[\"Lt\"] = 60] = \"Lt\";\n    CharCodes[CharCodes[\"Eq\"] = 61] = \"Eq\";\n    CharCodes[CharCodes[\"Gt\"] = 62] = \"Gt\";\n    CharCodes[CharCodes[\"Questionmark\"] = 63] = \"Questionmark\";\n    CharCodes[CharCodes[\"UpperA\"] = 65] = \"UpperA\";\n    CharCodes[CharCodes[\"LowerA\"] = 97] = \"LowerA\";\n    CharCodes[CharCodes[\"UpperF\"] = 70] = \"UpperF\";\n    CharCodes[CharCodes[\"LowerF\"] = 102] = \"LowerF\";\n    CharCodes[CharCodes[\"UpperZ\"] = 90] = \"UpperZ\";\n    CharCodes[CharCodes[\"LowerZ\"] = 122] = \"LowerZ\";\n    CharCodes[CharCodes[\"LowerX\"] = 120] = \"LowerX\";\n    CharCodes[CharCodes[\"OpeningSquareBracket\"] = 91] = \"OpeningSquareBracket\";\n})(CharCodes || (CharCodes = {}));\n/** All the states the tokenizer can be in. */\nvar State;\n(function (State) {\n    State[State[\"Text\"] = 1] = \"Text\";\n    State[State[\"BeforeTagName\"] = 2] = \"BeforeTagName\";\n    State[State[\"InTagName\"] = 3] = \"InTagName\";\n    State[State[\"InSelfClosingTag\"] = 4] = \"InSelfClosingTag\";\n    State[State[\"BeforeClosingTagName\"] = 5] = \"BeforeClosingTagName\";\n    State[State[\"InClosingTagName\"] = 6] = \"InClosingTagName\";\n    State[State[\"AfterClosingTagName\"] = 7] = \"AfterClosingTagName\";\n    // Attributes\n    State[State[\"BeforeAttributeName\"] = 8] = \"BeforeAttributeName\";\n    State[State[\"InAttributeName\"] = 9] = \"InAttributeName\";\n    State[State[\"AfterAttributeName\"] = 10] = \"AfterAttributeName\";\n    State[State[\"BeforeAttributeValue\"] = 11] = \"BeforeAttributeValue\";\n    State[State[\"InAttributeValueDq\"] = 12] = \"InAttributeValueDq\";\n    State[State[\"InAttributeValueSq\"] = 13] = \"InAttributeValueSq\";\n    State[State[\"InAttributeValueNq\"] = 14] = \"InAttributeValueNq\";\n    // Declarations\n    State[State[\"BeforeDeclaration\"] = 15] = \"BeforeDeclaration\";\n    State[State[\"InDeclaration\"] = 16] = \"InDeclaration\";\n    // Processing instructions\n    State[State[\"InProcessingInstruction\"] = 17] = \"InProcessingInstruction\";\n    // Comments & CDATA\n    State[State[\"BeforeComment\"] = 18] = \"BeforeComment\";\n    State[State[\"CDATASequence\"] = 19] = \"CDATASequence\";\n    State[State[\"DeclarationSequence\"] = 20] = \"DeclarationSequence\";\n    State[State[\"InSpecialComment\"] = 21] = \"InSpecialComment\";\n    State[State[\"InCommentLike\"] = 22] = \"InCommentLike\";\n    // Special tags\n    State[State[\"SpecialStartSequence\"] = 23] = \"SpecialStartSequence\";\n    State[State[\"InSpecialTag\"] = 24] = \"InSpecialTag\";\n    State[State[\"InPlainText\"] = 25] = \"InPlainText\";\n    State[State[\"InEntity\"] = 26] = \"InEntity\";\n})(State || (State = {}));\nfunction isWhitespace(c) {\n    return (c === CharCodes.Space ||\n        c === CharCodes.NewLine ||\n        c === CharCodes.Tab ||\n        c === CharCodes.FormFeed ||\n        c === CharCodes.CarriageReturn);\n}\nfunction isEndOfTagSection(c) {\n    return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace(c);\n}\nfunction isASCIIAlpha(c) {\n    return ((c >= CharCodes.LowerA && c <= CharCodes.LowerZ) ||\n        (c >= CharCodes.UpperA && c <= CharCodes.UpperZ));\n}\n/**\n * Quote style used for parsed attributes.\n */\nexport var QuoteType;\n(function (QuoteType) {\n    QuoteType[QuoteType[\"NoValue\"] = 0] = \"NoValue\";\n    QuoteType[QuoteType[\"Unquoted\"] = 1] = \"Unquoted\";\n    QuoteType[QuoteType[\"Single\"] = 2] = \"Single\";\n    QuoteType[QuoteType[\"Double\"] = 3] = \"Double\";\n})(QuoteType || (QuoteType = {}));\n/**\n * Sequences used to match longer strings.\n *\n * We don't have `Script`, `Style`, or `Title` here. Instead, we re-use the *End\n * sequences with an increased offset.\n */\nconst Sequences = {\n    Empty: new Uint8Array(0),\n    Cdata: new Uint8Array([0x43, 0x44, 0x41, 0x54, 0x41, 0x5b]), // CDATA[\n    CdataEnd: new Uint8Array([0x5d, 0x5d, 0x3e]), // ]]>\n    CommentEnd: new Uint8Array([0x2d, 0x2d, 0x21, 0x3e]), // `--!>`\n    Doctype: new Uint8Array([0x64, 0x6f, 0x63, 0x74, 0x79, 0x70, 0x65]), // `doctype`\n    IframeEnd: new Uint8Array([0x3c, 0x2f, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65]), // `</iframe`\n    NoembedEnd: new Uint8Array([\n        0x3c, 0x2f, 0x6e, 0x6f, 0x65, 0x6d, 0x62, 0x65, 0x64,\n    ]), // `</noembed`\n    NoframesEnd: new Uint8Array([\n        0x3c, 0x2f, 0x6e, 0x6f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73,\n    ]), // `</noframes`\n    Plaintext: new Uint8Array([\n        0x3c, 0x2f, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74,\n    ]), // `</plaintext`\n    ScriptEnd: new Uint8Array([0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74]), // `</script`\n    StyleEnd: new Uint8Array([0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65]), // `</style`\n    TitleEnd: new Uint8Array([0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65]), // `</title`\n    TextareaEnd: new Uint8Array([\n        0x3c, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x61, 0x72, 0x65, 0x61,\n    ]), // `</textarea`\n    XmpEnd: new Uint8Array([0x3c, 0x2f, 0x78, 0x6d, 0x70]), // `</xmp`\n};\n/**\n * Maps the first lowercase character of an HTML tag name to the sequence\n * used for special-tag detection.  All sequences share a common layout\n * where index 2 is the first tag-name character, so matching always\n * continues from offset 3.\n */\nconst specialStartSequences = new Map([\n    [Sequences.IframeEnd[2], Sequences.IframeEnd],\n    [Sequences.NoembedEnd[2], Sequences.NoembedEnd],\n    [Sequences.Plaintext[2], Sequences.Plaintext],\n    [Sequences.ScriptEnd[2], Sequences.ScriptEnd],\n    [Sequences.TitleEnd[2], Sequences.TitleEnd],\n    [Sequences.XmpEnd[2], Sequences.XmpEnd],\n]);\n/**\n * Tokenizer implementation used by `Parser`.\n */\nexport default class Tokenizer {\n    cbs;\n    /** The current state the tokenizer is in. */\n    state = State.Text;\n    /** The read buffer. */\n    buffer = \"\";\n    /** The beginning of the section that is currently being read. */\n    sectionStart = 0;\n    /** The index within the buffer that we are currently looking at. */\n    index = 0;\n    /** The start of the last entity. */\n    entityStart = 0;\n    /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */\n    baseState = State.Text;\n    /** For special parsing behavior inside of script and style tags. */\n    isSpecial = false;\n    /** Indicates whether the tokenizer has been paused. */\n    running = true;\n    /** The offset of the current buffer. */\n    offset = 0;\n    xmlMode;\n    decodeEntities;\n    recognizeSelfClosing;\n    entityDecoder;\n    constructor({ xmlMode = false, decodeEntities = true, recognizeSelfClosing = xmlMode, }, cbs) {\n        this.cbs = cbs;\n        this.xmlMode = xmlMode;\n        this.decodeEntities = decodeEntities;\n        this.recognizeSelfClosing = recognizeSelfClosing;\n        this.entityDecoder = new EntityDecoder(xmlMode ? xmlDecodeTree : htmlDecodeTree, (cp, consumed) => this.emitCodePoint(cp, consumed));\n    }\n    reset() {\n        this.state = State.Text;\n        this.buffer = \"\";\n        this.sectionStart = 0;\n        this.index = 0;\n        this.baseState = State.Text;\n        this.isSpecial = false;\n        this.currentSequence = Sequences.Empty;\n        this.sequenceIndex = 0;\n        this.running = true;\n        this.offset = 0;\n    }\n    write(chunk) {\n        this.offset += this.buffer.length;\n        this.buffer = chunk;\n        this.parse();\n    }\n    end() {\n        if (this.running)\n            this.finish();\n    }\n    pause() {\n        this.running = false;\n    }\n    resume() {\n        this.running = true;\n        if (this.index < this.buffer.length + this.offset) {\n            this.parse();\n        }\n    }\n    stateText(c) {\n        if (c === CharCodes.Lt ||\n            (!this.decodeEntities && this.fastForwardTo(CharCodes.Lt))) {\n            if (this.index > this.sectionStart) {\n                this.cbs.ontext(this.sectionStart, this.index);\n            }\n            this.state = State.BeforeTagName;\n            this.sectionStart = this.index;\n        }\n        else if (this.decodeEntities && c === CharCodes.Amp) {\n            this.startEntity();\n        }\n    }\n    currentSequence = Sequences.Empty;\n    sequenceIndex = 0;\n    enterTagBody() {\n        if (this.currentSequence === Sequences.Plaintext) {\n            this.currentSequence = Sequences.Empty;\n            this.state = State.InPlainText;\n        }\n        else if (this.isSpecial) {\n            this.state = State.InSpecialTag;\n            this.sequenceIndex = 0;\n        }\n        else {\n            this.state = State.Text;\n        }\n    }\n    /**\n     * Match the opening tag name against an HTML text-only tag sequence.\n     *\n     * Some tags share an initial prefix (`script`/`style`, `title`/`textarea`,\n     * `noembed`/`noframes`), so we may switch to an alternate sequence at the\n     * first distinguishing byte.  On a successful full match we fall back to\n     * the normal tag-name state; a later `>` will enter raw-text, RCDATA, or\n     * plaintext mode based on `currentSequence` / `isSpecial`.\n     * @param c Current character code point.\n     */\n    stateSpecialStartSequence(c) {\n        const lower = c | 0x20;\n        // Still matching — check for an alternate sequence at branch points.\n        if (this.sequenceIndex < this.currentSequence.length) {\n            if (lower === this.currentSequence[this.sequenceIndex]) {\n                this.sequenceIndex++;\n                return;\n            }\n            if (this.sequenceIndex === 3) {\n                if (this.currentSequence === Sequences.ScriptEnd &&\n                    lower === Sequences.StyleEnd[3]) {\n                    this.currentSequence = Sequences.StyleEnd;\n                    this.sequenceIndex = 4;\n                    return;\n                }\n                if (this.currentSequence === Sequences.TitleEnd &&\n                    lower === Sequences.TextareaEnd[3]) {\n                    this.currentSequence = Sequences.TextareaEnd;\n                    this.sequenceIndex = 4;\n                    return;\n                }\n            }\n            else if (this.sequenceIndex === 4 &&\n                this.currentSequence === Sequences.NoembedEnd &&\n                lower === Sequences.NoframesEnd[4]) {\n                this.currentSequence = Sequences.NoframesEnd;\n                this.sequenceIndex = 5;\n                return;\n            }\n        }\n        else if (isEndOfTagSection(c)) {\n            // Full match on a valid tag boundary — keep the sequence.\n            this.sequenceIndex = 0;\n            this.state = State.InTagName;\n            this.stateInTagName(c);\n            return;\n        }\n        // No match — abandon special-tag detection.\n        this.isSpecial = false;\n        this.currentSequence = Sequences.Empty;\n        this.sequenceIndex = 0;\n        this.state = State.InTagName;\n        this.stateInTagName(c);\n    }\n    stateCDATASequence(c) {\n        if (c === Sequences.Cdata[this.sequenceIndex]) {\n            if (++this.sequenceIndex === Sequences.Cdata.length) {\n                this.state = State.InCommentLike;\n                this.currentSequence = Sequences.CdataEnd;\n                this.sequenceIndex = 0;\n                this.sectionStart = this.index + 1;\n            }\n        }\n        else {\n            this.sequenceIndex = 0;\n            if (this.xmlMode) {\n                this.state = State.InDeclaration;\n                this.stateInDeclaration(c); // Reconsume the character\n            }\n            else {\n                this.state = State.InSpecialComment;\n                this.stateInSpecialComment(c); // Reconsume the character\n            }\n        }\n    }\n    /**\n     * When we wait for one specific character, we can speed things up\n     * by skipping through the buffer until we find it.\n     * @param c Current character code point.\n     * @returns Whether the character was found.\n     */\n    fastForwardTo(c) {\n        while (++this.index < this.buffer.length + this.offset) {\n            if (this.buffer.charCodeAt(this.index - this.offset) === c) {\n                return true;\n            }\n        }\n        /*\n         * We increment the index at the end of the `parse` loop,\n         * so set it to `buffer.length - 1` here.\n         *\n         * TODO: Refactor `parse` to increment index before calling states.\n         */\n        this.index = this.buffer.length + this.offset - 1;\n        return false;\n    }\n    /**\n     * Emit a comment token and return to the text state.\n     * @param offset Number of characters in the end sequence that have already been matched.\n     */\n    emitComment(offset) {\n        this.cbs.oncomment(this.sectionStart, this.index, offset);\n        this.sequenceIndex = 0;\n        this.sectionStart = this.index + 1;\n        this.state = State.Text;\n    }\n    /**\n     * Comments and CDATA end with `-->` and `]]>`.\n     *\n     * Their common qualities are:\n     * - Their end sequences have a distinct character they start with.\n     * - That character is then repeated, so we have to check multiple repeats.\n     * - All characters but the start character of the sequence can be skipped.\n     * @param c Current character code point.\n     */\n    stateInCommentLike(c) {\n        if (!this.xmlMode &&\n            this.currentSequence === Sequences.CommentEnd &&\n            this.sequenceIndex <= 1 &&\n            /*\n             * We're still at the very start of the comment: the only\n             * characters consumed since `<!--` are the dashes that\n             * advanced sequenceIndex (0 for `<!-->`, 1 for `<!--->`).\n             */\n            this.index === this.sectionStart + this.sequenceIndex &&\n            c === CharCodes.Gt) {\n            // Abruptly closed empty HTML comment.\n            this.emitComment(this.sequenceIndex);\n        }\n        else if (this.currentSequence === Sequences.CommentEnd &&\n            this.sequenceIndex === 2 &&\n            c === CharCodes.Gt) {\n            // `!` is optional here, so the same sequence also accepts `-->`.\n            this.emitComment(2);\n        }\n        else if (this.currentSequence === Sequences.CommentEnd &&\n            this.sequenceIndex === this.currentSequence.length - 1 &&\n            c !== CharCodes.Gt) {\n            this.sequenceIndex = Number(c === CharCodes.Dash);\n        }\n        else if (c === this.currentSequence[this.sequenceIndex]) {\n            if (++this.sequenceIndex === this.currentSequence.length) {\n                if (this.currentSequence === Sequences.CdataEnd) {\n                    this.cbs.oncdata(this.sectionStart, this.index, 2);\n                }\n                else {\n                    this.cbs.oncomment(this.sectionStart, this.index, 3);\n                }\n                this.sequenceIndex = 0;\n                this.sectionStart = this.index + 1;\n                this.state = State.Text;\n            }\n        }\n        else if (this.sequenceIndex === 0) {\n            // Fast-forward to the first character of the sequence\n            if (this.fastForwardTo(this.currentSequence[0])) {\n                this.sequenceIndex = 1;\n            }\n        }\n        else if (c !== this.currentSequence[this.sequenceIndex - 1]) {\n            // Allow long sequences, eg. --->, ]]]>\n            this.sequenceIndex = 0;\n        }\n    }\n    /**\n     * HTML only allows ASCII alpha characters (a-z and A-Z) at the beginning of a tag name.\n     *\n     * XML allows a lot more characters here (@see https://www.w3.org/TR/REC-xml/#NT-NameStartChar).\n     * We allow anything that wouldn't end the tag.\n     * @param c Current character code point.\n     */\n    isTagStartChar(c) {\n        return this.xmlMode ? !isEndOfTagSection(c) : isASCIIAlpha(c);\n    }\n    /**\n     * Scan raw-text / RCDATA content for the matching end tag.\n     *\n     * For RCDATA tags (`<title>`, `<textarea>`) entities are decoded inline.\n     * For raw-text tags (`<script>`, `<style>`, etc.) we fast-forward to `<`.\n     * @param c Current character code point.\n     */\n    stateInSpecialTag(c) {\n        if (this.sequenceIndex === this.currentSequence.length) {\n            if (isEndOfTagSection(c)) {\n                const endOfText = this.index - this.currentSequence.length;\n                if (this.sectionStart < endOfText) {\n                    // Spoof the index so that reported locations match up.\n                    const actualIndex = this.index;\n                    this.index = endOfText;\n                    this.cbs.ontext(this.sectionStart, endOfText);\n                    this.index = actualIndex;\n                }\n                this.isSpecial = false;\n                this.sectionStart = endOfText + 2; // Skip over the `</`\n                this.stateInClosingTagName(c);\n                return; // We are done; skip the rest of the function.\n            }\n            this.sequenceIndex = 0;\n        }\n        if ((c | 0x20) === this.currentSequence[this.sequenceIndex]) {\n            this.sequenceIndex += 1;\n        }\n        else if (this.sequenceIndex === 0) {\n            if (this.currentSequence === Sequences.TitleEnd ||\n                this.currentSequence === Sequences.TextareaEnd) {\n                // RCDATA tags have to parse entities while still looking for their end tag.\n                if (this.decodeEntities && c === CharCodes.Amp) {\n                    this.startEntity();\n                }\n            }\n            else if (this.fastForwardTo(CharCodes.Lt)) {\n                // Outside of RCDATA tags, we can fast-forward.\n                this.sequenceIndex = 1;\n            }\n        }\n        else {\n            // If we see a `<`, set the sequence index to 1; useful for eg. `<</script>`.\n            this.sequenceIndex = Number(c === CharCodes.Lt);\n        }\n    }\n    stateBeforeTagName(c) {\n        if (c === CharCodes.ExclamationMark) {\n            this.state = State.BeforeDeclaration;\n            this.sectionStart = this.index + 1;\n        }\n        else if (c === CharCodes.Questionmark) {\n            if (this.xmlMode) {\n                this.state = State.InProcessingInstruction;\n                this.sequenceIndex = 0;\n                this.sectionStart = this.index + 1;\n            }\n            else {\n                this.state = State.InSpecialComment;\n                this.sectionStart = this.index;\n            }\n        }\n        else if (this.isTagStartChar(c)) {\n            this.sectionStart = this.index;\n            const special = this.xmlMode || this.cbs.isInForeignContext?.()\n                ? undefined\n                : specialStartSequences.get(c | 0x20);\n            if (special === undefined) {\n                this.state = State.InTagName;\n            }\n            else {\n                this.isSpecial = true;\n                this.currentSequence = special;\n                this.sequenceIndex = 3;\n                this.state = State.SpecialStartSequence;\n            }\n        }\n        else if (c === CharCodes.Slash) {\n            this.state = State.BeforeClosingTagName;\n        }\n        else {\n            this.state = State.Text;\n            this.stateText(c);\n        }\n    }\n    stateInTagName(c) {\n        if (isEndOfTagSection(c)) {\n            this.cbs.onopentagname(this.sectionStart, this.index);\n            this.sectionStart = -1;\n            this.state = State.BeforeAttributeName;\n            this.stateBeforeAttributeName(c);\n        }\n    }\n    stateBeforeClosingTagName(c) {\n        if (isWhitespace(c)) {\n            if (this.xmlMode) {\n                // Ignore\n            }\n            else {\n                this.state = State.InSpecialComment;\n                this.sectionStart = this.index;\n            }\n        }\n        else if (c === CharCodes.Gt) {\n            this.state = State.Text;\n            if (!this.xmlMode) {\n                this.sectionStart = this.index + 1;\n            }\n        }\n        else {\n            this.state = this.isTagStartChar(c)\n                ? State.InClosingTagName\n                : State.InSpecialComment;\n            this.sectionStart = this.index;\n        }\n    }\n    stateInClosingTagName(c) {\n        if (isEndOfTagSection(c)) {\n            this.cbs.onclosetag(this.sectionStart, this.index);\n            this.sectionStart = -1;\n            this.state = State.AfterClosingTagName;\n            this.stateAfterClosingTagName(c);\n        }\n    }\n    stateAfterClosingTagName(c) {\n        // Skip everything until \">\"\n        if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n    }\n    stateBeforeAttributeName(c) {\n        if (c === CharCodes.Gt) {\n            this.cbs.onopentagend(this.index);\n            this.enterTagBody();\n            this.sectionStart = this.index + 1;\n        }\n        else if (c === CharCodes.Slash) {\n            this.state = State.InSelfClosingTag;\n        }\n        else if (!isWhitespace(c)) {\n            this.state = State.InAttributeName;\n            this.sectionStart = this.index;\n        }\n    }\n    /**\n     * Handle `/` before `>` in an opening tag.\n     *\n     * In HTML mode, text-only tags ignore the self-closing flag and still enter\n     * their raw-text/RCDATA/plaintext state unless self-closing tags are being\n     * recognized. In XML mode, or for ordinary tags, the tokenizer returns to\n     * regular text parsing after emitting the self-closing callback.\n     * @param c Current character code point.\n     */\n    stateInSelfClosingTag(c) {\n        if (c === CharCodes.Gt) {\n            this.cbs.onselfclosingtag(this.index);\n            this.sectionStart = this.index + 1;\n            if (!this.recognizeSelfClosing) {\n                this.enterTagBody();\n                return;\n            }\n            this.state = State.Text;\n            this.isSpecial = false; // Reset special state, in case of self-closing special tags\n            this.currentSequence = Sequences.Empty;\n        }\n        else if (!isWhitespace(c)) {\n            this.state = State.BeforeAttributeName;\n            this.stateBeforeAttributeName(c);\n        }\n    }\n    stateInAttributeName(c) {\n        if (c === CharCodes.Eq || isEndOfTagSection(c)) {\n            this.cbs.onattribname(this.sectionStart, this.index);\n            this.sectionStart = this.index;\n            this.state = State.AfterAttributeName;\n            this.stateAfterAttributeName(c);\n        }\n    }\n    stateAfterAttributeName(c) {\n        if (c === CharCodes.Eq) {\n            this.state = State.BeforeAttributeValue;\n        }\n        else if (c === CharCodes.Slash || c === CharCodes.Gt) {\n            this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);\n            this.sectionStart = -1;\n            this.state = State.BeforeAttributeName;\n            this.stateBeforeAttributeName(c);\n        }\n        else if (!isWhitespace(c)) {\n            this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);\n            this.state = State.InAttributeName;\n            this.sectionStart = this.index;\n        }\n    }\n    stateBeforeAttributeValue(c) {\n        if (c === CharCodes.DoubleQuote) {\n            this.state = State.InAttributeValueDq;\n            this.sectionStart = this.index + 1;\n        }\n        else if (c === CharCodes.SingleQuote) {\n            this.state = State.InAttributeValueSq;\n            this.sectionStart = this.index + 1;\n        }\n        else if (!isWhitespace(c)) {\n            this.sectionStart = this.index;\n            this.state = State.InAttributeValueNq;\n            this.stateInAttributeValueNoQuotes(c); // Reconsume token\n        }\n    }\n    handleInAttributeValue(c, quote) {\n        if (c === quote ||\n            (!this.decodeEntities && this.fastForwardTo(quote))) {\n            this.cbs.onattribdata(this.sectionStart, this.index);\n            this.sectionStart = -1;\n            this.cbs.onattribend(quote === CharCodes.DoubleQuote\n                ? QuoteType.Double\n                : QuoteType.Single, this.index + 1);\n            this.state = State.BeforeAttributeName;\n        }\n        else if (this.decodeEntities && c === CharCodes.Amp) {\n            this.startEntity();\n        }\n    }\n    stateInAttributeValueDoubleQuotes(c) {\n        this.handleInAttributeValue(c, CharCodes.DoubleQuote);\n    }\n    stateInAttributeValueSingleQuotes(c) {\n        this.handleInAttributeValue(c, CharCodes.SingleQuote);\n    }\n    stateInAttributeValueNoQuotes(c) {\n        if (isWhitespace(c) || c === CharCodes.Gt) {\n            this.cbs.onattribdata(this.sectionStart, this.index);\n            this.sectionStart = -1;\n            this.cbs.onattribend(QuoteType.Unquoted, this.index);\n            this.state = State.BeforeAttributeName;\n            this.stateBeforeAttributeName(c);\n        }\n        else if (this.decodeEntities && c === CharCodes.Amp) {\n            this.startEntity();\n        }\n    }\n    /**\n     * Distinguish between CDATA, declarations, HTML comments, and HTML bogus\n     * comments after `<!`.\n     *\n     * In HTML mode, only real comments and doctypes stay on declaration paths;\n     * everything else becomes a bogus comment terminated by the next `>`.\n     * @param c Current character code point.\n     */\n    stateBeforeDeclaration(c) {\n        if (c === CharCodes.OpeningSquareBracket) {\n            this.state = State.CDATASequence;\n            this.sequenceIndex = 0;\n        }\n        else if (this.xmlMode) {\n            this.state =\n                c === CharCodes.Dash\n                    ? State.BeforeComment\n                    : State.InDeclaration;\n        }\n        else if ((c | 0x20) === Sequences.Doctype[0]) {\n            this.state = State.DeclarationSequence;\n            this.currentSequence = Sequences.Doctype;\n            this.sequenceIndex = 1;\n        }\n        else if (c === CharCodes.Gt) {\n            this.cbs.oncomment(this.sectionStart, this.index, 0);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n        else if (c === CharCodes.Dash) {\n            this.state = State.BeforeComment;\n        }\n        else {\n            this.state = State.InSpecialComment;\n        }\n    }\n    /**\n     * Continue matching `doctype` after `<!d`.\n     *\n     * A full `doctype` match stays on the declaration path; any other name falls\n     * back to an HTML bogus comment, which matches browser behavior for\n     * non-doctype `<!...>` constructs.\n     * @param c Current character code point.\n     */\n    stateDeclarationSequence(c) {\n        if (this.sequenceIndex === this.currentSequence.length) {\n            this.state = State.InDeclaration;\n            this.stateInDeclaration(c);\n        }\n        else if ((c | 0x20) === this.currentSequence[this.sequenceIndex]) {\n            this.sequenceIndex += 1;\n        }\n        else if (c === CharCodes.Gt) {\n            this.cbs.oncomment(this.sectionStart, this.index, 0);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n        else {\n            this.state = State.InSpecialComment;\n        }\n    }\n    stateInDeclaration(c) {\n        if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {\n            this.cbs.ondeclaration(this.sectionStart, this.index);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n    }\n    /**\n     * XML processing instructions (`<?...?>`).\n     *\n     * In HTML mode `<?` is routed to `InSpecialComment` instead, so this\n     * state is only reachable in XML mode.\n     * @param c Current character code point.\n     */\n    stateInProcessingInstruction(c) {\n        if (c === CharCodes.Questionmark) {\n            // Remember that we just consumed `?`, so the next `>` closes the PI.\n            this.sequenceIndex = 1;\n        }\n        else if (c === CharCodes.Gt && this.sequenceIndex === 1) {\n            this.cbs.onprocessinginstruction(this.sectionStart, this.index - 1);\n            this.sequenceIndex = 0;\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n        else {\n            // Keep scanning for the next `?`, which can start a closing `?>`.\n            this.sequenceIndex = Number(this.fastForwardTo(CharCodes.Questionmark));\n        }\n    }\n    stateBeforeComment(c) {\n        if (c === CharCodes.Dash) {\n            this.state = State.InCommentLike;\n            this.currentSequence = Sequences.CommentEnd;\n            this.sequenceIndex = 0;\n            this.sectionStart = this.index + 1;\n        }\n        else if (this.xmlMode) {\n            this.state = State.InDeclaration;\n        }\n        else if (c === CharCodes.Gt) {\n            this.cbs.oncomment(this.sectionStart, this.index, 0);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n        else {\n            this.state = State.InSpecialComment;\n        }\n    }\n    stateInSpecialComment(c) {\n        if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {\n            this.cbs.oncomment(this.sectionStart, this.index, 0);\n            this.state = State.Text;\n            this.sectionStart = this.index + 1;\n        }\n    }\n    startEntity() {\n        this.baseState = this.state;\n        this.state = State.InEntity;\n        this.entityStart = this.index;\n        this.entityDecoder.startEntity(this.xmlMode\n            ? DecodingMode.Strict\n            : this.baseState === State.Text ||\n                this.baseState === State.InSpecialTag\n                ? DecodingMode.Legacy\n                : DecodingMode.Attribute);\n    }\n    stateInEntity() {\n        const indexInBuffer = this.index - this.offset;\n        const length = this.entityDecoder.write(this.buffer, indexInBuffer);\n        // If `length` is positive, we are done with the entity.\n        if (length >= 0) {\n            this.state = this.baseState;\n            if (length === 0) {\n                this.index -= 1;\n            }\n        }\n        else {\n            if (indexInBuffer < this.buffer.length &&\n                this.buffer.charCodeAt(indexInBuffer) === CharCodes.Amp) {\n                this.state = this.baseState;\n                this.index -= 1;\n                return;\n            }\n            // Mark buffer as consumed.\n            this.index = this.offset + this.buffer.length - 1;\n        }\n    }\n    /**\n     * Remove data that has already been consumed from the buffer.\n     */\n    cleanup() {\n        // If we are inside of text or attributes, emit what we already have.\n        if (this.running && this.sectionStart !== this.index) {\n            if (this.state === State.Text ||\n                this.state === State.InPlainText ||\n                (this.state === State.InSpecialTag && this.sequenceIndex === 0)) {\n                this.cbs.ontext(this.sectionStart, this.index);\n                this.sectionStart = this.index;\n            }\n            else if (this.state === State.InAttributeValueDq ||\n                this.state === State.InAttributeValueSq ||\n                this.state === State.InAttributeValueNq) {\n                this.cbs.onattribdata(this.sectionStart, this.index);\n                this.sectionStart = this.index;\n            }\n        }\n    }\n    shouldContinue() {\n        return this.index < this.buffer.length + this.offset && this.running;\n    }\n    /**\n     * Iterates through the buffer, calling the function corresponding to the current state.\n     *\n     * States that are more likely to be hit are higher up, as a performance improvement.\n     */\n    parse() {\n        while (this.shouldContinue()) {\n            const c = this.buffer.charCodeAt(this.index - this.offset);\n            switch (this.state) {\n                case State.Text: {\n                    this.stateText(c);\n                    break;\n                }\n                case State.InPlainText: {\n                    // Skip to end of buffer; cleanup() emits the text.\n                    this.index = this.buffer.length + this.offset - 1;\n                    break;\n                }\n                case State.SpecialStartSequence: {\n                    this.stateSpecialStartSequence(c);\n                    break;\n                }\n                case State.InSpecialTag: {\n                    this.stateInSpecialTag(c);\n                    break;\n                }\n                case State.CDATASequence: {\n                    this.stateCDATASequence(c);\n                    break;\n                }\n                case State.DeclarationSequence: {\n                    this.stateDeclarationSequence(c);\n                    break;\n                }\n                case State.InAttributeValueDq: {\n                    this.stateInAttributeValueDoubleQuotes(c);\n                    break;\n                }\n                case State.InAttributeName: {\n                    this.stateInAttributeName(c);\n                    break;\n                }\n                case State.InCommentLike: {\n                    this.stateInCommentLike(c);\n                    break;\n                }\n                case State.InSpecialComment: {\n                    this.stateInSpecialComment(c);\n                    break;\n                }\n                case State.BeforeAttributeName: {\n                    this.stateBeforeAttributeName(c);\n                    break;\n                }\n                case State.InTagName: {\n                    this.stateInTagName(c);\n                    break;\n                }\n                case State.InClosingTagName: {\n                    this.stateInClosingTagName(c);\n                    break;\n                }\n                case State.BeforeTagName: {\n                    this.stateBeforeTagName(c);\n                    break;\n                }\n                case State.AfterAttributeName: {\n                    this.stateAfterAttributeName(c);\n                    break;\n                }\n                case State.InAttributeValueSq: {\n                    this.stateInAttributeValueSingleQuotes(c);\n                    break;\n                }\n                case State.BeforeAttributeValue: {\n                    this.stateBeforeAttributeValue(c);\n                    break;\n                }\n                case State.BeforeClosingTagName: {\n                    this.stateBeforeClosingTagName(c);\n                    break;\n                }\n                case State.AfterClosingTagName: {\n                    this.stateAfterClosingTagName(c);\n                    break;\n                }\n                case State.InAttributeValueNq: {\n                    this.stateInAttributeValueNoQuotes(c);\n                    break;\n                }\n                case State.InSelfClosingTag: {\n                    this.stateInSelfClosingTag(c);\n                    break;\n                }\n                case State.InDeclaration: {\n                    this.stateInDeclaration(c);\n                    break;\n                }\n                case State.BeforeDeclaration: {\n                    this.stateBeforeDeclaration(c);\n                    break;\n                }\n                case State.BeforeComment: {\n                    this.stateBeforeComment(c);\n                    break;\n                }\n                case State.InProcessingInstruction: {\n                    this.stateInProcessingInstruction(c);\n                    break;\n                }\n                case State.InEntity: {\n                    this.stateInEntity();\n                    break;\n                }\n            }\n            this.index++;\n        }\n        this.cleanup();\n    }\n    finish() {\n        if (this.state === State.InEntity) {\n            this.entityDecoder.end();\n            this.state = this.baseState;\n        }\n        this.handleTrailingData();\n        this.cbs.onend();\n    }\n    handleTrailingCommentLikeData(endIndex) {\n        if (this.state !== State.InCommentLike) {\n            return false;\n        }\n        if (this.currentSequence === Sequences.CdataEnd) {\n            if (this.xmlMode) {\n                if (this.sectionStart < endIndex) {\n                    this.cbs.oncdata(this.sectionStart, endIndex, 0);\n                }\n            }\n            else {\n                /* In HTML mode, unclosed CDATA is a bogus comment. */\n                const cdataStart = this.sectionStart - Sequences.Cdata.length - 1;\n                this.cbs.oncomment(cdataStart, endIndex, 0);\n            }\n        }\n        else {\n            const offset = this.xmlMode\n                ? 0\n                : Math.min(this.sequenceIndex, Sequences.CommentEnd.length - 1);\n            this.cbs.oncomment(this.sectionStart, endIndex, offset);\n        }\n        return true;\n    }\n    handleTrailingMarkupDeclaration(endIndex) {\n        if (this.xmlMode) {\n            switch (this.state) {\n                case State.InSpecialComment:\n                case State.BeforeComment:\n                case State.CDATASequence:\n                case State.DeclarationSequence:\n                case State.InDeclaration: {\n                    this.cbs.ontext(this.sectionStart, endIndex);\n                    return true;\n                }\n                default: {\n                    return false;\n                }\n            }\n        }\n        switch (this.state) {\n            case State.BeforeDeclaration:\n            case State.InSpecialComment:\n            case State.BeforeComment:\n            case State.CDATASequence: {\n                this.cbs.oncomment(this.sectionStart, endIndex, 0);\n                return true;\n            }\n            case State.DeclarationSequence: {\n                if (this.sequenceIndex !== Sequences.Doctype.length) {\n                    this.cbs.oncomment(this.sectionStart, endIndex, 0);\n                }\n                return true;\n            }\n            case State.InDeclaration: {\n                return true;\n            }\n            default: {\n                return false;\n            }\n        }\n    }\n    /** Handle any trailing data. */\n    handleTrailingData() {\n        const endIndex = this.buffer.length + this.offset;\n        if (this.handleTrailingCommentLikeData(endIndex) ||\n            this.handleTrailingMarkupDeclaration(endIndex)) {\n            return;\n        }\n        // If there is no remaining data, we are done.\n        if (this.sectionStart >= endIndex) {\n            return;\n        }\n        switch (this.state) {\n            case State.InTagName:\n            case State.BeforeAttributeName:\n            case State.BeforeAttributeValue:\n            case State.AfterAttributeName:\n            case State.InAttributeName:\n            case State.InAttributeValueSq:\n            case State.InAttributeValueDq:\n            case State.InAttributeValueNq:\n            case State.InClosingTagName: {\n                /*\n                 * If we are currently in an opening or closing tag, us not calling the\n                 * respective callback signals that the tag should be ignored.\n                 */\n                break;\n            }\n            default: {\n                this.cbs.ontext(this.sectionStart, endIndex);\n            }\n        }\n    }\n    emitCodePoint(cp, consumed) {\n        if (this.baseState !== State.Text &&\n            this.baseState !== State.InSpecialTag) {\n            if (this.sectionStart < this.entityStart) {\n                this.cbs.onattribdata(this.sectionStart, this.entityStart);\n            }\n            this.sectionStart = this.entityStart + consumed;\n            this.index = this.sectionStart - 1;\n            this.cbs.onattribentity(cp);\n        }\n        else {\n            if (this.sectionStart < this.entityStart) {\n                this.cbs.ontext(this.sectionStart, this.entityStart);\n            }\n            this.sectionStart = this.entityStart + consumed;\n            this.index = this.sectionStart - 1;\n            this.cbs.ontextentity(cp, this.sectionStart);\n        }\n    }\n}\n//# sourceMappingURL=Tokenizer.js.map","const { fromCodePoint } = String;\nimport Tokenizer, { QuoteType } from \"./Tokenizer.js\";\nconst formTags = new Set([\n    \"input\",\n    \"option\",\n    \"optgroup\",\n    \"select\",\n    \"button\",\n    \"datalist\",\n    \"textarea\",\n]);\nconst pTag = new Set([\"p\"]);\nconst headingTags = new Set([\"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"p\"]);\nconst tableSectionTags = new Set([\"thead\", \"tbody\"]);\nconst ddtTags = new Set([\"dd\", \"dt\"]);\nconst rtpTags = new Set([\"rt\", \"rp\"]);\nconst openImpliesClose = new Map([\n    [\"tr\", new Set([\"tr\", \"th\", \"td\"])],\n    [\"th\", new Set([\"th\"])],\n    [\"td\", new Set([\"thead\", \"th\", \"td\"])],\n    [\"body\", new Set([\"head\", \"link\", \"script\"])],\n    [\"a\", new Set([\"a\"])],\n    [\"li\", new Set([\"li\"])],\n    [\"p\", pTag],\n    [\"h1\", headingTags],\n    [\"h2\", headingTags],\n    [\"h3\", headingTags],\n    [\"h4\", headingTags],\n    [\"h5\", headingTags],\n    [\"h6\", headingTags],\n    [\"select\", formTags],\n    [\"input\", formTags],\n    [\"output\", formTags],\n    [\"button\", formTags],\n    [\"datalist\", formTags],\n    [\"textarea\", formTags],\n    [\"option\", new Set([\"option\"])],\n    [\"optgroup\", new Set([\"optgroup\", \"option\"])],\n    [\"dd\", ddtTags],\n    [\"dt\", ddtTags],\n    [\"address\", pTag],\n    [\"article\", pTag],\n    [\"aside\", pTag],\n    [\"blockquote\", pTag],\n    [\"details\", pTag],\n    [\"div\", pTag],\n    [\"dl\", pTag],\n    [\"fieldset\", pTag],\n    [\"figcaption\", pTag],\n    [\"figure\", pTag],\n    [\"footer\", pTag],\n    [\"form\", pTag],\n    [\"header\", pTag],\n    [\"hr\", pTag],\n    [\"main\", pTag],\n    [\"nav\", pTag],\n    [\"ol\", pTag],\n    [\"pre\", pTag],\n    [\"section\", pTag],\n    [\"table\", pTag],\n    [\"ul\", pTag],\n    [\"rt\", rtpTags],\n    [\"rp\", rtpTags],\n    [\"tbody\", tableSectionTags],\n    [\"tfoot\", tableSectionTags],\n]);\nconst DOCUMENT_TYPE = \"doctype\";\nconst voidElements = new Set([\n    \"area\",\n    \"base\",\n    \"basefont\",\n    \"br\",\n    \"col\",\n    \"command\",\n    \"embed\",\n    \"frame\",\n    \"hr\",\n    \"img\",\n    \"input\",\n    \"isindex\",\n    \"keygen\",\n    \"link\",\n    \"meta\",\n    \"param\",\n    \"source\",\n    \"track\",\n    \"wbr\",\n]);\nconst foreignContextElements = new Set([\"math\", \"svg\"]);\n/**\n * Elements that can be used to integrate HTML content within foreign namespaces (e.g., SVG or MathML).\n *\n * Entries must use the SVG-adjusted casing (e.g. \"foreignObject\" not\n * \"foreignobject\") since they are compared against adjusted tag names.\n */\nconst htmlIntegrationElements = new Set([\n    \"mi\",\n    \"mo\",\n    \"mn\",\n    \"ms\",\n    \"mtext\",\n    \"annotation-xml\",\n    \"foreignObject\",\n    \"desc\",\n    \"title\",\n]);\nconst svgTagNameAdjustments = new Map([\n    [\"altglyph\", \"altGlyph\"],\n    [\"altglyphdef\", \"altGlyphDef\"],\n    [\"altglyphitem\", \"altGlyphItem\"],\n    [\"animatecolor\", \"animateColor\"],\n    [\"animatemotion\", \"animateMotion\"],\n    [\"animatetransform\", \"animateTransform\"],\n    [\"clippath\", \"clipPath\"],\n    [\"feblend\", \"feBlend\"],\n    [\"fecolormatrix\", \"feColorMatrix\"],\n    [\"fecomponenttransfer\", \"feComponentTransfer\"],\n    [\"fecomposite\", \"feComposite\"],\n    [\"feconvolvematrix\", \"feConvolveMatrix\"],\n    [\"fediffuselighting\", \"feDiffuseLighting\"],\n    [\"fedisplacementmap\", \"feDisplacementMap\"],\n    [\"fedistantlight\", \"feDistantLight\"],\n    [\"fedropshadow\", \"feDropShadow\"],\n    [\"feflood\", \"feFlood\"],\n    [\"fefunca\", \"feFuncA\"],\n    [\"fefuncb\", \"feFuncB\"],\n    [\"fefuncg\", \"feFuncG\"],\n    [\"fefuncr\", \"feFuncR\"],\n    [\"fegaussianblur\", \"feGaussianBlur\"],\n    [\"feimage\", \"feImage\"],\n    [\"femerge\", \"feMerge\"],\n    [\"femergenode\", \"feMergeNode\"],\n    [\"femorphology\", \"feMorphology\"],\n    [\"feoffset\", \"feOffset\"],\n    [\"fepointlight\", \"fePointLight\"],\n    [\"fespecularlighting\", \"feSpecularLighting\"],\n    [\"fespotlight\", \"feSpotLight\"],\n    [\"fetile\", \"feTile\"],\n    [\"feturbulence\", \"feTurbulence\"],\n    [\"foreignobject\", \"foreignObject\"],\n    [\"glyphref\", \"glyphRef\"],\n    [\"lineargradient\", \"linearGradient\"],\n    [\"radialgradient\", \"radialGradient\"],\n    [\"textpath\", \"textPath\"],\n]);\nvar ForeignContext;\n(function (ForeignContext) {\n    ForeignContext[ForeignContext[\"None\"] = 0] = \"None\";\n    ForeignContext[ForeignContext[\"Svg\"] = 1] = \"Svg\";\n    ForeignContext[ForeignContext[\"MathML\"] = 2] = \"MathML\";\n})(ForeignContext || (ForeignContext = {}));\nconst reNameEnd = /\\s|\\//;\n/**\n * Incremental parser implementation.\n */\nexport class Parser {\n    options;\n    /** The start index of the last event. */\n    startIndex = 0;\n    /** The end index of the last event. */\n    endIndex = 0;\n    /**\n     * Store the start index of the current open tag,\n     * so we can update the start index for attributes.\n     */\n    openTagStart = 0;\n    tagname = \"\";\n    attribname = \"\";\n    attribvalue = \"\";\n    attribs = null;\n    stack = [];\n    foreignContext;\n    cbs;\n    lowerCaseTagNames;\n    lowerCaseAttributeNames;\n    recognizeSelfClosing;\n    /** We are parsing HTML. Inverse of the `xmlMode` option. */\n    htmlMode;\n    tokenizer;\n    buffers = [];\n    bufferOffset = 0;\n    /** The index of the last written buffer. Used when resuming after a `pause()`. */\n    writeIndex = 0;\n    /** Indicates whether the parser has finished running / `.end` has been called. */\n    ended = false;\n    constructor(cbs, options = {}) {\n        this.options = options;\n        this.cbs = cbs ?? {};\n        this.htmlMode = !this.options.xmlMode;\n        this.lowerCaseTagNames = options.lowerCaseTags ?? this.htmlMode;\n        this.lowerCaseAttributeNames =\n            options.lowerCaseAttributeNames ?? this.htmlMode;\n        this.recognizeSelfClosing =\n            options.recognizeSelfClosing ?? !this.htmlMode;\n        this.tokenizer = new (options.Tokenizer ?? Tokenizer)(this.options, this);\n        this.foreignContext = [ForeignContext.None];\n        this.cbs.onparserinit?.(this);\n    }\n    // Tokenizer event handlers\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    ontext(start, endIndex) {\n        const data = this.getSlice(start, endIndex);\n        this.endIndex = endIndex - 1;\n        this.cbs.ontext?.(data);\n        this.startIndex = endIndex;\n    }\n    /**\n     * @param cp Current Unicode code point.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    ontextentity(cp, endIndex) {\n        this.endIndex = endIndex - 1;\n        this.cbs.ontext?.(fromCodePoint(cp));\n        this.startIndex = endIndex;\n    }\n    /** @internal */\n    isInForeignContext() {\n        return this.foreignContext[0] !== ForeignContext.None;\n    }\n    /**\n     * Checks if the current tag is a void element. Override this if you want\n     * to specify your own additional void elements.\n     * @param name Name of the pseudo selector.\n     */\n    isVoidElement(name) {\n        return this.htmlMode && voidElements.has(name);\n    }\n    /**\n     * Read a tag name from the buffer.\n     *\n     * When `lowerCaseTagNames` is enabled (the default in HTML mode), the name\n     * is lowercased and may be adjusted for SVG casing or the `image` → `img`\n     * alias.\n     * @param start Start index of the tag name in the buffer.\n     * @param endIndex End index of the tag name in the buffer.\n     */\n    readTagName(start, endIndex) {\n        const name = this.lowerCaseTagNames\n            ? this.getSlice(start, endIndex).toLowerCase()\n            : this.getSlice(start, endIndex);\n        if (!(this.lowerCaseTagNames && this.htmlMode)) {\n            return name;\n        }\n        if (this.foreignContext[0] === ForeignContext.Svg) {\n            return svgTagNameAdjustments.get(name) ?? name;\n        }\n        /*\n         * Closing tags for SVG elements inside HTML integration points\n         * (e.g. </foreignObject> while inside its own content) need case\n         * adjustment so the name matches what was pushed to the stack.\n         * `foreignContext.length > 1` means a foreign ancestor exists —\n         * the base [None] entry plus at least one pushed context.\n         */\n        if (this.foreignContext.length > 1) {\n            const adjusted = svgTagNameAdjustments.get(name);\n            if (adjusted !== undefined && this.stack.includes(adjusted)) {\n                return adjusted;\n            }\n        }\n        if (!this.isInForeignContext()) {\n            return name === \"image\" ? \"img\" : name;\n        }\n        return name;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onopentagname(start, endIndex) {\n        this.endIndex = endIndex;\n        this.emitOpenTag(this.readTagName(start, endIndex));\n    }\n    emitOpenTag(name) {\n        this.openTagStart = this.startIndex;\n        this.tagname = name;\n        /*\n         * The spec ignores a second <form> when one is already open.\n         * Setting tagname to \"\" suppresses all downstream effects: attribs\n         * stays null so endOpenTag is a no-op, and closeCurrentTag can't\n         * match \"\" on the stack.\n         */\n        if (this.htmlMode && name === \"form\" && this.stack.includes(\"form\")) {\n            this.tagname = \"\";\n            return;\n        }\n        const impliesClose = this.htmlMode && openImpliesClose.get(name);\n        if (impliesClose) {\n            while (this.stack.length > 0 && impliesClose.has(this.stack[0])) {\n                this.popElement(true);\n            }\n        }\n        if (!this.isVoidElement(name)) {\n            this.stack.unshift(name);\n            if (this.htmlMode) {\n                if (name === \"svg\") {\n                    this.foreignContext.unshift(ForeignContext.Svg);\n                }\n                else if (name === \"math\") {\n                    this.foreignContext.unshift(ForeignContext.MathML);\n                }\n                else if (htmlIntegrationElements.has(name)) {\n                    this.foreignContext.unshift(ForeignContext.None);\n                }\n            }\n        }\n        this.cbs.onopentagname?.(name);\n        if (this.cbs.onopentag)\n            this.attribs = {};\n    }\n    endOpenTag(isImplied) {\n        this.startIndex = this.openTagStart;\n        if (this.attribs) {\n            this.cbs.onopentag?.(this.tagname, this.attribs, isImplied);\n            this.attribs = null;\n        }\n        if (this.cbs.onclosetag && this.isVoidElement(this.tagname)) {\n            this.cbs.onclosetag(this.tagname, true);\n        }\n        this.tagname = \"\";\n    }\n    /**\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onopentagend(endIndex) {\n        this.endIndex = endIndex;\n        this.endOpenTag(false);\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onclosetag(start, endIndex) {\n        this.endIndex = endIndex;\n        const name = this.readTagName(start, endIndex);\n        if (!this.isVoidElement(name)) {\n            const pos = this.stack.indexOf(name);\n            if (pos !== -1) {\n                for (let index = 0; index < pos; index++) {\n                    this.popElement(true);\n                }\n                this.popElement(false);\n            }\n            else if (this.htmlMode && name === \"p\") {\n                // Implicit open before close\n                this.emitOpenTag(\"p\");\n                this.closeCurrentTag(true);\n            }\n        }\n        else if (this.htmlMode && name === \"br\") {\n            // We can't use `emitOpenTag` for implicit open, as `br` would be implicitly closed.\n            this.cbs.onopentagname?.(\"br\");\n            this.cbs.onopentag?.(\"br\", {}, true);\n            this.cbs.onclosetag?.(\"br\", false);\n        }\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onselfclosingtag(endIndex) {\n        this.endIndex = endIndex;\n        if (this.recognizeSelfClosing || this.isInForeignContext()) {\n            this.closeCurrentTag(false);\n            // Set `startIndex` for next node\n            this.startIndex = endIndex + 1;\n        }\n        else {\n            // Ignore the fact that the tag is self-closing.\n            this.onopentagend(endIndex);\n        }\n    }\n    /**\n     * Pop the top element off the stack, emit a close event, and maintain\n     * the foreign context stack.\n     * @param implied Whether this close is implied (not from an explicit end tag).\n     */\n    popElement(implied) {\n        // biome-ignore lint/style/noNonNullAssertion: The element is guaranteed to exist.\n        const element = this.stack.shift();\n        if (this.htmlMode &&\n            (foreignContextElements.has(element) ||\n                htmlIntegrationElements.has(element))) {\n            this.foreignContext.shift();\n        }\n        this.cbs.onclosetag?.(element, implied);\n    }\n    closeCurrentTag(isOpenImplied) {\n        const name = this.tagname;\n        this.endOpenTag(isOpenImplied);\n        // Self-closing tags will be on the top of the stack\n        if (this.stack[0] === name) {\n            this.popElement(!isOpenImplied);\n        }\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onattribname(start, endIndex) {\n        this.startIndex = start;\n        const name = this.getSlice(start, endIndex);\n        this.attribname = this.lowerCaseAttributeNames\n            ? name.toLowerCase()\n            : name;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onattribdata(start, endIndex) {\n        this.attribvalue += this.getSlice(start, endIndex);\n    }\n    /**\n     * @param cp Current Unicode code point.\n     * @internal\n     */\n    onattribentity(cp) {\n        this.attribvalue += fromCodePoint(cp);\n    }\n    /**\n     * @param quote Quote type used for the current attribute.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onattribend(quote, endIndex) {\n        this.endIndex = endIndex;\n        this.cbs.onattribute?.(this.attribname, this.attribvalue, quote === QuoteType.Double\n            ? '\"'\n            : quote === QuoteType.Single\n                ? \"'\"\n                : quote === QuoteType.NoValue\n                    ? undefined\n                    : null);\n        if (this.attribs && !Object.hasOwn(this.attribs, this.attribname)) {\n            this.attribs[this.attribname] = this.attribvalue;\n        }\n        this.attribvalue = \"\";\n    }\n    getInstructionName(value) {\n        const index = value.search(reNameEnd);\n        let name = index < 0 ? value : value.substr(0, index);\n        if (this.lowerCaseTagNames) {\n            name = name.toLowerCase();\n        }\n        return name;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    ondeclaration(start, endIndex) {\n        this.endIndex = endIndex;\n        const value = this.getSlice(start, endIndex);\n        if (this.cbs.onprocessinginstruction) {\n            /*\n             * In HTML mode, ondeclaration is only reached for DOCTYPE\n             * (the tokenizer routes everything else to bogus comments).\n             */\n            const name = this.htmlMode\n                ? this.lowerCaseTagNames\n                    ? DOCUMENT_TYPE\n                    : value.slice(0, DOCUMENT_TYPE.length)\n                : this.getInstructionName(value);\n            this.cbs.onprocessinginstruction(`!${name}`, `!${value}`);\n        }\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @internal\n     */\n    onprocessinginstruction(start, endIndex) {\n        this.endIndex = endIndex;\n        const value = this.getSlice(start, endIndex);\n        if (this.cbs.onprocessinginstruction) {\n            const name = this.getInstructionName(value);\n            this.cbs.onprocessinginstruction(`?${name}`, `?${value}`);\n        }\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @param offset Offset applied when computing parser indices.\n     * @internal\n     */\n    oncomment(start, endIndex, offset) {\n        this.endIndex = endIndex;\n        this.cbs.oncomment?.(this.getSlice(start, endIndex - offset));\n        this.cbs.oncommentend?.();\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /**\n     * @param start Start index for the current parser event.\n     * @param endIndex End index for the current parser event.\n     * @param offset Offset applied when computing parser indices.\n     * @internal\n     */\n    oncdata(start, endIndex, offset) {\n        this.endIndex = endIndex;\n        const value = this.getSlice(start, endIndex - offset);\n        if (!this.htmlMode || this.options.recognizeCDATA) {\n            this.cbs.oncdatastart?.();\n            this.cbs.ontext?.(value);\n            this.cbs.oncdataend?.();\n        }\n        else if (this.isInForeignContext()) {\n            this.cbs.ontext?.(value);\n        }\n        else {\n            this.cbs.oncomment?.(`[CDATA[${value}]]`);\n            this.cbs.oncommentend?.();\n        }\n        // Set `startIndex` for next node\n        this.startIndex = endIndex + 1;\n    }\n    /** @internal */\n    onend() {\n        if (this.cbs.onclosetag) {\n            // Set the end index for all remaining tags\n            this.endIndex = this.startIndex;\n            for (let index = 0; index < this.stack.length; index++) {\n                this.cbs.onclosetag(this.stack[index], true);\n            }\n        }\n        this.cbs.onend?.();\n    }\n    /**\n     * Resets the parser to a blank state, ready to parse a new HTML document\n     */\n    reset() {\n        this.cbs.onreset?.();\n        this.tokenizer.reset();\n        this.tagname = \"\";\n        this.attribname = \"\";\n        this.attribvalue = \"\";\n        this.attribs = null;\n        this.stack.length = 0;\n        this.startIndex = 0;\n        this.endIndex = 0;\n        this.cbs.onparserinit?.(this);\n        this.buffers.length = 0;\n        this.foreignContext.length = 0;\n        this.foreignContext.unshift(ForeignContext.None);\n        this.bufferOffset = 0;\n        this.writeIndex = 0;\n        this.ended = false;\n    }\n    /**\n     * Resets the parser, then parses a complete document and\n     * pushes it to the handler.\n     * @param data Document to parse.\n     */\n    parseComplete(data) {\n        this.reset();\n        this.end(data);\n    }\n    getSlice(start, end) {\n        if (start === end) {\n            return \"\";\n        }\n        while (start - this.bufferOffset >= this.buffers[0].length) {\n            this.shiftBuffer();\n        }\n        let slice = this.buffers[0].slice(start - this.bufferOffset, end - this.bufferOffset);\n        while (end - this.bufferOffset > this.buffers[0].length) {\n            this.shiftBuffer();\n            slice += this.buffers[0].slice(0, end - this.bufferOffset);\n        }\n        return slice;\n    }\n    shiftBuffer() {\n        this.bufferOffset += this.buffers[0].length;\n        this.writeIndex--;\n        this.buffers.shift();\n    }\n    /**\n     * Parses a chunk of data and calls the corresponding callbacks.\n     * @param chunk Chunk to parse.\n     */\n    write(chunk) {\n        if (this.ended) {\n            this.cbs.onerror?.(new Error(\".write() after done!\"));\n            return;\n        }\n        this.buffers.push(chunk);\n        if (this.tokenizer.running) {\n            this.tokenizer.write(chunk);\n            this.writeIndex++;\n        }\n    }\n    /**\n     * Parses the end of the buffer and clears the stack, calls onend.\n     * @param chunk Optional final chunk to parse.\n     */\n    end(chunk) {\n        if (this.ended) {\n            this.cbs.onerror?.(new Error(\".end() after done!\"));\n            return;\n        }\n        if (chunk)\n            this.write(chunk);\n        this.ended = true;\n        this.tokenizer.end();\n    }\n    /**\n     * Pauses parsing. The parser won't emit events until `resume` is called.\n     */\n    pause() {\n        this.tokenizer.pause();\n    }\n    /**\n     * Resumes parsing after `pause` was called.\n     */\n    resume() {\n        this.tokenizer.resume();\n        while (this.tokenizer.running &&\n            this.writeIndex < this.buffers.length) {\n            this.tokenizer.write(this.buffers[this.writeIndex++]);\n        }\n        if (this.ended)\n            this.tokenizer.end();\n    }\n}\n//# sourceMappingURL=Parser.js.map"],"x_google_ignoreList":[0,1,2,3,4,5,6,7],"mappings":"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"}