• Version 0.5.11
  • Published
  • 455 kB
  • No dependencies
  • MIT license


npm i simple-html-tokenizer
yarn add simple-html-tokenizer
pnpm add simple-html-tokenizer


Simple HTML Tokenizer is a lightweight JavaScript library that can be used to tokenize the kind of HTML normally found in templates.







Type Aliases


variable HTML5NamedCharRefs

const HTML5NamedCharRefs: {
Aacute: string;
aacute: string;
Abreve: string;
abreve: string;
ac: string;
acd: string;
acE: string;
Acirc: string;
acirc: string;
acute: string;
Acy: string;
acy: string;
AElig: string;
aelig: string;
af: string;
Afr: string;
afr: string;
Agrave: string;
agrave: string;
alefsym: string;
aleph: string;
Alpha: string;
alpha: string;
Amacr: string;
amacr: string;
amalg: string;
amp: string;
AMP: string;
andand: string;
And: string;
and: string;
andd: string;
andslope: string;
andv: string;
ang: string;
ange: string;
angle: string;
angmsdaa: string;
angmsdab: string;
angmsdac: string;
angmsdad: string;
angmsdae: string;
angmsdaf: string;
angmsdag: string;
angmsdah: string;
angmsd: string;
angrt: string;
angrtvb: string;
angrtvbd: string;
angsph: string;
angst: string;
angzarr: string;
Aogon: string;
aogon: string;
Aopf: string;
aopf: string;
apacir: string;
ap: string;
apE: string;
ape: string;
apid: string;
apos: string;
ApplyFunction: string;
approx: string;
approxeq: string;
Aring: string;
aring: string;
Ascr: string;
ascr: string;
Assign: string;
ast: string;
asymp: string;
asympeq: string;
Atilde: string;
atilde: string;
Auml: string;
auml: string;
awconint: string;
awint: string;
backcong: string;
backepsilon: string;
backprime: string;
backsim: string;
backsimeq: string;
Backslash: string;
Barv: string;
barvee: string;
barwed: string;
Barwed: string;
barwedge: string;
bbrk: string;
bbrktbrk: string;
bcong: string;
Bcy: string;
bcy: string;
bdquo: string;
becaus: string;
because: string;
Because: string;
bemptyv: string;
bepsi: string;
bernou: string;
Bernoullis: string;
Beta: string;
beta: string;
beth: string;
between: string;
Bfr: string;
bfr: string;
bigcap: string;
bigcirc: string;
bigcup: string;
bigodot: string;
bigoplus: string;
bigotimes: string;
bigsqcup: string;
bigstar: string;
bigtriangledown: string;
bigtriangleup: string;
biguplus: string;
bigvee: string;
bigwedge: string;
bkarow: string;
blacklozenge: string;
blacksquare: string;
blacktriangle: string;
blacktriangledown: string;
blacktriangleleft: string;
blacktriangleright: string;
blank: string;
blk12: string;
blk14: string;
blk34: string;
block: string;
bne: string;
bnequiv: string;
bNot: string;
bnot: string;
Bopf: string;
bopf: string;
bot: string;
bottom: string;
bowtie: string;
boxbox: string;
boxdl: string;
boxdL: string;
boxDl: string;
boxDL: string;
boxdr: string;
boxdR: string;
boxDr: string;
boxDR: string;
boxh: string;
boxH: string;
boxhd: string;
boxHd: string;
boxhD: string;
boxHD: string;
boxhu: string;
boxHu: string;
boxhU: string;
boxHU: string;
boxminus: string;
boxplus: string;
boxtimes: string;
boxul: string;
boxuL: string;
boxUl: string;
boxUL: string;
boxur: string;
boxuR: string;
boxUr: string;
boxUR: string;
boxv: string;
boxV: string;
boxvh: string;
boxvH: string;
boxVh: string;
boxVH: string;
boxvl: string;
boxvL: string;
boxVl: string;
boxVL: string;
boxvr: string;
boxvR: string;
boxVr: string;
boxVR: string;
bprime: string;
breve: string;
Breve: string;
brvbar: string;
bscr: string;
Bscr: string;
bsemi: string;
bsim: string;
bsime: string;
bsolb: string;
bsol: string;
bsolhsub: string;
bull: string;
bullet: string;
bump: string;
bumpE: string;
bumpe: string;
Bumpeq: string;
bumpeq: string;
Cacute: string;
cacute: string;
capand: string;
capbrcup: string;
capcap: string;
cap: string;
Cap: string;
capcup: string;
capdot: string;
CapitalDifferentialD: string;
caps: string;
caret: string;
caron: string;
Cayleys: string;
ccaps: string;
Ccaron: string;
ccaron: string;
Ccedil: string;
ccedil: string;
Ccirc: string;
ccirc: string;
Cconint: string;
ccups: string;
ccupssm: string;
Cdot: string;
cdot: string;
cedil: string;
Cedilla: string;
cemptyv: string;
cent: string;
centerdot: string;
CenterDot: string;
cfr: string;
Cfr: string;
CHcy: string;
chcy: string;
check: string;
checkmark: string;
Chi: string;
chi: string;
circ: string;
circeq: string;
circlearrowleft: string;
circlearrowright: string;
circledast: string;
circledcirc: string;
circleddash: string;
CircleDot: string;
circledR: string;
circledS: string;
CircleMinus: string;
CirclePlus: string;
CircleTimes: string;
cir: string;
cirE: string;
cire: string;
cirfnint: string;
cirmid: string;
cirscir: string;
ClockwiseContourIntegral: string;
CloseCurlyDoubleQuote: string;
CloseCurlyQuote: string;
clubs: string;
clubsuit: string;
colon: string;
Colon: string;
Colone: string;
colone: string;
coloneq: string;
comma: string;
commat: string;
comp: string;
compfn: string;
complement: string;
complexes: string;
cong: string;
congdot: string;
Congruent: string;
conint: string;
Conint: string;
ContourIntegral: string;
copf: string;
Copf: string;
coprod: string;
Coproduct: string;
copy: string;
COPY: string;
copysr: string;
CounterClockwiseContourIntegral: string;
crarr: string;
cross: string;
Cross: string;
Cscr: string;
cscr: string;
csub: string;
csube: string;
csup: string;
csupe: string;
ctdot: string;
cudarrl: string;
cudarrr: string;
cuepr: string;
cuesc: string;
cularr: string;
cularrp: string;
cupbrcap: string;
cupcap: string;
CupCap: string;
cup: string;
Cup: string;
cupcup: string;
cupdot: string;
cupor: string;
cups: string;
curarr: string;
curarrm: string;
curlyeqprec: string;
curlyeqsucc: string;
curlyvee: string;
curlywedge: string;
curren: string;
curvearrowleft: string;
curvearrowright: string;
cuvee: string;
cuwed: string;
cwconint: string;
cwint: string;
cylcty: string;
dagger: string;
Dagger: string;
daleth: string;
darr: string;
Darr: string;
dArr: string;
dash: string;
Dashv: string;
dashv: string;
dbkarow: string;
dblac: string;
Dcaron: string;
dcaron: string;
Dcy: string;
dcy: string;
ddagger: string;
ddarr: string;
DD: string;
dd: string;
DDotrahd: string;
ddotseq: string;
deg: string;
Del: string;
Delta: string;
delta: string;
demptyv: string;
dfisht: string;
Dfr: string;
dfr: string;
dHar: string;
dharl: string;
dharr: string;
DiacriticalAcute: string;
DiacriticalDot: string;
DiacriticalDoubleAcute: string;
DiacriticalGrave: string;
DiacriticalTilde: string;
diam: string;
diamond: string;
Diamond: string;
diamondsuit: string;
diams: string;
die: string;
DifferentialD: string;
digamma: string;
disin: string;
div: string;
divide: string;
divideontimes: string;
divonx: string;
DJcy: string;
djcy: string;
dlcorn: string;
dlcrop: string;
dollar: string;
Dopf: string;
dopf: string;
Dot: string;
dot: string;
DotDot: string;
doteq: string;
doteqdot: string;
DotEqual: string;
dotminus: string;
dotplus: string;
dotsquare: string;
doublebarwedge: string;
DoubleContourIntegral: string;
DoubleDot: string;
DoubleDownArrow: string;
DoubleLeftArrow: string;
DoubleLeftRightArrow: string;
DoubleLeftTee: string;
DoubleLongLeftArrow: string;
DoubleLongLeftRightArrow: string;
DoubleLongRightArrow: string;
DoubleRightArrow: string;
DoubleRightTee: string;
DoubleUpArrow: string;
DoubleUpDownArrow: string;
DoubleVerticalBar: string;
DownArrowBar: string;
downarrow: string;
DownArrow: string;
Downarrow: string;
DownArrowUpArrow: string;
DownBreve: string;
downdownarrows: string;
downharpoonleft: string;
downharpoonright: string;
DownLeftRightVector: string;
DownLeftTeeVector: string;
DownLeftVectorBar: string;
DownLeftVector: string;
DownRightTeeVector: string;
DownRightVectorBar: string;
DownRightVector: string;
DownTeeArrow: string;
DownTee: string;
drbkarow: string;
drcorn: string;
drcrop: string;
Dscr: string;
dscr: string;
DScy: string;
dscy: string;
dsol: string;
Dstrok: string;
dstrok: string;
dtdot: string;
dtri: string;
dtrif: string;
duarr: string;
duhar: string;
dwangle: string;
DZcy: string;
dzcy: string;
dzigrarr: string;
Eacute: string;
eacute: string;
easter: string;
Ecaron: string;
ecaron: string;
Ecirc: string;
ecirc: string;
ecir: string;
ecolon: string;
Ecy: string;
ecy: string;
eDDot: string;
Edot: string;
edot: string;
eDot: string;
ee: string;
efDot: string;
Efr: string;
efr: string;
eg: string;
Egrave: string;
egrave: string;
egs: string;
egsdot: string;
el: string;
Element: string;
elinters: string;
ell: string;
els: string;
elsdot: string;
Emacr: string;
emacr: string;
empty: string;
emptyset: string;
EmptySmallSquare: string;
emptyv: string;
EmptyVerySmallSquare: string;
emsp13: string;
emsp14: string;
emsp: string;
ENG: string;
eng: string;
ensp: string;
Eogon: string;
eogon: string;
Eopf: string;
eopf: string;
epar: string;
eparsl: string;
eplus: string;
epsi: string;
Epsilon: string;
epsilon: string;
epsiv: string;
eqcirc: string;
eqcolon: string;
eqsim: string;
eqslantgtr: string;
eqslantless: string;
Equal: string;
equals: string;
EqualTilde: string;
equest: string;
Equilibrium: string;
equiv: string;
equivDD: string;
eqvparsl: string;
erarr: string;
erDot: string;
escr: string;
Escr: string;
esdot: string;
Esim: string;
esim: string;
Eta: string;
eta: string;
ETH: string;
eth: string;
Euml: string;
euml: string;
euro: string;
excl: string;
exist: string;
Exists: string;
expectation: string;
exponentiale: string;
ExponentialE: string;
fallingdotseq: string;
Fcy: string;
fcy: string;
female: string;
ffilig: string;
fflig: string;
ffllig: string;
Ffr: string;
ffr: string;
filig: string;
FilledSmallSquare: string;
FilledVerySmallSquare: string;
fjlig: string;
flat: string;
fllig: string;
fltns: string;
fnof: string;
Fopf: string;
fopf: string;
forall: string;
ForAll: string;
fork: string;
forkv: string;
Fouriertrf: string;
fpartint: string;
frac12: string;
frac13: string;
frac14: string;
frac15: string;
frac16: string;
frac18: string;
frac23: string;
frac25: string;
frac34: string;
frac35: string;
frac38: string;
frac45: string;
frac56: string;
frac58: string;
frac78: string;
frasl: string;
frown: string;
fscr: string;
Fscr: string;
gacute: string;
Gamma: string;
gamma: string;
Gammad: string;
gammad: string;
gap: string;
Gbreve: string;
gbreve: string;
Gcedil: string;
Gcirc: string;
gcirc: string;
Gcy: string;
gcy: string;
Gdot: string;
gdot: string;
ge: string;
gE: string;
gEl: string;
gel: string;
geq: string;
geqq: string;
geqslant: string;
gescc: string;
ges: string;
gesdot: string;
gesdoto: string;
gesdotol: string;
gesl: string;
gesles: string;
Gfr: string;
gfr: string;
gg: string;
Gg: string;
ggg: string;
gimel: string;
GJcy: string;
gjcy: string;
gla: string;
gl: string;
glE: string;
glj: string;
gnap: string;
gnapprox: string;
gne: string;
gnE: string;
gneq: string;
gneqq: string;
gnsim: string;
Gopf: string;
gopf: string;
grave: string;
GreaterEqual: string;
GreaterEqualLess: string;
GreaterFullEqual: string;
GreaterGreater: string;
GreaterLess: string;
GreaterSlantEqual: string;
GreaterTilde: string;
Gscr: string;
gscr: string;
gsim: string;
gsime: string;
gsiml: string;
gtcc: string;
gtcir: string;
gt: string;
GT: string;
Gt: string;
gtdot: string;
gtlPar: string;
gtquest: string;
gtrapprox: string;
gtrarr: string;
gtrdot: string;
gtreqless: string;
gtreqqless: string;
gtrless: string;
gtrsim: string;
gvertneqq: string;
gvnE: string;
Hacek: string;
hairsp: string;
half: string;
hamilt: string;
HARDcy: string;
hardcy: string;
harrcir: string;
harr: string;
hArr: string;
harrw: string;
Hat: string;
hbar: string;
Hcirc: string;
hcirc: string;
hearts: string;
heartsuit: string;
hellip: string;
hercon: string;
hfr: string;
Hfr: string;
HilbertSpace: string;
hksearow: string;
hkswarow: string;
hoarr: string;
homtht: string;
hookleftarrow: string;
hookrightarrow: string;
hopf: string;
Hopf: string;
horbar: string;
HorizontalLine: string;
hscr: string;
Hscr: string;
hslash: string;
Hstrok: string;
hstrok: string;
HumpDownHump: string;
HumpEqual: string;
hybull: string;
hyphen: string;
Iacute: string;
iacute: string;
ic: string;
Icirc: string;
icirc: string;
Icy: string;
icy: string;
Idot: string;
IEcy: string;
iecy: string;
iexcl: string;
iff: string;
ifr: string;
Ifr: string;
Igrave: string;
igrave: string;
ii: string;
iiiint: string;
iiint: string;
iinfin: string;
iiota: string;
IJlig: string;
ijlig: string;
Imacr: string;
imacr: string;
image: string;
ImaginaryI: string;
imagline: string;
imagpart: string;
imath: string;
Im: string;
imof: string;
imped: string;
Implies: string;
incare: string;
in: string;
infin: string;
infintie: string;
inodot: string;
intcal: string;
int: string;
Int: string;
integers: string;
Integral: string;
intercal: string;
Intersection: string;
intlarhk: string;
intprod: string;
InvisibleComma: string;
InvisibleTimes: string;
IOcy: string;
iocy: string;
Iogon: string;
iogon: string;
Iopf: string;
iopf: string;
Iota: string;
iota: string;
iprod: string;
iquest: string;
iscr: string;
Iscr: string;
isin: string;
isindot: string;
isinE: string;
isins: string;
isinsv: string;
isinv: string;
it: string;
Itilde: string;
itilde: string;
Iukcy: string;
iukcy: string;
Iuml: string;
iuml: string;
Jcirc: string;
jcirc: string;
Jcy: string;
jcy: string;
Jfr: string;
jfr: string;
jmath: string;
Jopf: string;
jopf: string;
Jscr: string;
jscr: string;
Jsercy: string;
jsercy: string;
Jukcy: string;
jukcy: string;
Kappa: string;
kappa: string;
kappav: string;
Kcedil: string;
kcedil: string;
Kcy: string;
kcy: string;
Kfr: string;
kfr: string;
kgreen: string;
KHcy: string;
khcy: string;
KJcy: string;
kjcy: string;
Kopf: string;
kopf: string;
Kscr: string;
kscr: string;
lAarr: string;
Lacute: string;
lacute: string;
laemptyv: string;
lagran: string;
Lambda: string;
lambda: string;
lang: string;
Lang: string;
langd: string;
langle: string;
lap: string;
Laplacetrf: string;
laquo: string;
larrb: string;
larrbfs: string;
larr: string;
Larr: string;
lArr: string;
larrfs: string;
larrhk: string;
larrlp: string;
larrpl: string;
larrsim: string;
larrtl: string;
latail: string;
lAtail: string;
lat: string;
late: string;
lates: string;
lbarr: string;
lBarr: string;
lbbrk: string;
lbrace: string;
lbrack: string;
lbrke: string;
lbrksld: string;
lbrkslu: string;
Lcaron: string;
lcaron: string;
Lcedil: string;
lcedil: string;
lceil: string;
lcub: string;
Lcy: string;
lcy: string;
ldca: string;
ldquo: string;
ldquor: string;
ldrdhar: string;
ldrushar: string;
ldsh: string;
le: string;
lE: string;
LeftAngleBracket: string;
LeftArrowBar: string;
leftarrow: string;
LeftArrow: string;
Leftarrow: string;
LeftArrowRightArrow: string;
leftarrowtail: string;
LeftCeiling: string;
LeftDoubleBracket: string;
LeftDownTeeVector: string;
LeftDownVectorBar: string;
LeftDownVector: string;
LeftFloor: string;
leftharpoondown: string;
leftharpoonup: string;
leftleftarrows: string;
leftrightarrow: string;
LeftRightArrow: string;
Leftrightarrow: string;
leftrightarrows: string;
leftrightharpoons: string;
leftrightsquigarrow: string;
LeftRightVector: string;
LeftTeeArrow: string;
LeftTee: string;
LeftTeeVector: string;
leftthreetimes: string;
LeftTriangleBar: string;
LeftTriangle: string;
LeftTriangleEqual: string;
LeftUpDownVector: string;
LeftUpTeeVector: string;
LeftUpVectorBar: string;
LeftUpVector: string;
LeftVectorBar: string;
LeftVector: string;
lEg: string;
leg: string;
leq: string;
leqq: string;
leqslant: string;
lescc: string;
les: string;
lesdot: string;
lesdoto: string;
lesdotor: string;
lesg: string;
lesges: string;
lessapprox: string;
lessdot: string;
lesseqgtr: string;
lesseqqgtr: string;
LessEqualGreater: string;
LessFullEqual: string;
LessGreater: string;
lessgtr: string;
LessLess: string;
lesssim: string;
LessSlantEqual: string;
LessTilde: string;
lfisht: string;
lfloor: string;
Lfr: string;
lfr: string;
lg: string;
lgE: string;
lHar: string;
lhard: string;
lharu: string;
lharul: string;
lhblk: string;
LJcy: string;
ljcy: string;
llarr: string;
ll: string;
Ll: string;
llcorner: string;
Lleftarrow: string;
llhard: string;
lltri: string;
Lmidot: string;
lmidot: string;
lmoustache: string;
lmoust: string;
lnap: string;
lnapprox: string;
lne: string;
lnE: string;
lneq: string;
lneqq: string;
lnsim: string;
loang: string;
loarr: string;
lobrk: string;
longleftarrow: string;
LongLeftArrow: string;
Longleftarrow: string;
longleftrightarrow: string;
LongLeftRightArrow: string;
Longleftrightarrow: string;
longmapsto: string;
longrightarrow: string;
LongRightArrow: string;
Longrightarrow: string;
looparrowleft: string;
looparrowright: string;
lopar: string;
Lopf: string;
lopf: string;
loplus: string;
lotimes: string;
lowast: string;
lowbar: string;
LowerLeftArrow: string;
LowerRightArrow: string;
loz: string;
lozenge: string;
lozf: string;
lpar: string;
lparlt: string;
lrarr: string;
lrcorner: string;
lrhar: string;
lrhard: string;
lrm: string;
lrtri: string;
lsaquo: string;
lscr: string;
Lscr: string;
lsh: string;
Lsh: string;
lsim: string;
lsime: string;
lsimg: string;
lsqb: string;
lsquo: string;
lsquor: string;
Lstrok: string;
lstrok: string;
ltcc: string;
ltcir: string;
lt: string;
LT: string;
Lt: string;
ltdot: string;
lthree: string;
ltimes: string;
ltlarr: string;
ltquest: string;
ltri: string;
ltrie: string;
ltrif: string;
ltrPar: string;
lurdshar: string;
luruhar: string;
lvertneqq: string;
lvnE: string;
macr: string;
male: string;
malt: string;
maltese: string;
Map: string;
map: string;
mapsto: string;
mapstodown: string;
mapstoleft: string;
mapstoup: string;
marker: string;
mcomma: string;
Mcy: string;
mcy: string;
mdash: string;
mDDot: string;
measuredangle: string;
MediumSpace: string;
Mellintrf: string;
Mfr: string;
mfr: string;
mho: string;
micro: string;
midast: string;
midcir: string;
mid: string;
middot: string;
minusb: string;
minus: string;
minusd: string;
minusdu: string;
MinusPlus: string;
mlcp: string;
mldr: string;
mnplus: string;
models: string;
Mopf: string;
mopf: string;
mp: string;
mscr: string;
Mscr: string;
mstpos: string;
Mu: string;
mu: string;
multimap: string;
mumap: string;
nabla: string;
Nacute: string;
nacute: string;
nang: string;
nap: string;
napE: string;
napid: string;
napos: string;
napprox: string;
natural: string;
naturals: string;
natur: string;
nbsp: string;
nbump: string;
nbumpe: string;
ncap: string;
Ncaron: string;
ncaron: string;
Ncedil: string;
ncedil: string;
ncong: string;
ncongdot: string;
ncup: string;
Ncy: string;
ncy: string;
ndash: string;
nearhk: string;
nearr: string;
neArr: string;
nearrow: string;
ne: string;
nedot: string;
NegativeMediumSpace: string;
NegativeThickSpace: string;
NegativeThinSpace: string;
NegativeVeryThinSpace: string;
nequiv: string;
nesear: string;
nesim: string;
NestedGreaterGreater: string;
NestedLessLess: string;
NewLine: string;
nexist: string;
nexists: string;
Nfr: string;
nfr: string;
ngE: string;
nge: string;
ngeq: string;
ngeqq: string;
ngeqslant: string;
nges: string;
nGg: string;
ngsim: string;
nGt: string;
ngt: string;
ngtr: string;
nGtv: string;
nharr: string;
nhArr: string;
nhpar: string;
ni: string;
nis: string;
nisd: string;
niv: string;
NJcy: string;
njcy: string;
nlarr: string;
nlArr: string;
nldr: string;
nlE: string;
nle: string;
nleftarrow: string;
nLeftarrow: string;
nleftrightarrow: string;
nLeftrightarrow: string;
nleq: string;
nleqq: string;
nleqslant: string;
nles: string;
nless: string;
nLl: string;
nlsim: string;
nLt: string;
nlt: string;
nltri: string;
nltrie: string;
nLtv: string;
nmid: string;
NoBreak: string;
NonBreakingSpace: string;
nopf: string;
Nopf: string;
Not: string;
not: string;
NotCongruent: string;
NotCupCap: string;
NotDoubleVerticalBar: string;
NotElement: string;
NotEqual: string;
NotEqualTilde: string;
NotExists: string;
NotGreater: string;
NotGreaterEqual: string;
NotGreaterFullEqual: string;
NotGreaterGreater: string;
NotGreaterLess: string;
NotGreaterSlantEqual: string;
NotGreaterTilde: string;
NotHumpDownHump: string;
NotHumpEqual: string;
notin: string;
notindot: string;
notinE: string;
notinva: string;
notinvb: string;
notinvc: string;
NotLeftTriangleBar: string;
NotLeftTriangle: string;
NotLeftTriangleEqual: string;
NotLess: string;
NotLessEqual: string;
NotLessGreater: string;
NotLessLess: string;
NotLessSlantEqual: string;
NotLessTilde: string;
NotNestedGreaterGreater: string;
NotNestedLessLess: string;
notni: string;
notniva: string;
notnivb: string;
notnivc: string;
NotPrecedes: string;
NotPrecedesEqual: string;
NotPrecedesSlantEqual: string;
NotReverseElement: string;
NotRightTriangleBar: string;
NotRightTriangle: string;
NotRightTriangleEqual: string;
NotSquareSubset: string;
NotSquareSubsetEqual: string;
NotSquareSuperset: string;
NotSquareSupersetEqual: string;
NotSubset: string;
NotSubsetEqual: string;
NotSucceeds: string;
NotSucceedsEqual: string;
NotSucceedsSlantEqual: string;
NotSucceedsTilde: string;
NotSuperset: string;
NotSupersetEqual: string;
NotTilde: string;
NotTildeEqual: string;
NotTildeFullEqual: string;
NotTildeTilde: string;
NotVerticalBar: string;
nparallel: string;
npar: string;
nparsl: string;
npart: string;
npolint: string;
npr: string;
nprcue: string;
nprec: string;
npreceq: string;
npre: string;
nrarrc: string;
nrarr: string;
nrArr: string;
nrarrw: string;
nrightarrow: string;
nRightarrow: string;
nrtri: string;
nrtrie: string;
nsc: string;
nsccue: string;
nsce: string;
Nscr: string;
nscr: string;
nshortmid: string;
nshortparallel: string;
nsim: string;
nsime: string;
nsimeq: string;
nsmid: string;
nspar: string;
nsqsube: string;
nsqsupe: string;
nsub: string;
nsubE: string;
nsube: string;
nsubset: string;
nsubseteq: string;
nsubseteqq: string;
nsucc: string;
nsucceq: string;
nsup: string;
nsupE: string;
nsupe: string;
nsupset: string;
nsupseteq: string;
nsupseteqq: string;
ntgl: string;
Ntilde: string;
ntilde: string;
ntlg: string;
ntriangleleft: string;
ntrianglelefteq: string;
ntriangleright: string;
ntrianglerighteq: string;
Nu: string;
nu: string;
num: string;
numero: string;
numsp: string;
nvap: string;
nvdash: string;
nvDash: string;
nVdash: string;
nVDash: string;
nvge: string;
nvgt: string;
nvHarr: string;
nvinfin: string;
nvlArr: string;
nvle: string;
nvlt: string;
nvltrie: string;
nvrArr: string;
nvrtrie: string;
nvsim: string;
nwarhk: string;
nwarr: string;
nwArr: string;
nwarrow: string;
nwnear: string;
Oacute: string;
oacute: string;
oast: string;
Ocirc: string;
ocirc: string;
ocir: string;
Ocy: string;
ocy: string;
odash: string;
Odblac: string;
odblac: string;
odiv: string;
odot: string;
odsold: string;
OElig: string;
oelig: string;
ofcir: string;
Ofr: string;
ofr: string;
ogon: string;
Ograve: string;
ograve: string;
ogt: string;
ohbar: string;
ohm: string;
oint: string;
olarr: string;
olcir: string;
olcross: string;
oline: string;
olt: string;
Omacr: string;
omacr: string;
Omega: string;
omega: string;
Omicron: string;
omicron: string;
omid: string;
ominus: string;
Oopf: string;
oopf: string;
opar: string;
OpenCurlyDoubleQuote: string;
OpenCurlyQuote: string;
operp: string;
oplus: string;
orarr: string;
Or: string;
or: string;
ord: string;
order: string;
orderof: string;
ordf: string;
ordm: string;
origof: string;
oror: string;
orslope: string;
orv: string;
oS: string;
Oscr: string;
oscr: string;
Oslash: string;
oslash: string;
osol: string;
Otilde: string;
otilde: string;
otimesas: string;
Otimes: string;
otimes: string;
Ouml: string;
ouml: string;
ovbar: string;
OverBar: string;
OverBrace: string;
OverBracket: string;
OverParenthesis: string;
para: string;
parallel: string;
par: string;
parsim: string;
parsl: string;
part: string;
PartialD: string;
Pcy: string;
pcy: string;
percnt: string;
period: string;
permil: string;
perp: string;
pertenk: string;
Pfr: string;
pfr: string;
Phi: string;
phi: string;
phiv: string;
phmmat: string;
phone: string;
Pi: string;
pi: string;
pitchfork: string;
piv: string;
planck: string;
planckh: string;
plankv: string;
plusacir: string;
plusb: string;
pluscir: string;
plus: string;
plusdo: string;
plusdu: string;
pluse: string;
PlusMinus: string;
plusmn: string;
plussim: string;
plustwo: string;
pm: string;
Poincareplane: string;
pointint: string;
popf: string;
Popf: string;
pound: string;
prap: string;
Pr: string;
pr: string;
prcue: string;
precapprox: string;
prec: string;
preccurlyeq: string;
Precedes: string;
PrecedesEqual: string;
PrecedesSlantEqual: string;
PrecedesTilde: string;
preceq: string;
precnapprox: string;
precneqq: string;
precnsim: string;
pre: string;
prE: string;
precsim: string;
prime: string;
Prime: string;
primes: string;
prnap: string;
prnE: string;
prnsim: string;
prod: string;
Product: string;
profalar: string;
profline: string;
profsurf: string;
prop: string;
Proportional: string;
Proportion: string;
propto: string;
prsim: string;
prurel: string;
Pscr: string;
pscr: string;
Psi: string;
psi: string;
puncsp: string;
Qfr: string;
qfr: string;
qint: string;
qopf: string;
Qopf: string;
qprime: string;
Qscr: string;
qscr: string;
quaternions: string;
quatint: string;
quest: string;
questeq: string;
quot: string;
QUOT: string;
rAarr: string;
race: string;
Racute: string;
racute: string;
radic: string;
raemptyv: string;
rang: string;
Rang: string;
rangd: string;
range: string;
rangle: string;
raquo: string;
rarrap: string;
rarrb: string;
rarrbfs: string;
rarrc: string;
rarr: string;
Rarr: string;
rArr: string;
rarrfs: string;
rarrhk: string;
rarrlp: string;
rarrpl: string;
rarrsim: string;
Rarrtl: string;
rarrtl: string;
rarrw: string;
ratail: string;
rAtail: string;
ratio: string;
rationals: string;
rbarr: string;
rBarr: string;
RBarr: string;
rbbrk: string;
rbrace: string;
rbrack: string;
rbrke: string;
rbrksld: string;
rbrkslu: string;
Rcaron: string;
rcaron: string;
Rcedil: string;
rcedil: string;
rceil: string;
rcub: string;
Rcy: string;
rcy: string;
rdca: string;
rdldhar: string;
rdquo: string;
rdquor: string;
rdsh: string;
real: string;
realine: string;
realpart: string;
reals: string;
Re: string;
rect: string;
reg: string;
REG: string;
ReverseElement: string;
ReverseEquilibrium: string;
ReverseUpEquilibrium: string;
rfisht: string;
rfloor: string;
rfr: string;
Rfr: string;
rHar: string;
rhard: string;
rharu: string;
rharul: string;
Rho: string;
rho: string;
rhov: string;
RightAngleBracket: string;
RightArrowBar: string;
rightarrow: string;
RightArrow: string;
Rightarrow: string;
RightArrowLeftArrow: string;
rightarrowtail: string;
RightCeiling: string;
RightDoubleBracket: string;
RightDownTeeVector: string;
RightDownVectorBar: string;
RightDownVector: string;
RightFloor: string;
rightharpoondown: string;
rightharpoonup: string;
rightleftarrows: string;
rightleftharpoons: string;
rightrightarrows: string;
rightsquigarrow: string;
RightTeeArrow: string;
RightTee: string;
RightTeeVector: string;
rightthreetimes: string;
RightTriangleBar: string;
RightTriangle: string;
RightTriangleEqual: string;
RightUpDownVector: string;
RightUpTeeVector: string;
RightUpVectorBar: string;
RightUpVector: string;
RightVectorBar: string;
RightVector: string;
ring: string;
risingdotseq: string;
rlarr: string;
rlhar: string;
rlm: string;
rmoustache: string;
rmoust: string;
rnmid: string;
roang: string;
roarr: string;
robrk: string;
ropar: string;
ropf: string;
Ropf: string;
roplus: string;
rotimes: string;
RoundImplies: string;
rpar: string;
rpargt: string;
rppolint: string;
rrarr: string;
Rrightarrow: string;
rsaquo: string;
rscr: string;
Rscr: string;
rsh: string;
Rsh: string;
rsqb: string;
rsquo: string;
rsquor: string;
rthree: string;
rtimes: string;
rtri: string;
rtrie: string;
rtrif: string;
rtriltri: string;
RuleDelayed: string;
ruluhar: string;
rx: string;
Sacute: string;
sacute: string;
sbquo: string;
scap: string;
Scaron: string;
scaron: string;
Sc: string;
sc: string;
sccue: string;
sce: string;
scE: string;
Scedil: string;
scedil: string;
Scirc: string;
scirc: string;
scnap: string;
scnE: string;
scnsim: string;
scpolint: string;
scsim: string;
Scy: string;
scy: string;
sdotb: string;
sdot: string;
sdote: string;
searhk: string;
searr: string;
seArr: string;
searrow: string;
sect: string;
semi: string;
seswar: string;
setminus: string;
setmn: string;
sext: string;
Sfr: string;
sfr: string;
sfrown: string;
sharp: string;
SHCHcy: string;
shchcy: string;
SHcy: string;
shcy: string;
ShortDownArrow: string;
ShortLeftArrow: string;
shortmid: string;
shortparallel: string;
ShortRightArrow: string;
ShortUpArrow: string;
shy: string;
Sigma: string;
sigma: string;
sigmaf: string;
sigmav: string;
sim: string;
simdot: string;
sime: string;
simeq: string;
simg: string;
simgE: string;
siml: string;
simlE: string;
simne: string;
simplus: string;
simrarr: string;
slarr: string;
SmallCircle: string;
smallsetminus: string;
smashp: string;
smeparsl: string;
smid: string;
smile: string;
smt: string;
smte: string;
smtes: string;
SOFTcy: string;
softcy: string;
solbar: string;
solb: string;
sol: string;
Sopf: string;
sopf: string;
spades: string;
spadesuit: string;
spar: string;
sqcap: string;
sqcaps: string;
sqcup: string;
sqcups: string;
Sqrt: string;
sqsub: string;
sqsube: string;
sqsubset: string;
sqsubseteq: string;
sqsup: string;
sqsupe: string;
sqsupset: string;
sqsupseteq: string;
square: string;
Square: string;
SquareIntersection: string;
SquareSubset: string;
SquareSubsetEqual: string;
SquareSuperset: string;
SquareSupersetEqual: string;
SquareUnion: string;
squarf: string;
squ: string;
squf: string;
srarr: string;
Sscr: string;
sscr: string;
ssetmn: string;
ssmile: string;
sstarf: string;
Star: string;
star: string;
starf: string;
straightepsilon: string;
straightphi: string;
strns: string;
sub: string;
Sub: string;
subdot: string;
subE: string;
sube: string;
subedot: string;
submult: string;
subnE: string;
subne: string;
subplus: string;
subrarr: string;
subset: string;
Subset: string;
subseteq: string;
subseteqq: string;
SubsetEqual: string;
subsetneq: string;
subsetneqq: string;
subsim: string;
subsub: string;
subsup: string;
succapprox: string;
succ: string;
succcurlyeq: string;
Succeeds: string;
SucceedsEqual: string;
SucceedsSlantEqual: string;
SucceedsTilde: string;
succeq: string;
succnapprox: string;
succneqq: string;
succnsim: string;
succsim: string;
SuchThat: string;
sum: string;
Sum: string;
sung: string;
sup1: string;
sup2: string;
sup3: string;
sup: string;
Sup: string;
supdot: string;
supdsub: string;
supE: string;
supe: string;
supedot: string;
Superset: string;
SupersetEqual: string;
suphsol: string;
suphsub: string;
suplarr: string;
supmult: string;
supnE: string;
supne: string;
supplus: string;
supset: string;
Supset: string;
supseteq: string;
supseteqq: string;
supsetneq: string;
supsetneqq: string;
supsim: string;
supsub: string;
supsup: string;
swarhk: string;
swarr: string;
swArr: string;
swarrow: string;
swnwar: string;
szlig: string;
Tab: string;
target: string;
Tau: string;
tau: string;
tbrk: string;
Tcaron: string;
tcaron: string;
Tcedil: string;
tcedil: string;
Tcy: string;
tcy: string;
tdot: string;
telrec: string;
Tfr: string;
tfr: string;
there4: string;
therefore: string;
Therefore: string;
Theta: string;
theta: string;
thetasym: string;
thetav: string;
thickapprox: string;
thicksim: string;
ThickSpace: string;
ThinSpace: string;
thinsp: string;
thkap: string;
thksim: string;
THORN: string;
thorn: string;
tilde: string;
Tilde: string;
TildeEqual: string;
TildeFullEqual: string;
TildeTilde: string;
timesbar: string;
timesb: string;
times: string;
timesd: string;
tint: string;
toea: string;
topbot: string;
topcir: string;
top: string;
Topf: string;
topf: string;
topfork: string;
tosa: string;
tprime: string;
trade: string;
TRADE: string;
triangle: string;
triangledown: string;
triangleleft: string;
trianglelefteq: string;
triangleq: string;
triangleright: string;
trianglerighteq: string;
tridot: string;
trie: string;
triminus: string;
TripleDot: string;
triplus: string;
trisb: string;
tritime: string;
trpezium: string;
Tscr: string;
tscr: string;
TScy: string;
tscy: string;
TSHcy: string;
tshcy: string;
Tstrok: string;
tstrok: string;
twixt: string;
twoheadleftarrow: string;
twoheadrightarrow: string;
Uacute: string;
uacute: string;
uarr: string;
Uarr: string;
uArr: string;
Uarrocir: string;
Ubrcy: string;
ubrcy: string;
Ubreve: string;
ubreve: string;
Ucirc: string;
ucirc: string;
Ucy: string;
ucy: string;
udarr: string;
Udblac: string;
udblac: string;
udhar: string;
ufisht: string;
Ufr: string;
ufr: string;
Ugrave: string;
ugrave: string;
uHar: string;
uharl: string;
uharr: string;
uhblk: string;
ulcorn: string;
ulcorner: string;
ulcrop: string;
ultri: string;
Umacr: string;
umacr: string;
uml: string;
UnderBar: string;
UnderBrace: string;
UnderBracket: string;
UnderParenthesis: string;
Union: string;
UnionPlus: string;
Uogon: string;
uogon: string;
Uopf: string;
uopf: string;
UpArrowBar: string;
uparrow: string;
UpArrow: string;
Uparrow: string;
UpArrowDownArrow: string;
updownarrow: string;
UpDownArrow: string;
Updownarrow: string;
UpEquilibrium: string;
upharpoonleft: string;
upharpoonright: string;
uplus: string;
UpperLeftArrow: string;
UpperRightArrow: string;
upsi: string;
Upsi: string;
upsih: string;
Upsilon: string;
upsilon: string;
UpTeeArrow: string;
UpTee: string;
upuparrows: string;
urcorn: string;
urcorner: string;
urcrop: string;
Uring: string;
uring: string;
urtri: string;
Uscr: string;
uscr: string;
utdot: string;
Utilde: string;
utilde: string;
utri: string;
utrif: string;
uuarr: string;
Uuml: string;
uuml: string;
uwangle: string;
vangrt: string;
varepsilon: string;
varkappa: string;
varnothing: string;
varphi: string;
varpi: string;
varpropto: string;
varr: string;
vArr: string;
varrho: string;
varsigma: string;
varsubsetneq: string;
varsubsetneqq: string;
varsupsetneq: string;
varsupsetneqq: string;
vartheta: string;
vartriangleleft: string;
vartriangleright: string;
vBar: string;
Vbar: string;
vBarv: string;
Vcy: string;
vcy: string;
vdash: string;
vDash: string;
Vdash: string;
VDash: string;
Vdashl: string;
veebar: string;
vee: string;
Vee: string;
veeeq: string;
vellip: string;
verbar: string;
Verbar: string;
vert: string;
Vert: string;
VerticalBar: string;
VerticalLine: string;
VerticalSeparator: string;
VerticalTilde: string;
VeryThinSpace: string;
Vfr: string;
vfr: string;
vltri: string;
vnsub: string;
vnsup: string;
Vopf: string;
vopf: string;
vprop: string;
vrtri: string;
Vscr: string;
vscr: string;
vsubnE: string;
vsubne: string;
vsupnE: string;
vsupne: string;
Vvdash: string;
vzigzag: string;
Wcirc: string;
wcirc: string;
wedbar: string;
wedge: string;
Wedge: string;
wedgeq: string;
weierp: string;
Wfr: string;
wfr: string;
Wopf: string;
wopf: string;
wp: string;
wr: string;
wreath: string;
Wscr: string;
wscr: string;
xcap: string;
xcirc: string;
xcup: string;
xdtri: string;
Xfr: string;
xfr: string;
xharr: string;
xhArr: string;
Xi: string;
xi: string;
xlarr: string;
xlArr: string;
xmap: string;
xnis: string;
xodot: string;
Xopf: string;
xopf: string;
xoplus: string;
xotime: string;
xrarr: string;
xrArr: string;
Xscr: string;
xscr: string;
xsqcup: string;
xuplus: string;
xutri: string;
xvee: string;
xwedge: string;
Yacute: string;
yacute: string;
YAcy: string;
yacy: string;
Ycirc: string;
ycirc: string;
Ycy: string;
ycy: string;
yen: string;
Yfr: string;
yfr: string;
YIcy: string;
yicy: string;
Yopf: string;
yopf: string;
Yscr: string;
yscr: string;
YUcy: string;
yucy: string;
yuml: string;
Yuml: string;
Zacute: string;
zacute: string;
Zcaron: string;
zcaron: string;
Zcy: string;
zcy: string;
Zdot: string;
zdot: string;
zeetrf: string;
ZeroWidthSpace: string;
Zeta: string;
zeta: string;
zfr: string;
Zfr: string;
ZHcy: string;
zhcy: string;
zigrarr: string;
zopf: string;
Zopf: string;
Zscr: string;
zscr: string;
zwj: string;
zwnj: string;


    function tokenize

    tokenize: (input: string, options?: TokenizerOptions) => Token[];


      class EntityParser

      class EntityParser {}


        constructor(named: NamedEntityMap);

          method parse

          parse: (entity: string) => string | undefined;

            class EventedTokenizer

            class EventedTokenizer {}


              delegate: TokenizerDelegate,
              entityParser: EntityParser,
              mode?: 'codemod' | 'precompile'

                property column

                column: number;

                  property line

                  line: number;

                    property state

                    state: TokenizerState;

                      property states

                      states: {
                      beforeData?: (this: EventedTokenizer) => void;
                      data?: (this: EventedTokenizer) => void;
                      rcdata?: (this: EventedTokenizer) => void;
                      rawtext?: (this: EventedTokenizer) => void;
                      scriptData?: (this: EventedTokenizer) => void;
                      plaintext?: (this: EventedTokenizer) => void;
                      tagOpen?: (this: EventedTokenizer) => void;
                      endTagOpen?: (this: EventedTokenizer) => void;
                      tagName?: (this: EventedTokenizer) => void;
                      endTagName?: (this: EventedTokenizer) => void;
                      rcdataLessThanSign?: (this: EventedTokenizer) => void;
                      rcdataEndTagOpen?: (this: EventedTokenizer) => void;
                      rcdataEndTagName?: (this: EventedTokenizer) => void;
                      rawtextLessThanSign?: (this: EventedTokenizer) => void;
                      rawtextEndTagOpen?: (this: EventedTokenizer) => void;
                      rawtextEndTagName?: (this: EventedTokenizer) => void;
                      scriptDataLessThanSign?: (this: EventedTokenizer) => void;
                      scriptDataEndTagOpen?: (this: EventedTokenizer) => void;
                      scriptDataEndTagName?: (this: EventedTokenizer) => void;
                      scriptDataEscapeStart?: (this: EventedTokenizer) => void;
                      scriptDataEscapseStartDash?: (this: EventedTokenizer) => void;
                      scriptDataEscaped?: (this: EventedTokenizer) => void;
                      scriptDataEscapedDash?: (this: EventedTokenizer) => void;
                      scriptDataEscapedDashDash?: (this: EventedTokenizer) => void;
                      scriptDataEscapedLessThanSign?: (this: EventedTokenizer) => void;
                      scriptDataEscapedEndTagOpen?: (this: EventedTokenizer) => void;
                      scriptDataEscapedEndTagName?: (this: EventedTokenizer) => void;
                      scriptDataDoubleEscapeStart?: (this: EventedTokenizer) => void;
                      scriptDataDoubleEscaped?: (this: EventedTokenizer) => void;
                      scriptDataDoubleEscapedDash?: (this: EventedTokenizer) => void;
                      scriptDataDoubleEscapedDashDash?: (this: EventedTokenizer) => void;
                      scriptDataDoubleEscapedLessThanSign?: (this: EventedTokenizer) => void;
                      scriptDataDoubleEscapeEnd?: (this: EventedTokenizer) => void;
                      beforeAttributeName?: (this: EventedTokenizer) => void;
                      attributeName?: (this: EventedTokenizer) => void;
                      afterAttributeName?: (this: EventedTokenizer) => void;
                      beforeAttributeValue?: (this: EventedTokenizer) => void;
                      attributeValueDoubleQuoted?: (this: EventedTokenizer) => void;
                      attributeValueSingleQuoted?: (this: EventedTokenizer) => void;
                      attributeValueUnquoted?: (this: EventedTokenizer) => void;
                      afterAttributeValueQuoted?: (this: EventedTokenizer) => void;
                      selfClosingStartTag?: (this: EventedTokenizer) => void;
                      bogusComment?: (this: EventedTokenizer) => void;
                      markupDeclarationOpen?: (this: EventedTokenizer) => void;
                      commentStart?: (this: EventedTokenizer) => void;
                      commentStartDash?: (this: EventedTokenizer) => void;
                      comment?: (this: EventedTokenizer) => void;
                      commentLessThanSign?: (this: EventedTokenizer) => void;
                      commentLessThanSignBang?: (this: EventedTokenizer) => void;
                      commentLessThanSignBangDash?: (this: EventedTokenizer) => void;
                      commentLessThanSignBangDashDash?: (this: EventedTokenizer) => void;
                      commentEndDash?: (this: EventedTokenizer) => void;
                      commentEnd?: (this: EventedTokenizer) => void;
                      commentEndBang?: (this: EventedTokenizer) => void;
                      doctype?: (this: EventedTokenizer) => void;
                      beforeDoctypeName?: (this: EventedTokenizer) => void;
                      doctypeName?: (this: EventedTokenizer) => void;
                      afterDoctypeName?: (this: EventedTokenizer) => void;
                      afterDoctypePublicKeyword?: (this: EventedTokenizer) => void;
                      beforeDoctypePublicIdentifier?: (this: EventedTokenizer) => void;
                      doctypePublicIdentifierDoubleQuoted?: (this: EventedTokenizer) => void;
                      doctypePublicIdentifierSingleQuoted?: (this: EventedTokenizer) => void;
                      afterDoctypePublicIdentifier?: (this: EventedTokenizer) => void;
                      betweenDoctypePublicAndSystemIdentifiers?: (this: EventedTokenizer) => void;
                      afterDoctypeSystemKeyword?: (this: EventedTokenizer) => void;
                      beforeDoctypeSystemIdentifier?: (this: EventedTokenizer) => void;
                      doctypeSystemIdentifierDoubleQuoted?: (this: EventedTokenizer) => void;
                      doctypeSystemIdentifierSingleQuoted?: (this: EventedTokenizer) => void;
                      afterDoctypeSystemIdentifier?: (this: EventedTokenizer) => void;
                      bogusDoctype?: (this: EventedTokenizer) => void;
                      cdataSection?: (this: EventedTokenizer) => void;
                      cdataSectionBracket?: (this: EventedTokenizer) => void;
                      cdataSectionEnd?: (this: EventedTokenizer) => void;
                      characterReference?: (this: EventedTokenizer) => void;
                      numericCharacterReference?: (this: EventedTokenizer) => void;
                      hexadecimalCharacterReferenceStart?: (this: EventedTokenizer) => void;
                      decimalCharacterReferenceStart?: (this: EventedTokenizer) => void;
                      hexadecimalCharacterReference?: (this: EventedTokenizer) => void;
                      decimalCharacterReference?: (this: EventedTokenizer) => void;
                      numericCharacterReferenceEnd?: (this: EventedTokenizer) => void;
                      characterReferenceEnd?: (this: EventedTokenizer) => void;

                        method consume

                        consume: () => string;

                          method consumeCharRef

                          consumeCharRef: () => string | undefined;

                            method flushData

                            flushData: () => void;

                              method markTagStart

                              markTagStart: () => void;

                                method peek

                                peek: () => string;

                                  method reset

                                  reset: () => void;

                                    method tokenize

                                    tokenize: (input: string) => void;

                                      method tokenizeEOF

                                      tokenizeEOF: () => void;

                                        method tokenizePart

                                        tokenizePart: (input: string) => void;

                                          method transitionTo

                                          transitionTo: (state: TokenizerState) => void;

                                            class Tokenizer

                                            class Tokenizer implements TokenizerDelegate {}


                                              constructor(entityParser: EntityParser, options?: TokenizerOptions);

                                                method addLocInfo

                                                addLocInfo: () => void;

                                                  method appendToAttributeName

                                                  appendToAttributeName: (char: string) => void;

                                                    method appendToAttributeValue

                                                    appendToAttributeValue: (char: string) => void;

                                                      method appendToCommentData

                                                      appendToCommentData: (char: string) => void;

                                                        method appendToData

                                                        appendToData: (char: string) => void;

                                                          method appendToDoctypeName

                                                          appendToDoctypeName: (char: string) => void;

                                                            method appendToDoctypePublicIdentifier

                                                            appendToDoctypePublicIdentifier: (char: string) => void;

                                                              method appendToDoctypeSystemIdentifier

                                                              appendToDoctypeSystemIdentifier: (char: string) => void;

                                                                method appendToTagName

                                                                appendToTagName: (char: string) => void;

                                                                  method beginAttribute

                                                                  beginAttribute: () => void;

                                                                    method beginAttributeValue

                                                                    beginAttributeValue: (isQuoted: boolean) => void;

                                                                      method beginComment

                                                                      beginComment: () => void;

                                                                        method beginData

                                                                        beginData: () => void;

                                                                          method beginDoctype

                                                                          beginDoctype: () => void;

                                                                            method beginEndTag

                                                                            beginEndTag: () => void;

                                                                              method beginStartTag

                                                                              beginStartTag: () => void;

                                                                                method current

                                                                                current: {
                                                                                <T extends TokenType, U extends TokenType>(type1: T, type2: U):
                                                                                | TokenMap[T]
                                                                                | TokenMap[U];
                                                                                <T extends TokenType>(type: T): TokenMap[T];
                                                                                (): Token;

                                                                                  method currentAttribute

                                                                                  currentAttribute: () => [string, string, boolean] | undefined;

                                                                                    method endDoctype

                                                                                    endDoctype: () => void;

                                                                                      method finishAttributeValue

                                                                                      finishAttributeValue: () => void;

                                                                                        method finishComment

                                                                                        finishComment: () => void;

                                                                                          method finishData

                                                                                          finishData: () => void;

                                                                                            method finishTag

                                                                                            finishTag: () => void;

                                                                                              method markTagAsSelfClosing

                                                                                              markTagAsSelfClosing: () => void;

                                                                                                method push

                                                                                                push: (token: Token) => void;

                                                                                                  method reportSyntaxError

                                                                                                  reportSyntaxError: (message: string) => void;

                                                                                                    method reset

                                                                                                    reset: () => void;

                                                                                                      method tagOpen

                                                                                                      tagOpen: () => void;

                                                                                                        method tokenize

                                                                                                        tokenize: (input: string) => Token[];

                                                                                                          method tokenizeEOF

                                                                                                          tokenizeEOF: () => Token;

                                                                                                            method tokenizePart

                                                                                                            tokenizePart: (input: string) => Token[];


                                                                                                              interface Chars

                                                                                                              interface Chars extends TokenBase<TokenType.Chars> {}

                                                                                                                property chars

                                                                                                                chars: string;

                                                                                                                  interface Comment

                                                                                                                  interface Comment extends TokenBase<TokenType.Comment> {}

                                                                                                                    property chars

                                                                                                                    chars: string;

                                                                                                                      interface Doctype

                                                                                                                      interface Doctype extends TokenBase<TokenType.Doctype> {}

                                                                                                                        property name

                                                                                                                        name: string;

                                                                                                                          property publicIdentifier

                                                                                                                          publicIdentifier?: string;

                                                                                                                            property systemIdentifier

                                                                                                                            systemIdentifier?: string;

                                                                                                                              interface EndTag

                                                                                                                              interface EndTag extends TokenBase<TokenType.EndTag> {}

                                                                                                                                property tagName

                                                                                                                                tagName: string;

                                                                                                                                  interface Location

                                                                                                                                  interface Location {}

                                                                                                                                    property end

                                                                                                                                    end: {
                                                                                                                                    line: number;
                                                                                                                                    column: number;

                                                                                                                                      property start

                                                                                                                                      start: {
                                                                                                                                      line: number;
                                                                                                                                      column: number;

                                                                                                                                        interface NamedEntityMap

                                                                                                                                        interface NamedEntityMap {}

                                                                                                                                          index signature

                                                                                                                                          [name: string]: string;

                                                                                                                                            interface StartTag

                                                                                                                                            interface StartTag extends TokenBase<TokenType.StartTag> {}

                                                                                                                                              property attributes

                                                                                                                                              attributes: Attribute[];

                                                                                                                                                property selfClosing

                                                                                                                                                selfClosing: boolean;

                                                                                                                                                  property tagName

                                                                                                                                                  tagName: string;

                                                                                                                                                    interface TokenBase

                                                                                                                                                    interface TokenBase<T extends TokenType> {}

                                                                                                                                                      property loc

                                                                                                                                                      loc?: Location;

                                                                                                                                                        property syntaxError

                                                                                                                                                        syntaxError?: string;

                                                                                                                                                          property type

                                                                                                                                                          type: T;

                                                                                                                                                            interface TokenizerDelegate

                                                                                                                                                            interface TokenizerDelegate {}

                                                                                                                                                              method appendToAttributeName

                                                                                                                                                              appendToAttributeName: (char: string) => void;

                                                                                                                                                                method appendToAttributeValue

                                                                                                                                                                appendToAttributeValue: (char: string) => void;

                                                                                                                                                                  method appendToCommentData

                                                                                                                                                                  appendToCommentData: (char: string) => void;

                                                                                                                                                                    method appendToData

                                                                                                                                                                    appendToData: (char: string) => void;

                                                                                                                                                                      method appendToDoctypeName

                                                                                                                                                                      appendToDoctypeName: (char: string) => void;

                                                                                                                                                                        method appendToDoctypePublicIdentifier

                                                                                                                                                                        appendToDoctypePublicIdentifier: (char: string) => void;

                                                                                                                                                                          method appendToDoctypeSystemIdentifier

                                                                                                                                                                          appendToDoctypeSystemIdentifier: (char: string) => void;

                                                                                                                                                                            method appendToTagName

                                                                                                                                                                            appendToTagName: (char: string) => void;

                                                                                                                                                                              method beginAttribute

                                                                                                                                                                              beginAttribute: () => void;

                                                                                                                                                                                method beginAttributeValue

                                                                                                                                                                                beginAttributeValue: (quoted: boolean) => void;

                                                                                                                                                                                  method beginComment

                                                                                                                                                                                  beginComment: () => void;

                                                                                                                                                                                    method beginData

                                                                                                                                                                                    beginData: () => void;

                                                                                                                                                                                      method beginDoctype

                                                                                                                                                                                      beginDoctype: () => void;

                                                                                                                                                                                        method beginEndTag

                                                                                                                                                                                        beginEndTag: () => void;

                                                                                                                                                                                          method beginStartTag

                                                                                                                                                                                          beginStartTag: () => void;

                                                                                                                                                                                            method endDoctype

                                                                                                                                                                                            endDoctype: () => void;

                                                                                                                                                                                              method finishAttributeValue

                                                                                                                                                                                              finishAttributeValue: () => void;

                                                                                                                                                                                                method finishComment

                                                                                                                                                                                                finishComment: () => void;

                                                                                                                                                                                                  method finishData

                                                                                                                                                                                                  finishData: () => void;

                                                                                                                                                                                                    method finishTag

                                                                                                                                                                                                    finishTag: () => void;

                                                                                                                                                                                                      method markTagAsSelfClosing

                                                                                                                                                                                                      markTagAsSelfClosing: () => void;

                                                                                                                                                                                                        method reportSyntaxError

                                                                                                                                                                                                        reportSyntaxError: (error: string) => void;

                                                                                                                                                                                                          method reset

                                                                                                                                                                                                          reset: () => void;

                                                                                                                                                                                                            method tagOpen

                                                                                                                                                                                                            tagOpen: () => void;

                                                                                                                                                                                                              interface TokenizerOptions

                                                                                                                                                                                                              interface TokenizerOptions {}

                                                                                                                                                                                                                property loc

                                                                                                                                                                                                                loc?: boolean;

                                                                                                                                                                                                                  property mode

                                                                                                                                                                                                                  mode?: 'precompile' | 'codemod';

                                                                                                                                                                                                                    interface TokenMap

                                                                                                                                                                                                                    interface TokenMap {}

                                                                                                                                                                                                                      property Chars

                                                                                                                                                                                                                      Chars: Chars;

                                                                                                                                                                                                                        property Comment

                                                                                                                                                                                                                        Comment: Comment;

                                                                                                                                                                                                                          property Doctype

                                                                                                                                                                                                                          Doctype: Doctype;

                                                                                                                                                                                                                            property EndTag

                                                                                                                                                                                                                            EndTag: EndTag;

                                                                                                                                                                                                                              property StartTag

                                                                                                                                                                                                                              StartTag: StartTag;


                                                                                                                                                                                                                                enum TokenizerState

                                                                                                                                                                                                                                const enum TokenizerState {
                                                                                                                                                                                                                                beforeData = 'beforeData',
                                                                                                                                                                                                                                data = 'data',
                                                                                                                                                                                                                                rcdata = 'rcdata',
                                                                                                                                                                                                                                rawtext = 'rawtext',
                                                                                                                                                                                                                                scriptData = 'scriptData',
                                                                                                                                                                                                                                plaintext = 'plaintext',
                                                                                                                                                                                                                                tagOpen = 'tagOpen',
                                                                                                                                                                                                                                endTagOpen = 'endTagOpen',
                                                                                                                                                                                                                                tagName = 'tagName',
                                                                                                                                                                                                                                endTagName = 'endTagName',
                                                                                                                                                                                                                                rcdataLessThanSign = 'rcdataLessThanSign',
                                                                                                                                                                                                                                rcdataEndTagOpen = 'rcdataEndTagOpen',
                                                                                                                                                                                                                                rcdataEndTagName = 'rcdataEndTagName',
                                                                                                                                                                                                                                rawtextLessThanSign = 'rawtextLessThanSign',
                                                                                                                                                                                                                                rawtextEndTagOpen = 'rawtextEndTagOpen',
                                                                                                                                                                                                                                rawtextEndTagName = 'rawtextEndTagName',
                                                                                                                                                                                                                                scriptDataLessThanSign = 'scriptDataLessThanSign',
                                                                                                                                                                                                                                scriptDataEndTagOpen = 'scriptDataEndTagOpen',
                                                                                                                                                                                                                                scriptDataEndTagName = 'scriptDataEndTagName',
                                                                                                                                                                                                                                scriptDataEscapeStart = 'scriptDataEscapeStart',
                                                                                                                                                                                                                                scriptDataEscapseStartDash = 'scriptDataEscapseStartDash',
                                                                                                                                                                                                                                scriptDataEscaped = 'scriptDataEscaped',
                                                                                                                                                                                                                                scriptDataEscapedDash = 'scriptDataEscapedDash',
                                                                                                                                                                                                                                scriptDataEscapedDashDash = 'scriptDataEscapedDashDash',
                                                                                                                                                                                                                                scriptDataEscapedLessThanSign = 'scriptDataEscapedLessThanSign',
                                                                                                                                                                                                                                scriptDataEscapedEndTagOpen = 'scriptDataEscapedEndTagOpen',
                                                                                                                                                                                                                                scriptDataEscapedEndTagName = 'scriptDataEscapedEndTagName',
                                                                                                                                                                                                                                scriptDataDoubleEscapeStart = 'scriptDataDoubleEscapeStart',
                                                                                                                                                                                                                                scriptDataDoubleEscaped = 'scriptDataDoubleEscaped',
                                                                                                                                                                                                                                scriptDataDoubleEscapedDash = 'scriptDataDoubleEscapedDash',
                                                                                                                                                                                                                                scriptDataDoubleEscapedDashDash = 'scriptDataDoubleEscapedDashDash',
                                                                                                                                                                                                                                scriptDataDoubleEscapedLessThanSign = 'scriptDataDoubleEscapedLessThanSign',
                                                                                                                                                                                                                                scriptDataDoubleEscapeEnd = 'scriptDataDoubleEscapeEnd',
                                                                                                                                                                                                                                beforeAttributeName = 'beforeAttributeName',
                                                                                                                                                                                                                                attributeName = 'attributeName',
                                                                                                                                                                                                                                afterAttributeName = 'afterAttributeName',
                                                                                                                                                                                                                                beforeAttributeValue = 'beforeAttributeValue',
                                                                                                                                                                                                                                attributeValueDoubleQuoted = 'attributeValueDoubleQuoted',
                                                                                                                                                                                                                                attributeValueSingleQuoted = 'attributeValueSingleQuoted',
                                                                                                                                                                                                                                attributeValueUnquoted = 'attributeValueUnquoted',
                                                                                                                                                                                                                                afterAttributeValueQuoted = 'afterAttributeValueQuoted',
                                                                                                                                                                                                                                selfClosingStartTag = 'selfClosingStartTag',
                                                                                                                                                                                                                                bogusComment = 'bogusComment',
                                                                                                                                                                                                                                markupDeclarationOpen = 'markupDeclarationOpen',
                                                                                                                                                                                                                                commentStart = 'commentStart',
                                                                                                                                                                                                                                commentStartDash = 'commentStartDash',
                                                                                                                                                                                                                                comment = 'comment',
                                                                                                                                                                                                                                commentLessThanSign = 'commentLessThanSign',
                                                                                                                                                                                                                                commentLessThanSignBang = 'commentLessThanSignBang',
                                                                                                                                                                                                                                commentLessThanSignBangDash = 'commentLessThanSignBangDash',
                                                                                                                                                                                                                                commentLessThanSignBangDashDash = 'commentLessThanSignBangDashDash',
                                                                                                                                                                                                                                commentEndDash = 'commentEndDash',
                                                                                                                                                                                                                                commentEnd = 'commentEnd',
                                                                                                                                                                                                                                commentEndBang = 'commentEndBang',
                                                                                                                                                                                                                                doctype = 'doctype',
                                                                                                                                                                                                                                beforeDoctypeName = 'beforeDoctypeName',
                                                                                                                                                                                                                                doctypeName = 'doctypeName',
                                                                                                                                                                                                                                afterDoctypeName = 'afterDoctypeName',
                                                                                                                                                                                                                                afterDoctypePublicKeyword = 'afterDoctypePublicKeyword',
                                                                                                                                                                                                                                beforeDoctypePublicIdentifier = 'beforeDoctypePublicIdentifier',
                                                                                                                                                                                                                                doctypePublicIdentifierDoubleQuoted = 'doctypePublicIdentifierDoubleQuoted',
                                                                                                                                                                                                                                doctypePublicIdentifierSingleQuoted = 'doctypePublicIdentifierSingleQuoted',
                                                                                                                                                                                                                                afterDoctypePublicIdentifier = 'afterDoctypePublicIdentifier',
                                                                                                                                                                                                                                betweenDoctypePublicAndSystemIdentifiers = 'betweenDoctypePublicAndSystemIdentifiers',
                                                                                                                                                                                                                                afterDoctypeSystemKeyword = 'afterDoctypeSystemKeyword',
                                                                                                                                                                                                                                beforeDoctypeSystemIdentifier = 'beforeDoctypeSystemIdentifier',
                                                                                                                                                                                                                                doctypeSystemIdentifierDoubleQuoted = 'doctypeSystemIdentifierDoubleQuoted',
                                                                                                                                                                                                                                doctypeSystemIdentifierSingleQuoted = 'doctypeSystemIdentifierSingleQuoted',
                                                                                                                                                                                                                                afterDoctypeSystemIdentifier = 'afterDoctypeSystemIdentifier',
                                                                                                                                                                                                                                bogusDoctype = 'bogusDoctype',
                                                                                                                                                                                                                                cdataSection = 'cdataSection',
                                                                                                                                                                                                                                cdataSectionBracket = 'cdataSectionBracket',
                                                                                                                                                                                                                                cdataSectionEnd = 'cdataSectionEnd',
                                                                                                                                                                                                                                characterReference = 'characterReference',
                                                                                                                                                                                                                                numericCharacterReference = 'numericCharacterReference',
                                                                                                                                                                                                                                hexadecimalCharacterReferenceStart = 'hexadecimalCharacterReferenceStart',
                                                                                                                                                                                                                                decimalCharacterReferenceStart = 'decimalCharacterReferenceStart',
                                                                                                                                                                                                                                hexadecimalCharacterReference = 'hexadecimalCharacterReference',
                                                                                                                                                                                                                                decimalCharacterReference = 'decimalCharacterReference',
                                                                                                                                                                                                                                numericCharacterReferenceEnd = 'numericCharacterReferenceEnd',
                                                                                                                                                                                                                                characterReferenceEnd = 'characterReferenceEnd',
                                                                                                                                                                                                                                • generated from do not edit

                                                                                                                                                                                                                                member afterAttributeName

                                                                                                                                                                                                                                afterAttributeName = 'afterAttributeName'

                                                                                                                                                                                                                                  member afterAttributeValueQuoted

                                                                                                                                                                                                                                  afterAttributeValueQuoted = 'afterAttributeValueQuoted'

                                                                                                                                                                                                                                    member afterDoctypeName

                                                                                                                                                                                                                                    afterDoctypeName = 'afterDoctypeName'

                                                                                                                                                                                                                                      member afterDoctypePublicIdentifier

                                                                                                                                                                                                                                      afterDoctypePublicIdentifier = 'afterDoctypePublicIdentifier'

                                                                                                                                                                                                                                        member afterDoctypePublicKeyword

                                                                                                                                                                                                                                        afterDoctypePublicKeyword = 'afterDoctypePublicKeyword'

                                                                                                                                                                                                                                          member afterDoctypeSystemIdentifier

                                                                                                                                                                                                                                          afterDoctypeSystemIdentifier = 'afterDoctypeSystemIdentifier'

                                                                                                                                                                                                                                            member afterDoctypeSystemKeyword

                                                                                                                                                                                                                                            afterDoctypeSystemKeyword = 'afterDoctypeSystemKeyword'

                                                                                                                                                                                                                                              member attributeName

                                                                                                                                                                                                                                              attributeName = 'attributeName'

                                                                                                                                                                                                                                                member attributeValueDoubleQuoted

                                                                                                                                                                                                                                                attributeValueDoubleQuoted = 'attributeValueDoubleQuoted'

                                                                                                                                                                                                                                                  member attributeValueSingleQuoted

                                                                                                                                                                                                                                                  attributeValueSingleQuoted = 'attributeValueSingleQuoted'

                                                                                                                                                                                                                                                    member attributeValueUnquoted

                                                                                                                                                                                                                                                    attributeValueUnquoted = 'attributeValueUnquoted'

                                                                                                                                                                                                                                                      member beforeAttributeName

                                                                                                                                                                                                                                                      beforeAttributeName = 'beforeAttributeName'

                                                                                                                                                                                                                                                        member beforeAttributeValue

                                                                                                                                                                                                                                                        beforeAttributeValue = 'beforeAttributeValue'

                                                                                                                                                                                                                                                          member beforeData

                                                                                                                                                                                                                                                          beforeData = 'beforeData'

                                                                                                                                                                                                                                                            member beforeDoctypeName

                                                                                                                                                                                                                                                            beforeDoctypeName = 'beforeDoctypeName'

                                                                                                                                                                                                                                                              member beforeDoctypePublicIdentifier

                                                                                                                                                                                                                                                              beforeDoctypePublicIdentifier = 'beforeDoctypePublicIdentifier'

                                                                                                                                                                                                                                                                member beforeDoctypeSystemIdentifier

                                                                                                                                                                                                                                                                beforeDoctypeSystemIdentifier = 'beforeDoctypeSystemIdentifier'

                                                                                                                                                                                                                                                                  member betweenDoctypePublicAndSystemIdentifiers

                                                                                                                                                                                                                                                                  betweenDoctypePublicAndSystemIdentifiers = 'betweenDoctypePublicAndSystemIdentifiers'

                                                                                                                                                                                                                                                                    member bogusComment

                                                                                                                                                                                                                                                                    bogusComment = 'bogusComment'

                                                                                                                                                                                                                                                                      member bogusDoctype

                                                                                                                                                                                                                                                                      bogusDoctype = 'bogusDoctype'

                                                                                                                                                                                                                                                                        member cdataSection

                                                                                                                                                                                                                                                                        cdataSection = 'cdataSection'

                                                                                                                                                                                                                                                                          member cdataSectionBracket

                                                                                                                                                                                                                                                                          cdataSectionBracket = 'cdataSectionBracket'

                                                                                                                                                                                                                                                                            member cdataSectionEnd

                                                                                                                                                                                                                                                                            cdataSectionEnd = 'cdataSectionEnd'

                                                                                                                                                                                                                                                                              member characterReference

                                                                                                                                                                                                                                                                              characterReference = 'characterReference'

                                                                                                                                                                                                                                                                                member characterReferenceEnd

                                                                                                                                                                                                                                                                                characterReferenceEnd = 'characterReferenceEnd'

                                                                                                                                                                                                                                                                                  member comment

                                                                                                                                                                                                                                                                                  comment = 'comment'

                                                                                                                                                                                                                                                                                    member commentEnd

                                                                                                                                                                                                                                                                                    commentEnd = 'commentEnd'

                                                                                                                                                                                                                                                                                      member commentEndBang

                                                                                                                                                                                                                                                                                      commentEndBang = 'commentEndBang'

                                                                                                                                                                                                                                                                                        member commentEndDash

                                                                                                                                                                                                                                                                                        commentEndDash = 'commentEndDash'

                                                                                                                                                                                                                                                                                          member commentLessThanSign

                                                                                                                                                                                                                                                                                          commentLessThanSign = 'commentLessThanSign'

                                                                                                                                                                                                                                                                                            member commentLessThanSignBang

                                                                                                                                                                                                                                                                                            commentLessThanSignBang = 'commentLessThanSignBang'

                                                                                                                                                                                                                                                                                              member commentLessThanSignBangDash

                                                                                                                                                                                                                                                                                              commentLessThanSignBangDash = 'commentLessThanSignBangDash'

                                                                                                                                                                                                                                                                                                member commentLessThanSignBangDashDash

                                                                                                                                                                                                                                                                                                commentLessThanSignBangDashDash = 'commentLessThanSignBangDashDash'

                                                                                                                                                                                                                                                                                                  member commentStart

                                                                                                                                                                                                                                                                                                  commentStart = 'commentStart'

                                                                                                                                                                                                                                                                                                    member commentStartDash

                                                                                                                                                                                                                                                                                                    commentStartDash = 'commentStartDash'

                                                                                                                                                                                                                                                                                                      member data

                                                                                                                                                                                                                                                                                                      data = 'data'

                                                                                                                                                                                                                                                                                                        member decimalCharacterReference

                                                                                                                                                                                                                                                                                                        decimalCharacterReference = 'decimalCharacterReference'

                                                                                                                                                                                                                                                                                                          member decimalCharacterReferenceStart

                                                                                                                                                                                                                                                                                                          decimalCharacterReferenceStart = 'decimalCharacterReferenceStart'

                                                                                                                                                                                                                                                                                                            member doctype

                                                                                                                                                                                                                                                                                                            doctype = 'doctype'

                                                                                                                                                                                                                                                                                                              member doctypeName

                                                                                                                                                                                                                                                                                                              doctypeName = 'doctypeName'

                                                                                                                                                                                                                                                                                                                member doctypePublicIdentifierDoubleQuoted

                                                                                                                                                                                                                                                                                                                doctypePublicIdentifierDoubleQuoted = 'doctypePublicIdentifierDoubleQuoted'

                                                                                                                                                                                                                                                                                                                  member doctypePublicIdentifierSingleQuoted

                                                                                                                                                                                                                                                                                                                  doctypePublicIdentifierSingleQuoted = 'doctypePublicIdentifierSingleQuoted'

                                                                                                                                                                                                                                                                                                                    member doctypeSystemIdentifierDoubleQuoted

                                                                                                                                                                                                                                                                                                                    doctypeSystemIdentifierDoubleQuoted = 'doctypeSystemIdentifierDoubleQuoted'

                                                                                                                                                                                                                                                                                                                      member doctypeSystemIdentifierSingleQuoted

                                                                                                                                                                                                                                                                                                                      doctypeSystemIdentifierSingleQuoted = 'doctypeSystemIdentifierSingleQuoted'

                                                                                                                                                                                                                                                                                                                        member endTagName

                                                                                                                                                                                                                                                                                                                        endTagName = 'endTagName'

                                                                                                                                                                                                                                                                                                                          member endTagOpen

                                                                                                                                                                                                                                                                                                                          endTagOpen = 'endTagOpen'

                                                                                                                                                                                                                                                                                                                            member hexadecimalCharacterReference

                                                                                                                                                                                                                                                                                                                            hexadecimalCharacterReference = 'hexadecimalCharacterReference'

                                                                                                                                                                                                                                                                                                                              member hexadecimalCharacterReferenceStart

                                                                                                                                                                                                                                                                                                                              hexadecimalCharacterReferenceStart = 'hexadecimalCharacterReferenceStart'

                                                                                                                                                                                                                                                                                                                                member markupDeclarationOpen

                                                                                                                                                                                                                                                                                                                                markupDeclarationOpen = 'markupDeclarationOpen'

                                                                                                                                                                                                                                                                                                                                  member numericCharacterReference

                                                                                                                                                                                                                                                                                                                                  numericCharacterReference = 'numericCharacterReference'

                                                                                                                                                                                                                                                                                                                                    member numericCharacterReferenceEnd

                                                                                                                                                                                                                                                                                                                                    numericCharacterReferenceEnd = 'numericCharacterReferenceEnd'

                                                                                                                                                                                                                                                                                                                                      member plaintext

                                                                                                                                                                                                                                                                                                                                      plaintext = 'plaintext'

                                                                                                                                                                                                                                                                                                                                        member rawtext

                                                                                                                                                                                                                                                                                                                                        rawtext = 'rawtext'

                                                                                                                                                                                                                                                                                                                                          member rawtextEndTagName

                                                                                                                                                                                                                                                                                                                                          rawtextEndTagName = 'rawtextEndTagName'

                                                                                                                                                                                                                                                                                                                                            member rawtextEndTagOpen

                                                                                                                                                                                                                                                                                                                                            rawtextEndTagOpen = 'rawtextEndTagOpen'

                                                                                                                                                                                                                                                                                                                                              member rawtextLessThanSign

                                                                                                                                                                                                                                                                                                                                              rawtextLessThanSign = 'rawtextLessThanSign'

                                                                                                                                                                                                                                                                                                                                                member rcdata

                                                                                                                                                                                                                                                                                                                                                rcdata = 'rcdata'

                                                                                                                                                                                                                                                                                                                                                  member rcdataEndTagName

                                                                                                                                                                                                                                                                                                                                                  rcdataEndTagName = 'rcdataEndTagName'

                                                                                                                                                                                                                                                                                                                                                    member rcdataEndTagOpen

                                                                                                                                                                                                                                                                                                                                                    rcdataEndTagOpen = 'rcdataEndTagOpen'

                                                                                                                                                                                                                                                                                                                                                      member rcdataLessThanSign

                                                                                                                                                                                                                                                                                                                                                      rcdataLessThanSign = 'rcdataLessThanSign'

                                                                                                                                                                                                                                                                                                                                                        member scriptData

                                                                                                                                                                                                                                                                                                                                                        scriptData = 'scriptData'

                                                                                                                                                                                                                                                                                                                                                          member scriptDataDoubleEscaped

                                                                                                                                                                                                                                                                                                                                                          scriptDataDoubleEscaped = 'scriptDataDoubleEscaped'

                                                                                                                                                                                                                                                                                                                                                            member scriptDataDoubleEscapedDash

                                                                                                                                                                                                                                                                                                                                                            scriptDataDoubleEscapedDash = 'scriptDataDoubleEscapedDash'

                                                                                                                                                                                                                                                                                                                                                              member scriptDataDoubleEscapedDashDash

                                                                                                                                                                                                                                                                                                                                                              scriptDataDoubleEscapedDashDash = 'scriptDataDoubleEscapedDashDash'

                                                                                                                                                                                                                                                                                                                                                                member scriptDataDoubleEscapedLessThanSign

                                                                                                                                                                                                                                                                                                                                                                scriptDataDoubleEscapedLessThanSign = 'scriptDataDoubleEscapedLessThanSign'

                                                                                                                                                                                                                                                                                                                                                                  member scriptDataDoubleEscapeEnd

                                                                                                                                                                                                                                                                                                                                                                  scriptDataDoubleEscapeEnd = 'scriptDataDoubleEscapeEnd'

                                                                                                                                                                                                                                                                                                                                                                    member scriptDataDoubleEscapeStart

                                                                                                                                                                                                                                                                                                                                                                    scriptDataDoubleEscapeStart = 'scriptDataDoubleEscapeStart'

                                                                                                                                                                                                                                                                                                                                                                      member scriptDataEndTagName

                                                                                                                                                                                                                                                                                                                                                                      scriptDataEndTagName = 'scriptDataEndTagName'

                                                                                                                                                                                                                                                                                                                                                                        member scriptDataEndTagOpen

                                                                                                                                                                                                                                                                                                                                                                        scriptDataEndTagOpen = 'scriptDataEndTagOpen'

                                                                                                                                                                                                                                                                                                                                                                          member scriptDataEscaped

                                                                                                                                                                                                                                                                                                                                                                          scriptDataEscaped = 'scriptDataEscaped'

                                                                                                                                                                                                                                                                                                                                                                            member scriptDataEscapedDash

                                                                                                                                                                                                                                                                                                                                                                            scriptDataEscapedDash = 'scriptDataEscapedDash'

                                                                                                                                                                                                                                                                                                                                                                              member scriptDataEscapedDashDash

                                                                                                                                                                                                                                                                                                                                                                              scriptDataEscapedDashDash = 'scriptDataEscapedDashDash'

                                                                                                                                                                                                                                                                                                                                                                                member scriptDataEscapedEndTagName

                                                                                                                                                                                                                                                                                                                                                                                scriptDataEscapedEndTagName = 'scriptDataEscapedEndTagName'

                                                                                                                                                                                                                                                                                                                                                                                  member scriptDataEscapedEndTagOpen

                                                                                                                                                                                                                                                                                                                                                                                  scriptDataEscapedEndTagOpen = 'scriptDataEscapedEndTagOpen'

                                                                                                                                                                                                                                                                                                                                                                                    member scriptDataEscapedLessThanSign

                                                                                                                                                                                                                                                                                                                                                                                    scriptDataEscapedLessThanSign = 'scriptDataEscapedLessThanSign'

                                                                                                                                                                                                                                                                                                                                                                                      member scriptDataEscapeStart

                                                                                                                                                                                                                                                                                                                                                                                      scriptDataEscapeStart = 'scriptDataEscapeStart'

                                                                                                                                                                                                                                                                                                                                                                                        member scriptDataEscapseStartDash

                                                                                                                                                                                                                                                                                                                                                                                        scriptDataEscapseStartDash = 'scriptDataEscapseStartDash'

                                                                                                                                                                                                                                                                                                                                                                                          member scriptDataLessThanSign

                                                                                                                                                                                                                                                                                                                                                                                          scriptDataLessThanSign = 'scriptDataLessThanSign'

                                                                                                                                                                                                                                                                                                                                                                                            member selfClosingStartTag

                                                                                                                                                                                                                                                                                                                                                                                            selfClosingStartTag = 'selfClosingStartTag'

                                                                                                                                                                                                                                                                                                                                                                                              member tagName

                                                                                                                                                                                                                                                                                                                                                                                              tagName = 'tagName'

                                                                                                                                                                                                                                                                                                                                                                                                member tagOpen

                                                                                                                                                                                                                                                                                                                                                                                                tagOpen = 'tagOpen'

                                                                                                                                                                                                                                                                                                                                                                                                  enum TokenType

                                                                                                                                                                                                                                                                                                                                                                                                  const enum TokenType {
                                                                                                                                                                                                                                                                                                                                                                                                  Doctype = 'Doctype',
                                                                                                                                                                                                                                                                                                                                                                                                  StartTag = 'StartTag',
                                                                                                                                                                                                                                                                                                                                                                                                  EndTag = 'EndTag',
                                                                                                                                                                                                                                                                                                                                                                                                  Chars = 'Chars',
                                                                                                                                                                                                                                                                                                                                                                                                  Comment = 'Comment',

                                                                                                                                                                                                                                                                                                                                                                                                    member Chars

                                                                                                                                                                                                                                                                                                                                                                                                    Chars = 'Chars'

                                                                                                                                                                                                                                                                                                                                                                                                      member Comment

                                                                                                                                                                                                                                                                                                                                                                                                      Comment = 'Comment'

                                                                                                                                                                                                                                                                                                                                                                                                        member Doctype

                                                                                                                                                                                                                                                                                                                                                                                                        Doctype = 'Doctype'

                                                                                                                                                                                                                                                                                                                                                                                                          member EndTag

                                                                                                                                                                                                                                                                                                                                                                                                          EndTag = 'EndTag'

                                                                                                                                                                                                                                                                                                                                                                                                            member StartTag

                                                                                                                                                                                                                                                                                                                                                                                                            StartTag = 'StartTag'

                                                                                                                                                                                                                                                                                                                                                                                                              Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                              type Attribute

                                                                                                                                                                                                                                                                                                                                                                                                              type Attribute = [string, string, boolean];

                                                                                                                                                                                                                                                                                                                                                                                                                type Token

                                                                                                                                                                                                                                                                                                                                                                                                                type Token = StartTag | EndTag | Chars | Comment | Doctype;

                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (8)

                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                  No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (18)

                                                                                                                                                                                                                                                                                                                                                                                                                  Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                  No peer dependencies.


                                                                                                                                                                                                                                                                                                                                                                                                                  To add a badge like this badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                  You may also use to create a custom badge linking to

                                                                                                                                                                                                                                                                                                                                                                                                                  • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                  • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                    <a href=""><img src="" alt=""></a>