{"version":3,"file":"static/js/main.84434a50.js","mappings":"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,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,EAAE,KAAK,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,IAAI,IAAI,GAAG,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,GAAG,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,KAAK,KAAK,KAAK,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,KAAK,IAAK,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,EAAE,MAAM,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,GAAG,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,GAAG,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,KAAK,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,GAAG,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,GAAG,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,GAAG,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,GAAG,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,KAAK,KAAK,KAAK,EAAE,GAAG,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,GAAG,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,KAAK,KAAK,KAAK,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,GAAG,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,GAAG,IAAI,GAAG,EAAE,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,MAAM,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,KAAK,KAAK,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,MAAM,MAAM,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,MAAM,GAAG,GAAG,EAAE,KAAK,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,GAAG,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,GAAG,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,MAAM,GAAG,GAAG,EAAE,KAAK,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,KAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,KAAK,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,KAAK,GAAG,EAAE,GAAG,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,GAAG,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,IAAI,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,GAAG,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,GAAG,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,GAAG,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,KAAK,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,GAAG,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,GAAG,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,MAAM,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,MAAM,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,MAAM,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,IAAI,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,KAAK,KAAK,GAAG,EAAE,KAAK,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,EAAE,KAAK,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,EAAE,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,GAAG,MAAM,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,IAAI,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,GAAG,EAAE,MAAM,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,GAAG,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,MAAM,MAAM,EAAE,EAAE,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM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AAM,yCAA2CtP,EAAQ,KANhD,SAAfA,EAAMsH,KACRwpF,EAASl5D,EAAO53B,EAAMqG,UAEtBuxB,EAAM73B,KAAKC,EAIf,CACF,CAUA,SAASixF,EAAelwE,EAAMjd,EAAM9D,GAClC,GAAqB,kBAAVA,EAAoB,CAC7B,GAAI+gB,EAAK65B,QAAU56C,IAAUsV,OAAOu8B,MAAMv8B,OAAOtV,IAC/C,OAAOsV,OAAOtV,GAGhB,IACG+gB,EAAKiyB,SAAWjyB,EAAKowE,qBACX,KAAVnxF,IAAgBuQ,EAAAA,EAAAA,GAAUvQ,MAAWuQ,EAAAA,EAAAA,GAAUzM,IAEhD,OAAO,CAEX,CAEA,OAAO9D,CACT,mFChPas3B,GAAIgZ,UAAAA,GAAK1gB,EAAAA,GAAM,0ECRrB,IAAMwhE,EAA0B,CACrC,QACA,MACA,SACA,QACA,SACA,QACA,SACA,OACA,OACA,SACA,MACA,SACA,QACA,SACA,OACA,KACA,SACA,QACA,SACA,OACA,KACA,SACA,SACA,QACA,SACA,SACA,SACA,OACA,OACA,MACA,QACA,SACA,QACA,SACA,OACA,SACA,SACA,QACA,QACA,QACA,SACA,MACA,QACA,SACA,OACA,SACA,SACA,QACA,OACA,OACA,SACA,MACA,SACA,SACA,QACA,SACA,MACA,OACA,SACA,SACA,SACA,KACA,SACA,QACA,QACA,SACA,SACA,OACA,QACA,KACA,OACA,QACA,SACA,OACA,MACA,SACA,SACA,QACA,SACA,OACA,OACA,SACA,SACA,OACA,OACA,SACA,QACA,OACA,QACA,MACA,OACA,MACA,OACA,OACA,OACA,QACA,QACA,QACA,SACA,QACA,SACA,MACA,OACA,SACA,MACA,QC1GWC,EAA4B,CACvC,EAAG,SACH,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SAC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","sources":["../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","../node_modules/@babel/runtime/helpers/esm/slicedToArray.js","../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","../node_modules/@babel/runtime/helpers/esm/extends.js","../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../node_modules/@babel/runtime/helpers/esm/construct.js","../node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js","../node_modules/@babel/runtime/helpers/esm/isNativeFunction.js","../node_modules/@uiw/github-corners/src/index.ts","../node_modules/@uiw/react-github-corners/src/index.tsx","../node_modules/@uiw/react-shields/src/common/Container.tsx","../node_modules/@uiw/react-shields/src/common/Base.tsx","../node_modules/@uiw/react-shields/src/github/Issues.tsx","../node_modules/@uiw/react-shields/src/github/Size.tsx","../node_modules/@uiw/react-shields/src/github/Downloads.tsx","../node_modules/@uiw/react-shields/src/github/Activity.tsx","../node_modules/@uiw/react-shields/src/github/Version.tsx","../node_modules/@uiw/react-shields/src/github/License.tsx","../node_modules/@uiw/react-shields/src/github/Analysis.tsx","../node_modules/@uiw/react-shields/src/github/Social.tsx","../node_modules/@uiw/react-shields/src/github/Github.tsx","../node_modules/@uiw/react-shields/src/github/index.tsx","../node_modules/@uiw/react-shields/src/npm/Version.tsx","../node_modules/@uiw/react-shields/src/npm/Size.tsx","../node_modules/@uiw/react-shields/src/npm/Npm.tsx","../node_modules/@uiw/react-shields/src/npm/index.tsx","../node_modules/@uiw/react-back-to-top/src/index.tsx","logo.svg","../node_modules/@babel/runtime/helpers/esm/defineProperty.js","../node_modules/@babel/runtime/helpers/esm/objectSpread2.js","../node_modules/unist-util-stringify-position/index.js","../node_modules/vfile-message/index.js","../node_modules/vfile/lib/minpath.browser.js","../node_modules/vfile/lib/minproc.browser.js","../node_modules/vfile/lib/minurl.shared.js","../node_modules/vfile/lib/minurl.browser.js","../node_modules/vfile/lib/index.js","../node_modules/@babel/runtime/helpers/esm/toArray.js","../node_modules/bail/index.js","../node_modules/unified/node_modules/is-plain-obj/index.js","../node_modules/trough/index.js","../node_modules/unified/lib/index.js","../node_modules/mdast-util-to-string/index.js","../node_modules/micromark-util-chunked/index.js","../node_modules/micromark-util-combine-extensions/index.js","../node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","../node_modules/micromark-util-character/index.js","../node_modules/micromark-factory-space/index.js","../node_modules/micromark/lib/initialize/content.js","../node_modules/micromark/lib/initialize/document.js","../node_modules/micromark-core-commonmark/lib/blank-line.js","../node_modules/micromark-util-subtokenize/index.js","../node_modules/micromark-core-commonmark/lib/content.js","../node_modules/micromark/lib/initialize/flow.js","../node_modules/micromark/lib/initialize/text.js","../node_modules/micromark-util-resolve-all/index.js","../node_modules/micromark/lib/create-tokenizer.js","../node_modules/micromark-core-commonmark/lib/thematic-break.js","../node_modules/micromark-core-commonmark/lib/list.js","../node_modules/micromark-core-commonmark/lib/block-quote.js","../node_modules/micromark-factory-destination/index.js","../node_modules/micromark-factory-label/index.js","../node_modules/micromark-factory-title/index.js","../node_modules/micromark-factory-whitespace/index.js","../node_modules/micromark-util-normalize-identifier/index.js","../node_modules/micromark-core-commonmark/lib/definition.js","../node_modules/micromark-core-commonmark/lib/code-indented.js","../node_modules/micromark-core-commonmark/lib/heading-atx.js","../node_modules/micromark-core-commonmark/lib/setext-underline.js","../node_modules/micromark-util-html-tag-name/index.js","../node_modules/micromark-core-commonmark/lib/html-flow.js","../node_modules/micromark-core-commonmark/lib/code-fenced.js","../node_modules/micromark-core-commonmark/lib/character-reference.js","../node_modules/micromark-core-commonmark/lib/character-escape.js","../node_modules/micromark-core-commonmark/lib/line-ending.js","../node_modules/micromark-core-commonmark/lib/label-end.js","../node_modules/micromark-core-commonmark/lib/label-start-image.js","../node_modules/micromark-util-classify-character/index.js","../node_modules/micromark-core-commonmark/lib/attention.js","../node_modules/micromark-core-commonmark/lib/autolink.js","../node_modules/micromark-core-commonmark/lib/html-text.js","../node_modules/micromark-core-commonmark/lib/label-start-link.js","../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","../node_modules/micromark-core-commonmark/lib/code-text.js","../node_modules/micromark/lib/constructs.js","../node_modules/micromark/lib/preprocess.js","../node_modules/micromark-util-decode-numeric-character-reference/index.js","../node_modules/micromark-util-decode-string/index.js","../node_modules/mdast-util-from-markdown/lib/index.js","../node_modules/micromark/lib/postprocess.js","../node_modules/micromark/lib/parse.js","../node_modules/remark-parse/index.js","../node_modules/remark-parse/lib/index.js","../node_modules/unist-builder/index.js","../node_modules/unist-util-is/index.js","../node_modules/unist-util-visit-parents/index.js","../node_modules/unist-util-visit/index.js","../node_modules/unist-util-position/index.js","../node_modules/mdast-util-definitions/index.js","../node_modules/mdast-util-to-hast/lib/traverse.js","../node_modules/micromark-util-sanitize-uri/index.js","../node_modules/mdast-util-to-hast/lib/wrap.js","../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","../node_modules/mdast-util-to-hast/lib/revert.js","../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","../node_modules/trim-lines/index.js","../node_modules/mdast-util-to-hast/lib/handlers/index.js","../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","../node_modules/mdast-util-to-hast/lib/handlers/break.js","../node_modules/mdast-util-to-hast/lib/handlers/code.js","../node_modules/mdast-util-to-hast/lib/handlers/delete.js","../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","../node_modules/mdast-util-to-hast/lib/handlers/footnote.js","../node_modules/mdast-util-to-hast/lib/handlers/heading.js","../node_modules/mdast-util-to-hast/lib/handlers/html.js","../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","../node_modules/mdast-util-to-hast/lib/handlers/image.js","../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","../node_modules/mdast-util-to-hast/lib/handlers/link.js","../node_modules/mdast-util-to-hast/lib/handlers/list.js","../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","../node_modules/mdast-util-to-hast/lib/handlers/root.js","../node_modules/mdast-util-to-hast/lib/handlers/strong.js","../node_modules/mdast-util-to-hast/lib/handlers/table.js","../node_modules/mdast-util-to-hast/lib/handlers/text.js","../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","../node_modules/mdast-util-to-hast/lib/index.js","../node_modules/unist-util-generated/index.js","../node_modules/mdast-util-to-hast/lib/footer.js","../node_modules/remark-rehype/lib/index.js","../node_modules/react-markdown/lib/rehype-filter.js","../node_modules/react-markdown/lib/uri-transformer.js","../node_modules/hast-util-whitespace/index.js","../node_modules/property-information/lib/hast-to-react.js","../node_modules/react-markdown/lib/ast-to-react.js","../node_modules/react-markdown/lib/react-markdown.js","../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js","../node_modules/micromark-extension-gfm-footnote/lib/syntax.js","../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js","../node_modules/micromark-extension-gfm-table/lib/syntax.js","../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js","../node_modules/micromark-extension-gfm/index.js","../node_modules/ccount/index.js","../node_modules/mdast-util-find-and-replace/lib/index.js","../node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js","../node_modules/mdast-util-gfm-autolink-literal/index.js","../node_modules/mdast-util-to-markdown/lib/util/association.js","../node_modules/mdast-util-to-markdown/lib/util/track.js","../node_modules/mdast-util-to-markdown/lib/util/container-flow.js","../node_modules/mdast-util-to-markdown/lib/util/indent-lines.js","../node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js","../node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js","../node_modules/mdast-util-to-markdown/lib/util/safe.js","../node_modules/mdast-util-gfm-footnote/index.js","../node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js","../node_modules/mdast-util-gfm-strikethrough/index.js","../node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","../node_modules/markdown-table/index.js","../node_modules/mdast-util-gfm-table/lib/index.js","../node_modules/mdast-util-to-markdown/lib/handle/list-item.js","../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","../node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","../node_modules/mdast-util-gfm-task-list-item/index.js","../node_modules/mdast-util-gfm/lib/index.js","../node_modules/remark-gfm/index.js","../node_modules/hastscript/lib/svg.js","../node_modules/hastscript/lib/svg-case-sensitive-tag-names.js","../node_modules/web-namespaces/index.js","../node_modules/hast-util-from-parse5/lib/index.js","../node_modules/vfile-location/index.js","../node_modules/hast-to-hyperscript/index.js","../node_modules/zwitch/index.js","../node_modules/hast-util-to-parse5/lib/index.js","../node_modules/html-void-elements/index.js","../node_modules/hast-util-raw/lib/index.js","../node_modules/rehype-raw/index.js","../node_modules/hast-util-has-property/index.js","../node_modules/hast-util-heading-rank/index.js","../node_modules/hast-util-to-string/index.js","../node_modules/rehype-slug/index.js","../node_modules/hast-util-is-element/index.js","../node_modules/rehype-autolink-headings/lib/index.js","../node_modules/rehype-attr/src/utils.ts","../node_modules/rehype-attr/src/index.ts","../node_modules/rehype-ignore/src/index.ts","../node_modules/unist-util-filter/index.js","../../src/generator.js","../../src/all.js","../../src/common.js","../node_modules/direction/index.js","../node_modules/hast-util-select/lib/util.js","../node_modules/hast-util-select/lib/enter-state.js","../node_modules/hast-util-select/lib/nest.js","../node_modules/bcp-47-match/index.js","../node_modules/hast-util-select/lib/pseudo.js","../node_modules/hast-util-select/lib/attribute.js","../node_modules/hast-util-select/lib/test.js","../node_modules/hast-util-select/lib/name.js","../node_modules/hast-util-select/lib/class-name.js","../node_modules/hast-util-select/lib/id.js","../node_modules/hast-util-select/lib/any.js","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/parse.ts","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/index.ts","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/compile.ts","../node_modules/hast-util-select/lib/parse.js","../node_modules/hast-util-select/index.js","../node_modules/rehype-rewrite/src/index.ts","../src/nodes/octiconLink.ts","../src/plugins/reservedMeta.ts","../src/index.tsx","../src/plugins/useCopied.tsx","../src/nodes/copy.ts","App.tsx","../README.md","index.tsx","../../src/main.js","../node_modules/@wcj/dark-mode/dist/dark-mode.min.js","../node_modules/boolbase/index.js","../node_modules/css-selector-parser/lib/index.js","../node_modules/css-selector-parser/lib/parser-context.js","../node_modules/css-selector-parser/lib/render.js","../node_modules/css-selector-parser/lib/utils.js","../node_modules/extend/index.js","../node_modules/github-slugger/index.js","../node_modules/github-slugger/regex.js","../node_modules/inline-style-parser/index.js","../node_modules/is-buffer/index.js","../node_modules/parse-numeric-range/index.js","../node_modules/parse5/lib/common/doctype.js","../node_modules/parse5/lib/common/error-codes.js","../node_modules/parse5/lib/common/foreign-content.js","../node_modules/parse5/lib/common/html.js","../node_modules/parse5/lib/common/unicode.js","../node_modules/parse5/lib/extensions/error-reporting/mixin-base.js","../node_modules/parse5/lib/extensions/error-reporting/parser-mixin.js","../node_modules/parse5/lib/extensions/error-reporting/preprocessor-mixin.js","../node_modules/parse5/lib/extensions/error-reporting/tokenizer-mixin.js","../node_modules/parse5/lib/extensions/location-info/open-element-stack-mixin.js","../node_modules/parse5/lib/extensions/location-info/parser-mixin.js","../node_modules/parse5/lib/extensions/location-info/tokenizer-mixin.js","../node_modules/parse5/lib/extensions/position-tracking/preprocessor-mixin.js","../node_modules/parse5/lib/parser/formatting-element-list.js","../node_modules/parse5/lib/parser/index.js","../node_modules/parse5/lib/parser/open-element-stack.js","../node_modules/parse5/lib/tokenizer/index.js","../node_modules/parse5/lib/tokenizer/named-entity-data.js","../node_modules/parse5/lib/tokenizer/preprocessor.js","../node_modules/parse5/lib/tree-adapters/default.js","../node_modules/parse5/lib/utils/merge-options.js","../node_modules/parse5/lib/utils/mixin.js","../node_modules/prop-types/factoryWithThrowingShims.js","../node_modules/prop-types/index.js","../node_modules/prop-types/lib/ReactPropTypesSecret.js","../node_modules/react-markdown/node_modules/react-is/cjs/react-is.production.min.js","../node_modules/react-markdown/node_modules/react-is/index.js","../node_modules/scheduler/cjs/scheduler.production.min.js","../node_modules/scheduler/index.js","../node_modules/style-to-object/index.js","../node_modules/@babel/runtime/helpers/arrayLikeToArray.js","../node_modules/@babel/runtime/helpers/arrayWithHoles.js","../node_modules/@babel/runtime/helpers/assertThisInitialized.js","../node_modules/@babel/runtime/helpers/classCallCheck.js","../node_modules/@babel/runtime/helpers/construct.js","../node_modules/@babel/runtime/helpers/createClass.js","../node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js","../node_modules/@babel/runtime/helpers/createSuper.js","../node_modules/@babel/runtime/helpers/defineProperty.js","../node_modules/@babel/runtime/helpers/get.js","../node_modules/@babel/runtime/helpers/getPrototypeOf.js","../node_modules/@babel/runtime/helpers/inherits.js","../node_modules/@babel/runtime/helpers/isNativeFunction.js","../node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js","../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","../node_modules/@babel/runtime/helpers/nonIterableRest.js","../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","../node_modules/@babel/runtime/helpers/setPrototypeOf.js","../node_modules/@babel/runtime/helpers/slicedToArray.js","../node_modules/@babel/runtime/helpers/superPropBase.js","../node_modules/@babel/runtime/helpers/typeof.js","../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","../node_modules/@babel/runtime/helpers/wrapNativeSuper.js","../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","../node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","../node_modules/@babel/runtime/helpers/esm/createClass.js","../node_modules/@babel/runtime/helpers/esm/typeof.js","../node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","../node_modules/@babel/runtime/helpers/esm/createSuper.js","../node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","../node_modules/@babel/runtime/helpers/esm/inherits.js","../node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js","../node_modules/@babel/runtime/helpers/esm/iterableToArray.js","../node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","../node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","../node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","../node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","../node_modules/comma-separated-tokens/index.js","../node_modules/decode-named-character-reference/index.dom.js","../node_modules/hast-util-parse-selector/index.js","../node_modules/hastscript/lib/core.js","../node_modules/hastscript/lib/html.js","../node_modules/character-entities-legacy/index.js","../node_modules/character-reference-invalid/index.js","../node_modules/is-decimal/index.js","../node_modules/is-hexadecimal/index.js","../node_modules/is-alphanumerical/index.js","../node_modules/is-alphabetical/index.js","../node_modules/parse-entities/lib/index.js","../node_modules/property-information/lib/util/schema.js","../node_modules/property-information/lib/util/merge.js","../node_modules/property-information/lib/util/create.js","../node_modules/property-information/lib/xlink.js","../node_modules/property-information/lib/xml.js","../node_modules/property-information/lib/util/case-sensitive-transform.js","../node_modules/property-information/lib/util/case-insensitive-transform.js","../node_modules/property-information/lib/xmlns.js","../node_modules/property-information/lib/aria.js","../node_modules/property-information/lib/html.js","../node_modules/property-information/lib/svg.js","../node_modules/property-information/index.js","../node_modules/property-information/lib/find.js","../node_modules/property-information/lib/normalize.js","../node_modules/property-information/lib/util/defined-info.js","../node_modules/property-information/lib/util/info.js","../node_modules/property-information/lib/util/types.js","../node_modules/space-separated-tokens/index.js","../webpack/bootstrap","../webpack/runtime/chunk loaded","../webpack/runtime/compat get default export","../webpack/runtime/define property getters","../webpack/runtime/hasOwnProperty shorthand","../webpack/runtime/make namespace object","../webpack/runtime/publicPath","../webpack/runtime/jsonp chunk loading","../webpack/startup"],"sourcesContent":["export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _s, _e;\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n  return _arr;\n}","export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.js\";\nexport default function _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    _construct = Reflect.construct.bind();\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n  return _construct.apply(null, arguments);\n}","import getPrototypeOf from \"./getPrototypeOf.js\";\nimport setPrototypeOf from \"./setPrototypeOf.js\";\nimport isNativeFunction from \"./isNativeFunction.js\";\nimport construct from \"./construct.js\";\nexport default function _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !isNativeFunction(Class)) return Class;\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n      _cache.set(Class, Wrapper);\n    }\n    function Wrapper() {\n      return construct(Class, arguments, getPrototypeOf(this).constructor);\n    }\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return setPrototypeOf(Wrapper, Class);\n  };\n  return _wrapNativeSuper(Class);\n}","export default function _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}","// @ts-ignore\ndeclare global {\n  interface HTMLElementTagNameMap {\n    'github-corners': GithubCorners;\n  }\n  namespace JSX {\n    interface IntrinsicElements {\n      'github-corners': Partial<GithubCorners> | {\n        style?: Partial<CSSStyleDeclaration> | React.CSSProperties;\n      };\n    }\n  }\n}\n\nconst GITHUB_CORNERS_TEMPLATE = document.createElement(\"template\");\nGITHUB_CORNERS_TEMPLATE.innerHTML = `\n<style>\n:host a:hover .octo-arm { animation: octocat-wave 560ms ease-in-out; }\n@keyframes octocat-wave {\n  0%, 100% { transform: rotate(0); }\n  20%, 60% { transform: rotate(-25deg); }\n  40%, 80% { transform: rotate(10deg); }\n}\n@media (max-width:500px) {\n  :host a:hover .octo-arm { animation: none; }\n  :host .octo-arm { animation: octocat-wave 560ms ease-in-out; }\n}\n:host svg {\n  z-index: 99;\n  position: fixed;\n  border: 0px;\n  top: 0px;\n}\n</style>\n<svg width=\"54\" height=\"54\" viewBox=\"0 0 250 250\" aria-hidden=\"true\">\n  <a xlink:href=\"https://github.com/uiwjs/react-github-corners\" target=\"_blank\" rel=\"nofollow sponsored\" style=\"fill: rgb(21, 21, 19); color: rgb(255, 255, 255);\">\n    <g>\n      <path d=\"M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z\"></path>\n      <path d=\"M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2\" fill=\"currentColor\" class=\"octo-arm\" style=\"transform-origin: 130px 106px;\"></path>\n      <path d=\"M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z\" fill=\"currentColor\" class=\"octo-body\"></path>\n    </g>\n  </a>\n</svg>\n`;\n\nexport class GithubCorners extends HTMLElement {\n  /** Sets the z-order of a positioned element and its descendants or flex items. */\n  'z-index'?: string;\n  height?: string | number;\n  width?: string | number;\n  href?: string;\n  color?: string;\n  fill?: string;\n  position?: string;\n  target?: string;\n  top?: string;\n  left?: string;\n  right?: string = '0';\n  bottom?: string;\n  transform?: string;\n  private shadow: ShadowRoot\n  static get observedAttributes(): string[] {\n    return ['style', 'z-index', 'target', 'height', 'width', 'href', 'color', 'fill', 'position', 'top', 'left', 'right', 'bottom', 'transform'];\n  }\n  constructor() {\n    super();\n    this.shadow = this.attachShadow({ mode: 'open' });\n    this.shadow.appendChild(this.ownerDocument.importNode(GITHUB_CORNERS_TEMPLATE.content, true));\n    this.update()\n  }\n  private setAttr(name: string, value: string) {\n    const svg = this.shadow.querySelector('svg');\n    if (/(href)/.test(name.toLocaleLowerCase())) {\n      svg.lastElementChild.setAttribute('xlink:href', value);\n    } else if (/(color|fill)/.test(name.toLocaleLowerCase())) {\n      (svg.firstElementChild as HTMLAnchorElement).style[name as any] = value;\n    } else if (/(z-index|position|top|left|right|bottom|transform)/.test(name.toLocaleLowerCase())) {\n      svg.style[name as any] = value;\n    } else {\n      svg.setAttribute(name, value);\n    }\n  }\n  private update() {\n    ;[...this.getAttributeNames(), 'right'].forEach((name) => {\n      const value = this.getAttribute(name) || this[name as keyof GithubCorners] as any || '';\n      this.setAttr(name, value);\n    });\n  }\n  attributeChangedCallback(name: string, oldValue: string, newValue: string) {\n    if (oldValue !== newValue) {\n      this.setAttr(name, newValue);\n    }\n  }\n}\n\ncustomElements.define('github-corners', GithubCorners);","import React from 'react';\nimport '@uiw/github-corners';\n\nexport interface GitHubCornersProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {\n  /**\n   * The link to your project page.\n   */\n  href?: string;\n  /**\n   * The width and height of the corner. \n   * Default: `80`\n   */\n  size?: number;\n  /**\n   * The background color of the corner.\n   * Default: `#151513`\n   */\n  bgColor?: string;\n  /**\n   * The Github logo color of the corner.\n   * Default: `#fff`\n   */\n  color?: string;\n  /**\n   * The position of corner. \n   * Default: `right`\n   */\n  position?: 'left' | 'right';\n  /** Is it displayed at the bottom? */\n  bottom?: boolean,\n  /** \n   * It is positioned relative to the initial containing block established.\n   * Default: `false`\n   */\n  fixed?: boolean;\n  /**\n   * Sets the z-order of a positioned element and its descendants or flex items.\n   */\n  zIndex?: number;\n}\n\nexport default function githubCorners(props: GitHubCornersProps) {\n  const { size = 80, fixed = false, bottom, zIndex, className, style, bgColor = '#151513', color = '#fff', position = 'right', ...otherProps } = props;\n  const styl: React.CSSProperties = position === 'left' ? { left: 0, right: 'initial', transform: 'scale(-1, 1)' } : { right: 0, left: 'initial', transform: 'scale(1, 1)' };\n  if (bottom) {\n    styl.bottom = 0;\n    styl.top = 'initial';\n    styl.transform = position === 'left' ? 'scale(-1, -1)' : 'scale(1, -1)';\n  } else {\n    styl.bottom = 'initial';\n    styl.top = 0;\n  }\n  return (\n    <github-corners\n      target=\"__blank\"\n      width={size}\n      height={size}\n      href={props.href}\n      position={fixed ? 'fixed' : 'absolute'}\n      z-index={zIndex}\n      style={style}\n      fill={bgColor}\n      color={color}\n      {...styl}\n      {...otherProps}\n    />\n  );\n}","import React, { Component, ReactElement } from 'react';\nimport { BaseProps } from '../common/Base';\n\nexport interface ContainerProps extends BaseProps {}\n\nexport default class Container extends Component<ContainerProps> {\n  render() {\n    return (\n      <>\n        {React.Children.toArray(this.props.children).map((child: React.ReactNode) => {\n          if (!React.isValidElement(child)) return null;\n          return React.cloneElement(child as ReactElement, { ...this.props, ...(child as React.ReactElement).props });\n        })}\n      </>\n    );\n  }\n}","import React, { Component } from 'react';\n\nexport interface BaseProps {\n  platform?: 'github' | 'coveralls' | 'npm';\n  type?: string;\n  user?: string;\n  repo?: string;\n  base?: string;\n  href?: HTMLAnchorElement['href'];\n  children?: React.ReactNode;\n}\n\nexport interface BaseState extends BaseProps {}\n\nexport default class Base<T> extends Component<BaseProps & T, BaseState & T> {\n  static defaultProps: BaseProps = {\n    platform: 'github',\n    base: 'https://img.shields.io',\n  }\n  constructor(props: BaseProps & T, defaultState: BaseProps & T, forceState?: BaseProps & T) {\n    super(props);\n    this.state = Object.assign({}, { ...defaultState,  ...props }, forceState);\n  }\n  getUrl = () => '';\n  render() {\n    const { href } = this.state;\n    if (href) {\n      return <a href={href}> <img alt=\"\" src={this.getUrl()} /> </a>;\n    }\n    return <img alt=\"\" src={this.getUrl()} />;\n  }\n}","import Base, { BaseProps} from '../common/Base';\n\nexport interface IssueProps extends BaseProps {\n  /**\n   * Github Issue\n   * \n   * `/github/:issueKind/detail/:property/:user/:repo/:number`  \n   * GitHub issue/pull request detail: GitHub issue/pull request detail badge  \n   * \n   * `/github/issues/:user/:repo`  \n   * GitHub issues:  GitHub issues badge \n   * \n   * `/github/issues-raw/:user/:repo`  \n   * GitHub issues:  GitHub issues badge \n   * \n   * `/github/issues/:user/:repo/:label`  \n   * GitHub issues by-label: GitHub issues by-label badge  \n   * \n   * `/github/issues-raw/:user/:repo/:label`  \n   * GitHub issues by-label: GitHub issues by-label badge  \n   * \n   * `/github/issues-closed/:user/:repo`  \n   * GitHub closed issues: GitHub closed issues badge  \n   * \n   * `/github/issues-closed-raw/:user/:repo`  \n   * GitHub closed issues: GitHub closed issues badge  \n   * \n   * `/github/issues-pr/:user/:repo`  \n   * GitHub pull requests: GitHub pull requests badge  \n   * \n   * `/github/issues-pr-raw/:user/:repo`  \n   * GitHub pull requests: GitHub pull requests badge  \n   * \n   * `/github/issues-pr-closed/:user/:repo`  \n   * GitHub closed pull requests:  GitHub closed pull requests badge \n   * \n   * `/github/issues-pr-closed-raw/:user/:repo`  \n   * GitHub closed pull requests:  GitHub closed pull requests badge \n   * \n   * `/github/issues-pr/:user/:repo/:label`  \n   * GitHub pull requests by-label:  GitHub pull requests by-label badge \n   * \n   * `/github/issues-pr-raw/:user/:repo/:label`  \n   * GitHub pull requests by-label:  GitHub pull requests by-label badge \n   * \n   * `/github/labels/:user/:repo/:name`  \n   * GitHub labels:  GitHub labels badge \n   */\n  type?: 'issueKind' | 'issues' | 'issues-raw' | 'issues-closed'\n    | 'issues-closed-raw' | 'issues-pr' | 'issues-pr-raw' \n    | 'issues-pr-closed' | 'issues-pr-closed-raw'\n    | 'languages';\n  /**\n   * /github/:issueKind/detail/:property/:user/:repo/:number\n   */\n  property?: string;\n  /**\n   * /github/:issueKind/detail/:property/:user/:repo/:number\n   */\n  number?: string;\n  label?: string;\n}\n\nexport default class Issue extends Base<IssueProps> {\n  constructor(props: IssueProps) {\n    super(props, { platform: 'github', type: 'issues' });\n  };\n  getUrl = () => {\n    const { type, platform, property, user, repo, label, base } = this.state;\n    if (platform !== 'github') return '';\n    if (type === 'issues' || /^issues-(raw|closed|closed-raw|pr|pr-raw|pr-closed|pr-closed-raw)/.test(type!)) {\n      if(label && (type === 'issues' || /^issues-(raw|pr|pr-raw)/.test(type || ''))) {\n        return [base, platform, type, user, repo, label].join('/');\n      }\n      return [base, platform, type, user, repo].join('/');\n    }\n    if(type === 'issueKind') {\n      return [base, platform, type, 'detail', property, user, repo].join('/');\n    }\n    return '';\n  }\n}","import Base, { BaseProps } from '../common/Base';\n\nexport interface SizeProps extends BaseProps {\n  /**\n   * Github Size\n   * \n   * /github/languages/code-size/:user/:repo  \n   * /github/repo-size/:user/:repo  \n   * /github/size/:user/:repo/:path*  \n   */\n  type?: 'languages' | 'repo-size' | 'size';\n  /**\n   * GitHub file size in bytes\n   * build/phaser-craft.min.js\n   */\n  path?: string;\n}\n\nexport default class Size extends Base<SizeProps> {\n  constructor(props: SizeProps) {\n    super(props, { platform: 'github', type: 'languages' });\n  };\n\n  getUrl = () => {\n    const { type, platform, user, repo, base, path } = this.state;\n    if (platform !== 'github') return '';\n    /**\n     * /github/languages/code-size/:user/:repo\n     */\n    if (type === 'languages') {\n      return [base, platform, type, 'code-size', user, repo].join('/');\n    }\n    /**\n     * /github/repo-size/:user/:repo\n     */\n    if (type === 'repo-size') {\n      return [base, platform, type, user, repo].join('/');\n    }\n    /**\n     * /github/size/:user/:repo/:path*\n     */\n    if (type === 'size' && path) {\n      return [base, platform, type, user, repo, path].join('/');\n    }\n    return '';\n  }\n}","import Base, { BaseProps} from '../common/Base';\n\nexport interface ActivityProps extends BaseProps {\n  /**\n   * Github Downloads\n   * \n   * `/github/downloads/:user/:repo/total`\n   * GitHub All Releases:  GitHub All Releases badge \n   * \n   * `/github/downloads/:user/:repo/:tag/total`\n   * GitHub Releases:  GitHub Releases badge \n   * \n   * `/github/downloads-pre/:user/:repo/:tag/total`\n   * GitHub Pre-Releases:  GitHub Pre-Releases badge \n   * \n   * `/github/downloads/:user/:repo/:tag/total`\n   * GitHub Releases (by Release): GitHub Releases (by Release) badge  \n   * \n   * `/github/downloads/:user/:repo/:tag/:path`\n   * GitHub Releases (by Asset): GitHub Releases (by Asset) badge  \n   * \n   * `/github/downloads-pre/:user/:repo/:tag/:path`\n   * GitHub Pre-Releases (by Asset): GitHub Pre-Releases (by Asset) badge  \n   */\n  type?: 'downloads' | 'downloads-pre';\n  tag?: string;\n  path?: string;\n  total?: boolean;\n}\n\nexport default class Activity extends Base<ActivityProps> {\n  constructor(props: ActivityProps) {\n    super(props, { platform: 'github', type: 'downloads', total: true });\n  };\n  getUrl = () => {\n    const { type, platform, user, repo, base, tag, path, total } = this.state;\n    if (platform !== 'github' || !/^(downloads|downloads-pre)/.test(type || '')) return '';\n\n    const baseData = [base, platform, type, user, repo];\n\n    if (path && tag) {\n      return [...baseData, tag, path].join('/');\n    }\n    if ((total && tag) || (type === 'downloads-pre' && tag && total)) {\n      return [...baseData, tag, 'total'].join('/');\n    }\n    if (total) {\n      return [...baseData, 'total'].join('/');\n    }\n    return '';\n  }\n}","import Base, { BaseProps} from '../common/Base';\n\nexport interface ActivityProps extends BaseProps {\n  /**\n   * `/github/commit-activity/:interval/:user/:repo`\n   * GitHub commit activity: GitHub commit activity badge  \n   * \n   * `/github/commits-since/:user/:repo/:version/:branch*`\n   * GitHub commits since tagged version:  GitHub commits since tagged version badge \n   * \n   * `/github/commits-since/:user/:repo/:version/:branch*`\n   * GitHub commits since tagged version (branch): GitHub commits since tagged version (branch) badge  \n   * \n   * `/github/commits-since/:user/:repo/:version/:branch*`\n   * GitHub commits since latest release:  GitHub commits since latest release badge \n   * \n   * `/github/commits-since/:user/:repo/:version/:branch*`\n   * GitHub commits since latest release (branch): GitHub commits since latest release (branch) badge  \n   * \n   * `/github/:variant/:user/:repo`\n   * GitHub contributors:  GitHub contributors badge \n   * \n   * `/github/last-commit/:user/:repo`\n   * GitHub last commit: GitHub last commit badge  \n   * \n   * `/github/last-commit/:user/:repo/:branch`\n   * GitHub last commit (branch):  GitHub last commit (branch) badge \n   * \n   * `/github/release-date/:user/:repo`\n   * GitHub Release Date:  GitHub Release Date badge \n   * \n   * `/github/release-date-pre/:user/:repo`\n   * GitHub (Pre-)Release Date:  GitHub (Pre-)Release Date badge \n   */\n  type?: 'commit-activity' | 'commits-since' | 'variant' | 'last-commit' | 'release-date' | 'release-date-pre';\n  variant?: string;\n  interval?: 'y' | 'm' | 'w';\n  version?: 'contributors' | 'contributors-anon';\n  branch?: string;\n}\n\nexport default class Activity extends Base<ActivityProps> {\n  constructor(props: ActivityProps) {\n    super(props, { platform: 'github', type: 'commits-since' });\n  };\n  getUrl = () => {\n    const { type, platform, user, repo, base, interval, variant, version, branch } = this.state;\n    if (platform !== 'github') return '';\n    if (type === 'commits-since' && version && branch) {\n      return [base, platform, type, user, repo, version, branch].join('/');\n    }\n    if (type === 'commit-activity' && interval) {\n      return [base, platform, type, interval, user, repo].join('/');\n    }\n    if (type === 'variant' && variant) {\n      return [base, platform, type, variant, user, repo].join('/');\n    }\n    if (type === 'last-commit') {\n      return branch ? [base, platform, type, user, repo, branch].join('/') : [base, platform, type, user, repo].join('/');\n    }\n    if (type && /^release-(date|date-pre)/.test(type)) {\n      return [base, platform, type, user, repo].join('/');\n    }\n    return '';\n  }\n}","import Base, { BaseProps } from '../common/Base';\n\nexport interface VersionProps extends BaseProps {\n  /**\n   * Github Version\n   * \n   * `/github/go-mod/go-version/:user/:repo`\n   * GitHub go.mod Go version: GitHub go.mod Go version badge  \n   * \n   * `/github/go-mod/go-version/:user/:repo/:branch`\n   * GitHub go.mod Go version (branch):  GitHub go.mod Go version (branch) badge \n   * \n   * `/github/go-mod/go-version/:user/:repo?filename=src%2Fgo.mod`\n   * GitHub go.mod Go version (subfolder of monorepo): GitHub go.mod Go version (subfolder of monorepo) badge  \n   * \n   * `/github/go-mod/go-version/:user/:repo/:branch?filename=src%2Fgo.mod`\n   * GitHub go.mod Go version (branch & subfolder of monorepo):  GitHub go.mod Go version (branch & subfolder of monorepo) badge \n   * \n   * `/github/manifest-json/v/:user/:repo`\n   * GitHub manifest version:  GitHub manifest version badge \n   * \n   * `/github/manifest-json/v/:user/:repo/:branch`\n   * GitHub manifest version:  GitHub manifest version badge \n   * \n   * `/github/package-json/v/:user/:repo`\n   * GitHub package.json version:  GitHub package.json version badge \n   * \n   * `/github/package-json/v/:user/:repo/:branch`\n   * GitHub package.json version (branch): GitHub package.json version (branch) badge  \n   * \n   * `/github/v/release/:user/:repo`\n   * GitHub release (latest by date):  GitHub release (latest by date) badge \n   * \n   * `/github/v/release/:user/:repo?include_prereleases`\n   * GitHub release (latest by date including pre-releases): GitHub release (latest by date including pre-releases) badge  \n   * \n   * `/github/v/release/:user/:repo?sort=semver`\n   * GitHub release (latest SemVer): GitHub release (latest SemVer) badge  \n   * \n   * `/github/v/release/:user/:repo?include_prereleases&sort=semver`\n   * GitHub release (latest SemVer including pre-releases):  GitHub release (latest SemVer including pre-releases) badge \n   * \n   * `/github/v/tag/:user/:repo`\n   * GitHub tag (latest by date):  GitHub tag (latest by date) badge \n   * \n   * `/github/v/tag/:user/:repo?sort=semver`\n   * GitHub tag (latest SemVer): GitHub tag (latest SemVer) badge  \n   * \n   * `/github/v/tag/:user/:repo?include_prereleases&sort=semver`\n   * GitHub tag (latest SemVer pre-release): GitHub tag (latest SemVer pre-release) badge  \n   */\n  type?: 'version-release' | 'version-tag' | 'package-json' | 'manifest-json' | 'go-mod';\n  branch?: string;\n}\n\nexport default class Version extends Base<VersionProps> {\n  constructor(props: VersionProps) {\n    super(props, { platform: 'github', type: 'version-release' });\n  };\n\n  getUrl = () => {\n    const { type, platform, user, repo, base, branch } = this.state;\n    let typePath = '';\n    switch (type) {\n      case 'version-release': typePath = 'v/release';break;\n      case 'version-tag': typePath = 'v/tag';break;\n      case 'package-json': typePath = 'package-json/v';break;\n      case 'manifest-json': typePath = 'manifest-json/v';break;\n      case 'go-mod': typePath = 'go-mod/go-version';break;\n      default:break;\n    }\n    if (platform !== 'github' || !typePath) return '';\n    const baseData = [base, platform, typePath, user, repo];\n    if (/(go-mod|manifest-json|package-json)/.test(type || '') && branch) {\n      return [...baseData, branch].join('/');\n    }\n    return baseData.join('/');\n  }\n}","import Base, { BaseProps} from '../common/Base';\n\nexport interface LicenseProps extends BaseProps {\n  /**\n   * Github License\n   * \n   * `/github/license/:user/:repo`  \n   * GitHub: GitHub badge  \n   */\n  type?: 'license';\n}\n\nexport default class License extends Base<LicenseProps> {\n  constructor(props: LicenseProps) {\n    super(props, { platform: 'github', type: 'license' });\n  };\n  getUrl = () => {\n    const { type, platform, user, repo, base } = this.state;\n    if (platform !== 'github') return '';\n    return [base, platform, type, user, repo].join('/');\n  }\n}","import Base, { BaseProps} from '../common/Base';\n\nexport interface AnalysisProps extends BaseProps {\n  /**\n   * Github Analysis\n   * \n   * `/github/languages/count/:user/:repo`  \n   * GitHub language count:  GitHub language count badge \n   * \n   * `/github/search/:user/:repo/:query`  \n   * GitHub search hit counter:  GitHub search hit counter badge \n   * \n   * `/github/languages/top/:user/:repo`  \n   * GitHub top language:  GitHub top language badge \n   */\n  type?: 'languages-count' | 'languages-top' | 'search';\n  query?: string;\n}\n\nexport default class Analysis extends Base<AnalysisProps> {\n  constructor(props: AnalysisProps) {\n    super(props, { platform: 'github', type: 'languages-count' });\n  };\n  getUrl = () => {\n    const {  base, platform, type, user, repo, query } = this.state;\n    let typePath = '';\n    switch (type) {\n      case 'languages-count': typePath = 'languages/count';break;\n      case 'languages-top': typePath = 'languages/top';break;\n      case 'search': typePath = 'search';break;\n      default:break;\n    }\n    if (platform !== 'github' || !typePath) return '';\n    const baseData = [base, platform, typePath, user, repo];\n    if (query) {\n      return [...baseData, query].join('/');\n    }\n    return baseData.join('/');\n  }\n}","import Base, { BaseProps} from '../common/Base';\n\nexport interface SocialProps extends BaseProps {\n  /**\n   * Github License\n   * \n   * `/github/followers/:user?label=Follow`\n   * GitHub followers: GitHub followers badge  \n   * \n   * `/github/forks/:user/:repo?label=Fork`\n   * GitHub forks: GitHub forks badge  \n   * \n   * `/github/stars/:user/:repo?style=social`\n   * GitHub stars: GitHub stars badge  \n   * \n   * `/github/watchers/:user/:repo?label=Watch`\n   * GitHub watchers:  GitHub watchers badge \n   */\n  type?: 'followers' | 'forks' | 'stars' | 'watchers';\n}\n\nexport default class Social extends Base<SocialProps> {\n  constructor(props: SocialProps) {\n    super(props, { platform: 'github', type: 'followers' });\n  };\n  getUrl = () => {\n    const { type, platform, user, repo, base } = this.state;\n    if (platform !== 'github') return '';\n    if(type === 'followers') return [base, platform, type, user].join('/');\n    return [base, platform, type, user, repo].join('/');\n  }\n}","import Container from '../common/Container';\nimport Issues from './Issues';\nimport Size from './Size';\nimport Downloads from './Downloads';\nimport Activity from './Activity';\nimport Version from './Version';\nimport License from './License';\nimport Analysis from './Analysis';\nimport Social from './Social';\n\nexport default class Github extends Container {\n  static Issues = Issues;\n  static Size = Size;\n  static Activity = Activity;\n  static Downloads = Downloads;\n  static Version = Version;\n  static License = License;\n  static Analysis = Analysis;\n  static Social = Social;\n}","import Github from './Github';\n\nexport default Github;","import Base, { BaseProps} from '../common/Base';\n\n/**\n * NPM Version\n * \n * `/npm/v/:packageName`  \n * npm:  npm badge \n * \n * `/npm/v/:scope/:packageName`  \n * npm (scoped): npm (scoped) badge  \n * \n * `/npm/v/:packageName/:tag`  \n * npm (tag):  npm (tag) badge \n * \n * `/npm/v/:packageName/:tag?registry_uri=https%3A%2F%2Fregistry.npmjs.com`  \n * npm (custom registry):  npm (custom registry) badge \n * \n * `/npm/v/:scope/:packageName/:tag`  \n * npm (scoped with tag):  npm (scoped with tag) badge \n * \n * `/npm/dependency-version/:packageName/peer/:dependency`\n * npm peer dependency version:  npm peer dependency version badge \n * \n * `/npm/dependency-version/:scope?/:packageName/dev/:dependencyScope?/:dependency`\n * npm peer dependency version (scoped): npm peer dependency version (scoped) badge  \n * \n * `/npm/dependency-version/:packageName/dev/:dependency`\n * npm dev dependency version: npm dev dependency version badge  \n * \n * `/npm/dependency-version/:scope?/:packageName/dev/:dependencyScope?/:dependency`\n * npm dev dependency version (scoped):  npm dev dependency version (scoped) badge \n * \n * `/npm/dependency-version/:packageName/:dependency`\n * npm (prod) dependency version:  npm (prod) dependency version badge \n * \n * `/npm/dependency-version/:scope?/:packageName/:dependencyScope?/:dependency`\n * npm (prod) dependency version (scoped): npm (prod) dependency version (scoped) badge  \n * \n * `/npm/types/:packageName`\n * npm type definitions: npm type definitions badge  \n */\nexport interface VersionProps extends BaseProps {\n  type?: 'version' | 'peer-dependency' | 'dev-dependency';\n  registryUri?: string;\n  packageName?: string;\n  dependency?: string;\n  scope?: string;\n  dependencyScope?: string;\n  version?: string;\n}\n\nexport default class Version extends Base<VersionProps> {\n  constructor(props: VersionProps) {\n    super(props, { type: 'version' }, { platform: 'npm' });\n  };\n  getUrl = () => {\n    const { base, platform, type, scope, packageName, dependency, dependencyScope, version, registryUri  } = this.state;\n    if (platform !== 'npm' || !packageName) return '';\n\n    let url = '';\n    const baseData = [base, platform];\n\n    if (type === 'version' && packageName) {\n      baseData.push('v');\n      if (scope) {\n        baseData.push(scope);\n      }\n      baseData.push(packageName);\n      if (version) {\n        baseData.push(version);\n      }\n      url = baseData.join('/');\n      if (registryUri) {\n        url = `${url}?registry_uri=${registryUri}`;\n      }\n    } else if (type === 'peer-dependency' && packageName && dependency) {\n      baseData.push('dependency-version');\n      if (scope) {\n        baseData.push(scope);\n      }\n      url = [...baseData, packageName, 'peer', dependency].join('/');\n    } else if (type === 'dev-dependency' && packageName && dependency) {\n      baseData.push('dependency-version');\n      if (scope) {\n        baseData.push(scope);\n      }\n      baseData.concat([packageName, 'dev']);\n      if (dependencyScope) {\n        baseData.push(dependencyScope);\n      }\n      baseData.push(dependency);\n      url = baseData.join('/');\n    } else if (packageName && dependency) {\n      baseData.concat([packageName, dependency]);\n      url = baseData.join('/');\n    }\n\n    return url;\n  }\n}","import Base, { BaseProps} from '../common/Base';\n\nexport interface SizeProps extends BaseProps {\n  format?: 'min' | 'minzip';\n  packageName?: string;\n  scope?: string;\n  version?: string;\n}\n\n/**\n * Npm Size\n * \n * `/bundlephobia/:format/:packageName`\n * npm bundle size:  npm bundle size badge \n * \n * `/bundlephobia/:format/:scope/:packageName`\n * npm bundle size (scoped): npm bundle size (scoped) badge  \n * \n * `/bundlephobia/:format/:packageName/:version`\n * npm bundle size (version):  npm bundle size (version) badge \n * \n * `/bundlephobia/:format/:scope/:packageName/:version`\n * npm bundle size (scoped version): npm bundle size (scoped version) badge  \n * \n */\nexport default class Size extends Base<SizeProps> {\n  constructor(props: SizeProps) {\n    super(props, { format: 'min' }, { platform: 'npm' });\n  };\n  getUrl = () => {\n    const { base, platform, format, packageName, scope, version } = this.state;\n    if (platform !== 'npm') return '';\n\n    const baseData = [base, 'bundlephobia'];\n    let url = '';\n\n    if (packageName && format) {\n      url = [...baseData, format, packageName].join('/');\n    }\n    if (packageName && format && scope) {\n      url = [...baseData, format, scope, packageName].join('/');\n    }\n    if (packageName && format && scope && version) {\n      url = [...baseData, format, scope, packageName, version].join('/');\n    }\n    if (packageName && format && version) {\n      url = [...baseData, format, packageName, version].join('/');\n    }\n\n    return url;\n  }\n}","import Container from '../common/Container';\nimport Version from './Version';\nimport Size from './Size';\n\nexport default class Npm extends Container {\n  static Version = Version;\n  static Size = Size;\n}","import Npm from './Npm';\n\nexport default Npm;","import React, { useEffect, useMemo, useRef, useState } from 'react';\n\nexport interface BackToUpProps extends React.AllHTMLAttributes<HTMLDivElement> {\n  prefixCls?: string;\n  /** Scroll bar area @default document.documentElement */\n  element?: HTMLElement | null;\n  /** Whether to use smooth scrolling* @default true */\n  smooth?: boolean;\n  /** Classname to add/override styling (note, !important for overrides might be needed) */\n  className?: string;\n  /** Object to add/override styling */\n  style?: React.CSSProperties;\n  /** Height after page scroll to be visible @default 120 */\n  top?: number;\n  /** The Button width & height @default 35 */\n  size?: number;\n  /** the width of the progress bar */\n  strokeWidth?: number;\n  /** hide progress icon */\n  hideProgress?: boolean;\n}\n\nconst warpperStyle: React.CSSProperties = {\n  position: 'sticky',\n  bottom: 15,\n  right: 15,\n  visibility: 'visible',\n  opacity: 0,\n  transition: 'visibility 0.3s linear 0s, opacity 0.3s linear 0s',\n  cursor: 'pointer',\n  userSelect: 'none',\n};\n\nconst svgStyle: React.CSSProperties = {\n  display: 'block',\n  transform: 'rotate(-90deg)',\n};\n\nconst circleStyle: React.CSSProperties = {\n  transition: 'stroke-dashoffset 0.3s linear 0s',\n};\n\nconst childStyle: React.CSSProperties = {\n  position: 'absolute',\n  top: 0,\n  display: 'flex',\n  height: '100%',\n  width: '100%',\n  alignItems: 'center',\n  justifyContent: 'center',\n  color: '#fff',\n  fontSize: 12,\n};\n\nconst documentElement = document.documentElement;\n\nexport default function BackToUp(props: BackToUpProps = {}) {\n  const {\n    className,\n    prefixCls = 'w-back-to-up',\n    element = documentElement,\n    top = 120,\n    size = 35,\n    strokeWidth = 3,\n    smooth = true,\n    hideProgress = false,\n    children,\n    ...others\n  } = props;\n  const $dom = useRef<HTMLDivElement>(null);\n  const cls = [className, prefixCls].filter(Boolean).join(' ');\n  const style: React.CSSProperties = Object.assign(\n    {},\n    warpperStyle,\n    {\n      position: element === documentElement ? 'fixed' : 'sticky',\n    },\n    others.style,\n    {\n      width: size,\n      height: size,\n      opacity: top === 0 ? 1 : 0,\n    },\n  );\n  const center = useMemo(() => size / 2, [size]);\n  const radius = useMemo(() => size / 2 - strokeWidth / 2, [size, strokeWidth]);\n  const dasharray = useMemo(() => Math.PI * radius * 2, [radius]);\n  const [progress, setProgress] = useState(dasharray || 0);\n\n  const handleScroll = (ev: MouseEventInit) => {\n    const { clientHeight, scrollHeight, scrollTop } = element || documentElement;\n    const percentage = scrollTop / (scrollHeight - clientHeight);\n    setProgress(dasharray - dasharray * percentage);\n    if ($dom.current && top > 0) {\n      $dom.current.style.opacity = scrollTop > top ? '1' : '0';\n    }\n  };\n\n  useEffect(() => {\n    const scrollElement = element === documentElement ? document : element;\n    if (scrollElement) {\n      scrollElement.addEventListener('scroll', handleScroll, { passive: true });\n    }\n    return () => {\n      if (scrollElement) {\n        scrollElement.removeEventListener('scroll', handleScroll);\n      }\n    };\n  }, [element]);\n\n  const goToUp = (ev: React.MouseEvent<HTMLDivElement, MouseEvent>) => {\n    element!.scrollTo({ top: 0, behavior: smooth ? 'smooth' : 'auto' });\n  };\n\n  return (\n    <div className={cls} ref={$dom} {...others} onClick={goToUp} style={style}>\n      {!hideProgress && (\n        <svg viewBox={`0 0 ${size} ${size}`} width={size} height={size} focusable=\"false\" style={svgStyle}>\n          <circle\n            fill=\"rgb(0 0 0 / 75%)\"\n            stroke=\"rgb(200 200 200 / 85%)\"\n            strokeWidth={strokeWidth}\n            r={radius}\n            cx={center}\n            cy={center}\n          />\n          <circle\n            fill=\"none\"\n            stroke=\"rgb(0 0 0 / 50%)\"\n            strokeWidth={strokeWidth}\n            r={radius}\n            cx={center}\n            cy={center}\n            strokeDasharray={dasharray}\n            strokeDashoffset={progress}\n            style={circleStyle}\n          />\n        </svg>\n      )}\n      {children && <div style={childStyle}>{children}</div>}\n    </div>\n  );\n}\n","var _g;\nvar _excluded = [\"title\", \"titleId\"];\nfunction _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport * as React from \"react\";\nfunction SvgLogo(_ref, svgRef) {\n  var title = _ref.title,\n    titleId = _ref.titleId,\n    props = _objectWithoutProperties(_ref, _excluded);\n  return /*#__PURE__*/React.createElement(\"svg\", _extends({\n    xmlns: \"http://www.w3.org/2000/svg\",\n    viewBox: \"0 0 841.9 595.3\",\n    ref: svgRef,\n    \"aria-labelledby\": titleId\n  }, props), title ? /*#__PURE__*/React.createElement(\"title\", {\n    id: titleId\n  }, title) : null, _g || (_g = /*#__PURE__*/React.createElement(\"g\", {\n    fill: \"#61DAFB\"\n  }, /*#__PURE__*/React.createElement(\"path\", {\n    d: \"M666.3 296.5c0-32.5-40.7-63.3-103.1-82.4 14.4-63.6 8-114.2-20.2-130.4-6.5-3.8-14.1-5.6-22.4-5.6v22.3c4.6 0 8.3.9 11.4 2.6 13.6 7.8 19.5 37.5 14.9 75.7-1.1 9.4-2.9 19.3-5.1 29.4-19.6-4.8-41-8.5-63.5-10.9-13.5-18.5-27.5-35.3-41.6-50 32.6-30.3 63.2-46.9 84-46.9V78c-27.5 0-63.5 19.6-99.9 53.6-36.4-33.8-72.4-53.2-99.9-53.2v22.3c20.7 0 51.4 16.5 84 46.6-14 14.7-28 31.4-41.3 49.9-22.6 2.4-44 6.1-63.6 11-2.3-10-4-19.7-5.2-29-4.7-38.2 1.1-67.9 14.6-75.8 3-1.8 6.9-2.6 11.5-2.6V78.5c-8.4 0-16 1.8-22.6 5.6-28.1 16.2-34.4 66.7-19.9 130.1-62.2 19.2-102.7 49.9-102.7 82.3 0 32.5 40.7 63.3 103.1 82.4-14.4 63.6-8 114.2 20.2 130.4 6.5 3.8 14.1 5.6 22.5 5.6 27.5 0 63.5-19.6 99.9-53.6 36.4 33.8 72.4 53.2 99.9 53.2 8.4 0 16-1.8 22.6-5.6 28.1-16.2 34.4-66.7 19.9-130.1 62-19.1 102.5-49.9 102.5-82.3zm-130.2-66.7c-3.7 12.9-8.3 26.2-13.5 39.5-4.1-8-8.4-16-13.1-24-4.6-8-9.5-15.8-14.4-23.4 14.2 2.1 27.9 4.7 41 7.9zm-45.8 106.5c-7.8 13.5-15.8 26.3-24.1 38.2-14.9 1.3-30 2-45.2 2-15.1 0-30.2-.7-45-1.9-8.3-11.9-16.4-24.6-24.2-38-7.6-13.1-14.5-26.4-20.8-39.8 6.2-13.4 13.2-26.8 20.7-39.9 7.8-13.5 15.8-26.3 24.1-38.2 14.9-1.3 30-2 45.2-2 15.1 0 30.2.7 45 1.9 8.3 11.9 16.4 24.6 24.2 38 7.6 13.1 14.5 26.4 20.8 39.8-6.3 13.4-13.2 26.8-20.7 39.9zm32.3-13c5.4 13.4 10 26.8 13.8 39.8-13.1 3.2-26.9 5.9-41.2 8 4.9-7.7 9.8-15.6 14.4-23.7 4.6-8 8.9-16.1 13-24.1zM421.2 430c-9.3-9.6-18.6-20.3-27.8-32 9 .4 18.2.7 27.5.7 9.4 0 18.7-.2 27.8-.7-9 11.7-18.3 22.4-27.5 32zm-74.4-58.9c-14.2-2.1-27.9-4.7-41-7.9 3.7-12.9 8.3-26.2 13.5-39.5 4.1 8 8.4 16 13.1 24 4.7 8 9.5 15.8 14.4 23.4zM420.7 163c9.3 9.6 18.6 20.3 27.8 32-9-.4-18.2-.7-27.5-.7-9.4 0-18.7.2-27.8.7 9-11.7 18.3-22.4 27.5-32zm-74 58.9c-4.9 7.7-9.8 15.6-14.4 23.7-4.6 8-8.9 16-13 24-5.4-13.4-10-26.8-13.8-39.8 13.1-3.1 26.9-5.8 41.2-7.9zm-90.5 125.2c-35.4-15.1-58.3-34.9-58.3-50.6 0-15.7 22.9-35.6 58.3-50.6 8.6-3.7 18-7 27.7-10.1 5.7 19.6 13.2 40 22.5 60.9-9.2 20.8-16.6 41.1-22.2 60.6-9.9-3.1-19.3-6.5-28-10.2zM310 490c-13.6-7.8-19.5-37.5-14.9-75.7 1.1-9.4 2.9-19.3 5.1-29.4 19.6 4.8 41 8.5 63.5 10.9 13.5 18.5 27.5 35.3 41.6 50-32.6 30.3-63.2 46.9-84 46.9-4.5-.1-8.3-1-11.3-2.7zm237.2-76.2c4.7 38.2-1.1 67.9-14.6 75.8-3 1.8-6.9 2.6-11.5 2.6-20.7 0-51.4-16.5-84-46.6 14-14.7 28-31.4 41.3-49.9 22.6-2.4 44-6.1 63.6-11 2.3 10.1 4.1 19.8 5.2 29.1zm38.5-66.7c-8.6 3.7-18 7-27.7 10.1-5.7-19.6-13.2-40-22.5-60.9 9.2-20.8 16.6-41.1 22.2-60.6 9.9 3.1 19.3 6.5 28.1 10.2 35.4 15.1 58.3 34.9 58.3 50.6-.1 15.7-23 35.6-58.4 50.6zM320.8 78.4z\"\n  }), /*#__PURE__*/React.createElement(\"circle\", {\n    cx: 420.9,\n    cy: 296.5,\n    r: 45.7\n  }), /*#__PURE__*/React.createElement(\"path\", {\n    d: \"M520.5 78.1z\"\n  }))));\n}\nvar ForwardRef = /*#__PURE__*/React.forwardRef(SvgLogo);\nexport default __webpack_public_path__ + \"static/media/logo.3931a054f5ef8356122965d973d55570.svg\";\nexport { ForwardRef as ReactComponent };","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}","import defineProperty from \"./defineProperty.js\";\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\nexport default function _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n  return target;\n}","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\n/**\n * Stringify one point, a position (start and end points), or a node’s\n * positional information.\n *\n * @param {Node|NodeLike|Position|Point|null} [value]\n * @returns {string}\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point|undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position|undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number|undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\nexport class VFileMessage extends Error {\n  /**\n   * Constructor of a message for `reason` at `place` from `origin`.\n   * When an error is passed in as `reason`, copies the `stack`.\n   *\n   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).\n   * @param {string} [origin] Place in code the message originates from (`string`, optional).\n   */\n  constructor(reason, place, origin) {\n    /** @type {[string|null, string|null]} */\n    const parts = [null, null]\n    /** @type {Position} */\n    let position = {\n      // @ts-expect-error: we always follows the structure of `position`.\n      start: {line: null, column: null},\n      // @ts-expect-error: \"\n      end: {line: null, column: null}\n    }\n\n    super()\n\n    if (typeof place === 'string') {\n      origin = place\n      place = undefined\n    }\n\n    if (typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        parts[1] = origin\n      } else {\n        parts[0] = origin.slice(0, index)\n        parts[1] = origin.slice(index + 1)\n      }\n    }\n\n    if (place) {\n      // Node.\n      if ('type' in place || 'position' in place) {\n        if (place.position) {\n          position = place.position\n        }\n      }\n      // Position.\n      else if ('start' in place || 'end' in place) {\n        position = place\n      }\n      // Point.\n      else if ('line' in place || 'column' in place) {\n        position.start = place\n      }\n    }\n\n    // Fields from `Error`\n    this.name = stringifyPosition(place) || '1:1'\n    this.message = typeof reason === 'object' ? reason.message : reason\n    this.stack = typeof reason === 'object' ? reason.stack : ''\n\n    /**\n     * Reason for message.\n     * @type {string}\n     */\n    this.reason = this.message\n    /**\n     * If true, marks associated file as no longer processable.\n     * @type {boolean?}\n     */\n    // eslint-disable-next-line no-unused-expressions\n    this.fatal\n    /**\n     * Starting line of error.\n     * @type {number?}\n     */\n    this.line = position.start.line\n    /**\n     * Starting column of error.\n     * @type {number?}\n     */\n    this.column = position.start.column\n    /**\n     * Namespace of warning.\n     * @type {string?}\n     */\n    this.source = parts[0]\n    /**\n     * Category of message.\n     * @type {string?}\n     */\n    this.ruleId = parts[1]\n    /**\n     * Full range information, when available.\n     * Has start and end properties, both set to an object with line and column, set to number?.\n     * @type {Position?}\n     */\n    this.position = position\n\n    // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * You can use this to specify the source value that’s being reported, which\n     * is deemed incorrect.\n     * @type {string?}\n     */\n    this.actual\n    /**\n     * You can use this to suggest values that should be used instead of\n     * `actual`, one or more values that are deemed as acceptable.\n     * @type {Array<string>?}\n     */\n    this.expected\n    /**\n     * You may add a file property with a path of a file (used throughout the VFile ecosystem).\n     * @type {string?}\n     */\n    this.file\n    /**\n     * You may add a url property with a link to documentation for the message.\n     * @type {string?}\n     */\n    this.url\n    /**\n     * You may add a note property with a long form description of the message (supported by vfile-reporter).\n     * @type {string?}\n     */\n    this.note\n    /* eslint-enable no-unused-expressions */\n  }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\n","// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const path = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * @param {string} path\n * @param {string} [ext]\n * @returns {string}\n */\nfunction basename(path, ext) {\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  let start = 0\n  let end = -1\n  let index = path.length\n  /** @type {boolean|undefined} */\n  let seenNonSlash\n\n  if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (ext === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extIndex = ext.length - 1\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction dirname(path) {\n  assertPath(path)\n\n  if (path.length === 0) {\n    return '.'\n  }\n\n  let end = -1\n  let index = path.length\n  /** @type {boolean|undefined} */\n  let unmatchedSlash\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.charCodeAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n    ? '//'\n    : path.slice(0, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction extname(path) {\n  assertPath(path)\n\n  let index = path.length\n\n  let end = -1\n  let startPart = 0\n  let startDot = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  let preDotState = 0\n  /** @type {boolean|undefined} */\n  let unmatchedSlash\n\n  while (index--) {\n    const code = path.charCodeAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\n/**\n * @param {Array<string>} segments\n * @returns {string}\n */\nfunction join(...segments) {\n  let index = -1\n  /** @type {string|undefined} */\n  let joined\n\n  while (++index < segments.length) {\n    assertPath(segments[index])\n\n    if (segments[index]) {\n      joined =\n        joined === undefined ? segments[index] : joined + '/' + segments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Note: `normalize` is not exposed as `path.normalize`, so some code is\n * manually removed from it.\n *\n * @param {string} path\n * @returns {string}\n */\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.charCodeAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  let value = normalizeString(path, !absolute)\n\n  if (value.length === 0 && !absolute) {\n    value = '.'\n  }\n\n  if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n * @param {boolean} allowAboveRoot\n * @returns {string}\n */\nfunction normalizeString(path, allowAboveRoot) {\n  let result = ''\n  let lastSegmentLength = 0\n  let lastSlash = -1\n  let dots = 0\n  let index = -1\n  /** @type {number|undefined} */\n  let code\n  /** @type {number} */\n  let lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n          result.charCodeAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length > 0) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length > 0 ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length > 0) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\n/**\n * @param {string} path\n */\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const proc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * @param {unknown} fileURLOrPath\n * @returns {fileURLOrPath is URL}\n */\n// From: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js#L1501>\nexport function isUrl(fileURLOrPath) {\n  return (\n    fileURLOrPath !== null &&\n    typeof fileURLOrPath === 'object' &&\n    // @ts-expect-error: indexable.\n    fileURLOrPath.href &&\n    // @ts-expect-error: indexable.\n    fileURLOrPath.origin\n  )\n}\n","/// <reference lib=\"dom\" />\n\nimport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js>\n\n/**\n * @param {string|URL} path\n */\nexport function urlToPath(path) {\n  if (typeof path === 'string') {\n    path = new URL(path)\n  } else if (!isUrl(path)) {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'The \"path\" argument must be of type string or an instance of URL. Received `' +\n        path +\n        '`'\n    )\n    error.code = 'ERR_INVALID_ARG_TYPE'\n    throw error\n  }\n\n  if (path.protocol !== 'file:') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The URL must be of scheme file')\n    error.code = 'ERR_INVALID_URL_SCHEME'\n    throw error\n  }\n\n  return getPathFromURLPosix(path)\n}\n\n/**\n * @param {URL} url\n */\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== '') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'File URL host must be \"localhost\" or empty on darwin'\n    )\n    error.code = 'ERR_INVALID_FILE_URL_HOST'\n    throw error\n  }\n\n  const pathname = url.pathname\n  let index = -1\n\n  while (++index < pathname.length) {\n    if (\n      pathname.charCodeAt(index) === 37 /* `%` */ &&\n      pathname.charCodeAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.charCodeAt(index + 2)\n      if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n        /** @type {NodeJS.ErrnoException} */\n        const error = new TypeError(\n          'File URL path must not include encoded / characters'\n        )\n        error.code = 'ERR_INVALID_FILE_URL_PATH'\n        throw error\n      }\n    }\n  }\n\n  return decodeURIComponent(pathname)\n}\n\nexport {isUrl} from './minurl.shared.js'\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {Record<string, unknown> & {type: string, position?: Position|undefined}} NodeLike\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n *\n * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'base64url'|'latin1'|'binary'|'hex'} BufferEncoding\n *   Encodings supported by the buffer class.\n *   This is a copy of the typing from Node, copied to prevent Node globals from\n *   being needed.\n *   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>\n *\n * @typedef {Value|Options|VFile|URL} Compatible\n *   Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n * @property {Value} [value]\n * @property {string} [cwd]\n * @property {Array<string>} [history]\n * @property {string|URL} [path]\n * @property {string} [basename]\n * @property {string} [stem]\n * @property {string} [extname]\n * @property {string} [dirname]\n * @property {Data} [data]\n *\n * @typedef Map\n *   Raw source map, see:\n *   <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.\n * @property {number} version\n * @property {Array<string>} sources\n * @property {Array<string>} names\n * @property {string|undefined} [sourceRoot]\n * @property {Array<string>|undefined} [sourcesContent]\n * @property {string} mappings\n * @property {string} file\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n *   Configuration: a bunch of keys that will be shallow copied over to the new\n *   file.\n *\n * @typedef {Record<string, unknown>} ReporterSettings\n * @typedef {<T = ReporterSettings>(files: Array<VFile>, options: T) => string} Reporter\n */\n\nimport buffer from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\n\n// Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * If `options` is `string` or `Buffer`, it’s treated as `{value: options}`.\n   * If `options` is a `URL`, it’s treated as `{path: options}`.\n   * If `options` is a `VFile`, shallow copies its data over to the new file.\n   * All fields in `options` are set on the newly created `VFile`.\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * It’s not possible to set either `dirname` or `extname` without setting\n   * either `history`, `path`, `basename`, or `stem` as well.\n   *\n   * @param {Compatible} [value]\n   */\n  constructor(value) {\n    /** @type {Options} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (typeof value === 'string' || buffer(value)) {\n      // @ts-expect-error Looks like a buffer.\n      options = {value}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else {\n      // @ts-expect-error Looks like file or options.\n      options = value\n    }\n\n    /**\n     * Place to store custom information (default: `{}`).\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of messages associated with the file.\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * List of filepaths the file moved between.\n     * The first is the original path and the last is the current path.\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     * @type {string}\n     */\n    this.cwd = proc.cwd()\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * Raw value.\n     * @type {Value}\n     */\n    this.value\n\n    // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n\n    /**\n     * Whether a file was saved to disk.\n     * This is used by vfile reporters.\n     * @type {boolean}\n     */\n    this.stored\n\n    /**\n     * Sometimes files have a non-string, compiled, representation.\n     * This can be stored in the `result` field.\n     * One example is when turning markdown into React nodes.\n     * This is used by unified to store non-string results.\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Sometimes files have a source map associated with them.\n     * This can be stored in the `map` field.\n     * This should be a `Map` type, which is equivalent to the `RawSourceMap`\n     * type from the `source-map` module.\n     * @type {Map|undefined}\n     */\n    this.map\n    /* eslint-enable no-unused-expressions */\n\n    // Set path related properties in the correct order.\n    let index = -1\n\n    while (++index < order.length) {\n      const prop = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (prop in options && options[prop] !== undefined) {\n        // @ts-expect-error: TS is confused by the different types for `history`.\n        this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n      }\n    }\n\n    /** @type {string} */\n    let prop\n\n    // Set non-path related properties.\n    for (prop in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(prop)) this[prop] = options[prop]\n    }\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   * @returns {string}\n   */\n  get path() {\n    return this.history[this.history.length - 1]\n  }\n\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   * @param {string|URL} path\n   */\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path)\n    }\n\n    assertNonEmpty(path, 'path')\n\n    if (this.path !== path) {\n      this.history.push(path)\n    }\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   */\n  get dirname() {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   * Cannot be set if there’s no `path` yet.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = path.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   */\n  get basename() {\n    return typeof this.path === 'string' ? path.basename(this.path) : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = path.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   */\n  get extname() {\n    return typeof this.path === 'string' ? path.extname(this.path) : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.charCodeAt(0) !== 46 /* `.` */) {\n        throw new Error('`extname` must start with `.`')\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots')\n      }\n    }\n\n    this.path = path.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? path.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * @param {BufferEncoding} [encoding='utf8']\n   *   When `value` is a `Buffer`, `encoding` is a character encoding to\n   *   understand it as (default: `'utf8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    return (this.value || '').toString(encoding)\n  }\n\n  /**\n   * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and\n   * associates it with the file by adding it to `vfile.messages` and setting\n   * `message.file` to the current filepath.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(reason, place, origin) {\n    const message = new VFileMessage(reason, place, origin)\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name\n      message.file = this.path\n    }\n\n    message.fatal = false\n\n    this.messages.push(message)\n\n    return message\n  }\n\n  /**\n   * Like `VFile#message()`, but associates an informational message where\n   * `fatal` is set to `null`.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = null\n\n    return message\n  }\n\n  /**\n   * Like `VFile#message()`, but associates a fatal message where `fatal` is\n   * set to `true`, and then immediately throws it.\n   *\n   * > 👉 **Note**: a fatal error means that a file is no longer processable.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {never}\n   *   Message.\n   */\n  fail(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {void}\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(path.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {asserts part is string}\n */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string|undefined} path\n * @param {string} name\n * @returns {asserts path is string}\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _toArray(arr) {\n  return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();\n}","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error\n  }\n}\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","/**\n * @typedef {(error?: Error|null|undefined, ...output: Array<any>) => void} Callback\n * @typedef {(...input: Array<any>) => any} Middleware\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add `fn` (middleware) to the list.\n * @typedef {{run: Run, use: Use}} Pipeline\n *   Middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n */\nexport function trough() {\n  /** @type {Array<Middleware>} */\n  const fns = []\n  /** @type {Pipeline} */\n  const pipeline = {run, use}\n\n  return pipeline\n\n  /** @type {Run} */\n  function run(...values) {\n    let middlewareIndex = -1\n    /** @type {Callback} */\n    const callback = values.pop()\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('Expected function as last argument, not ' + callback)\n    }\n\n    next(null, ...values)\n\n    /**\n     * Run the next `fn`, or we’re done.\n     *\n     * @param {Error|null|undefined} error\n     * @param {Array<any>} output\n     */\n    function next(error, ...output) {\n      const fn = fns[++middlewareIndex]\n      let index = -1\n\n      if (error) {\n        callback(error)\n        return\n      }\n\n      // Copy non-nullish input into values.\n      while (++index < values.length) {\n        if (output[index] === null || output[index] === undefined) {\n          output[index] = values[index]\n        }\n      }\n\n      // Save the newly created `output` for the next call.\n      values = output\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next)(...output)\n      } else {\n        callback(null, ...output)\n      }\n    }\n  }\n\n  /** @type {Use} */\n  function use(middelware) {\n    if (typeof middelware !== 'function') {\n      throw new TypeError(\n        'Expected `middelware` to be a function, not ' + middelware\n      )\n    }\n\n    fns.push(middelware)\n    return pipeline\n  }\n}\n\n/**\n * Wrap `middleware`.\n * Can be sync or async; return a promise, receive a callback, or return new\n * values and errors.\n *\n * @param {Middleware} middleware\n * @param {Callback} callback\n */\nexport function wrap(middleware, callback) {\n  /** @type {boolean} */\n  let called\n\n  return wrapped\n\n  /**\n   * Call `middleware`.\n   * @this {any}\n   * @param {Array<any>} parameters\n   * @returns {void}\n   */\n  function wrapped(...parameters) {\n    const fnExpectsCallback = middleware.length > parameters.length\n    /** @type {any} */\n    let result\n\n    if (fnExpectsCallback) {\n      parameters.push(done)\n    }\n\n    try {\n      result = middleware.apply(this, parameters)\n    } catch (error) {\n      const exception = /** @type {Error} */ (error)\n\n      // Well, this is quite the pickle.\n      // `middleware` received a callback and called it synchronously, but that\n      // threw an error.\n      // The only thing left to do is to throw the thing instead.\n      if (fnExpectsCallback && called) {\n        throw exception\n      }\n\n      return done(exception)\n    }\n\n    if (!fnExpectsCallback) {\n      if (result instanceof Promise) {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  /**\n   * Call `callback`, only once.\n   * @type {Callback}\n   */\n  function done(error, ...output) {\n    if (!called) {\n      called = true\n      callback(error, ...output)\n    }\n  }\n\n  /**\n   * Call `done` with one value.\n   *\n   * @param {any} [value]\n   */\n  function then(value) {\n    done(null, value)\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n  const transformers = trough()\n  /** @type {Processor['attachers']} */\n  const attachers = []\n  /** @type {Record<string, unknown>} */\n  let namespace = {}\n  /** @type {boolean|undefined} */\n  let frozen\n  let freezeIndex = -1\n\n  // Data management.\n  // @ts-expect-error: overloads are handled.\n  processor.data = data\n  processor.Parser = undefined\n  processor.Compiler = undefined\n\n  // Lock.\n  processor.freeze = freeze\n\n  // Plugins.\n  processor.attachers = attachers\n  // @ts-expect-error: overloads are handled.\n  processor.use = use\n\n  // API.\n  processor.parse = parse\n  processor.stringify = stringify\n  // @ts-expect-error: overloads are handled.\n  processor.run = run\n  processor.runSync = runSync\n  // @ts-expect-error: overloads are handled.\n  processor.process = process\n  processor.processSync = processSync\n\n  // Expose.\n  return processor\n\n  // Create a new processor based on the processor in the current scope.\n  /** @type {Processor} */\n  function processor() {\n    const destination = base()\n    let index = -1\n\n    while (++index < attachers.length) {\n      destination.use(...attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  /**\n   * @param {string|Record<string, unknown>} [key]\n   * @param {unknown} [value]\n   * @returns {unknown}\n   */\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n        namespace[key] = value\n        return processor\n      }\n\n      // Get `key`.\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    // Get space.\n    return namespace\n  }\n\n  /** @type {Processor['freeze']} */\n  function freeze() {\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      const [attacher, ...options] = attachers[freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      /** @type {Transformer|void} */\n      const transformer = attacher.call(processor, ...options)\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Number.POSITIVE_INFINITY\n\n    return processor\n  }\n\n  /**\n   * @param {Pluggable|null|undefined} [value]\n   * @param {...unknown} options\n   * @returns {Processor}\n   */\n  function use(value, ...options) {\n    /** @type {Record<string, unknown>|undefined} */\n    let settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, ...options)\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`')\n    }\n\n    if (settings) {\n      namespace.settings = Object.assign(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    /**\n     * @param {import('..').Pluggable<unknown[]>} value\n     * @returns {void}\n     */\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value)\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...options] = value\n          addPlugin(plugin, ...options)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    /**\n     * @param {Preset} result\n     * @returns {void}\n     */\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = Object.assign(settings || {}, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList|null|undefined} [plugins]\n     * @returns {void}\n     */\n    function addList(plugins) {\n      let index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index]\n          add(thing)\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    /**\n     * @param {Plugin} plugin\n     * @param {...unknown} [value]\n     * @returns {void}\n     */\n    function addPlugin(plugin, value) {\n      let index = -1\n      /** @type {Processor['attachers'][number]|undefined} */\n      let entry\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entry = attachers[index]\n          break\n        }\n      }\n\n      if (entry) {\n        if (isPlainObj(entry[1]) && isPlainObj(value)) {\n          value = extend(true, entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        // @ts-expect-error: fine.\n        attachers.push([...arguments])\n      }\n    }\n  }\n\n  /** @type {Processor['parse']} */\n  function parse(doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser, 'parse')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Parser(String(file), file).parse()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  /** @type {Processor['stringify']} */\n  function stringify(node, doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler, 'compile')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Compiler(node, file).compile()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  /**\n   * @param {Node} node\n   * @param {VFileCompatible|RunCallback} [doc]\n   * @param {RunCallback} [callback]\n   * @returns {Promise<Node>|void}\n   */\n  function run(node, doc, callback) {\n    assertNode(node)\n    processor.freeze()\n\n    if (!callback && typeof doc === 'function') {\n      callback = doc\n      doc = undefined\n    }\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((node: Node) => void)} resolve\n     * @param {(error: Error) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n      transformers.run(node, vfile(doc), done)\n\n      /**\n       * @param {Error|null} error\n       * @param {Node} tree\n       * @param {VFile} file\n       * @returns {void}\n       */\n      function done(error, tree, file) {\n        tree = tree || node\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, tree, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['runSync']} */\n  function runSync(node, file) {\n    /** @type {Node|undefined} */\n    let result\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    // @ts-expect-error: we either bailed on an error or have a tree.\n    return result\n\n    /**\n     * @param {Error|null} [error]\n     * @param {Node} [tree]\n     * @returns {void}\n     */\n    function done(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * @param {VFileCompatible} doc\n   * @param {ProcessCallback} [callback]\n   * @returns {Promise<VFile>|undefined}\n   */\n  function process(doc, callback) {\n    processor.freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((file: VFile) => void)} resolve\n     * @param {(error?: Error|null|undefined) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      const file = vfile(doc)\n\n      processor.run(processor.parse(file), file, (error, tree, file) => {\n        if (error || !tree || !file) {\n          done(error)\n        } else {\n          /** @type {unknown} */\n          const result = processor.stringify(tree, file)\n\n          if (result === undefined || result === null) {\n            // Empty.\n          } else if (looksLikeAVFileValue(result)) {\n            file.value = result\n          } else {\n            file.result = result\n          }\n\n          done(error, file)\n        }\n      })\n\n      /**\n       * @param {Error|null|undefined} [error]\n       * @param {VFile|undefined} [file]\n       * @returns {void}\n       */\n      function done(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['processSync']} */\n  function processSync(doc) {\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n\n    const file = vfile(doc)\n\n    processor.process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    /**\n     * @param {Error|null|undefined} [error]\n     * @returns {void}\n     */\n    function done(error) {\n      complete = true\n      bail(error)\n    }\n  }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n  return (\n    typeof value === 'function' &&\n    // Prototypes do exist.\n    // type-coverage:ignore-next-line\n    value.prototype &&\n    // A function with keys in its prototype is probably a constructor.\n    // Classes’ prototype methods are not enumerable, so we check if some value\n    // exists in the prototype.\n    // type-coverage:ignore-next-line\n    (keys(value.prototype) || name in value.prototype)\n  )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record<string, unknown>} value\n * @returns {boolean}\n */\nfunction keys(value) {\n  /** @type {string} */\n  let key\n\n  for (key in value) {\n    if (own.call(value, key)) {\n      return true\n    }\n  }\n\n  return false\n}\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `Parser`')\n  }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `Compiler`')\n  }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot call `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`')\n    // Fine.\n  }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'message' in value &&\n      'messages' in value\n  )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n  return typeof value === 'string' || isBuffer(value)\n}\n","/**\n * @typedef Options\n * @property {boolean} [includeImageAlt=true]\n */\n\n/**\n * Get the text content of a node.\n * Prefer the node’s plain-text fields, otherwise serialize its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} node\n * @param {Options} [options]\n * @returns {string}\n */\nexport function toString(node, options) {\n  var {includeImageAlt = true} = options || {}\n  return one(node, includeImageAlt)\n}\n\n/**\n * @param {unknown} node\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\nfunction one(node, includeImageAlt) {\n  return (\n    (node &&\n      typeof node === 'object' &&\n      // @ts-ignore looks like a literal.\n      (node.value ||\n        // @ts-ignore looks like an image.\n        (includeImageAlt ? node.alt : '') ||\n        // @ts-ignore looks like a parent.\n        ('children' in node && all(node.children, includeImageAlt)) ||\n        (Array.isArray(node) && all(node, includeImageAlt)))) ||\n    ''\n  )\n}\n\n/**\n * @param {Array.<unknown>} values\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\nfunction all(values, includeImageAlt) {\n  /** @type {Array.<string>} */\n  var result = []\n  var index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt)\n  }\n\n  return result.join('')\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {number} start\n * @param {number} remove\n * @param {T[]} items\n * @returns {void}\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {unknown[]} */\n\n  let parameters // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n\n  remove = remove > 0 ? remove : 0 // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.\n    ;[].splice.apply(list, parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) [].splice.apply(list, [start, remove]) // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.\n      ;[].splice.apply(list, parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {T[]} items\n * @returns {T[]}\n */\n\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine several syntax extensions into one.\n *\n * @param {Extension[]} extensions List of syntax extensions.\n * @returns {NormalizedExtension} A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all Extension to merge into.\n * @param {Extension} extension Extension to merge.\n * @returns {void}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {string} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    for (code in right) {\n      if (!hasOwnProperty.call(left, code)) left[code] = []\n      const value = right[code]\n      constructs(\n        // @ts-expect-error Looks like a list.\n        left[code],\n        Array.isArray(value) ? value : value ? [value] : []\n      )\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {unknown[]} existing\n * @param {unknown[]} list\n * @returns {void}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {unknown[]} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine several HTML extensions into one.\n *\n * @param {HtmlExtension[]} htmlExtensions List of HTML extensions.\n * @returns {HtmlExtension} A single combined extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all Extension to merge into.\n * @param {HtmlExtension} extension Extension to merge.\n * @returns {void}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {string} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {string} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\nexport const unicodePunctuationRegex =\n  /[!-/:-@[-`{-~\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n */\n\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n */\n\nexport const asciiDigit = regexCheck(/\\d/)\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n */\n\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n */\n\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n */\n\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n */\n\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n\nexport const unicodeWhitespace = regexCheck(/\\s/)\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => code is number}\n */\n\nfunction regexCheck(regex) {\n  return check\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code Character code\n   * @returns {code is number} Whether the character code matches the bound regex\n   */\n\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownSpace} from 'micromark-util-character'\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {string} type\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n}\n/** @type {Initializer} */\n\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  /** @type {Token} */\n\n  let previous\n  return contentStart\n  /** @type {State} */\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n  /** @type {State} */\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n  /** @type {State} */\n\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    })\n\n    if (previous) {\n      previous.next = token\n    }\n\n    previous = token\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Point} Point\n */\n\n/**\n * @typedef {Record<string, unknown>} StackState\n * @typedef {[Construct, StackState]} StackItem\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\n\nexport const document = {\n  tokenize: initializeDocument\n}\n/** @type {Construct} */\n\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n}\n/** @type {Initializer} */\n\nfunction initializeDocument(effects) {\n  const self = this\n  /** @type {Array<StackItem>} */\n\n  const stack = []\n  let continued = 0\n  /** @type {TokenizeContext|undefined} */\n\n  let childFlow\n  /** @type {Token|undefined} */\n\n  let childToken\n  /** @type {number} */\n\n  let lineStartOffset\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued]\n      self.containerState = item[1]\n      return effects.attempt(\n        item[0].continuation,\n        documentContinue,\n        checkNewContainers\n      )(code)\n    } // Done.\n\n    return checkNewContainers(code)\n  }\n  /** @type {State} */\n\n  function documentContinue(code) {\n    continued++ // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined\n\n      if (childFlow) {\n        closeFlow()\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {Point|undefined} */\n\n      let point // Find the flow chunk.\n\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          point = self.events[indexBeforeFlow][1].end\n          break\n        }\n      }\n\n      exitContainers(continued) // Fix positions.\n\n      let index = indexBeforeExits\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      } // Inject the exits earlier (they’re still also at the end).\n\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      ) // Discard the duplicate exits.\n\n      self.events.length = index\n      return checkNewContainers(code)\n    }\n\n    return start(code)\n  }\n  /** @type {State} */\n\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code)\n      } // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code)\n      } // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n\n      self.interrupt = Boolean(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    } // Check if there is a new container.\n\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(code)\n  }\n  /** @type {State} */\n\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow()\n    exitContainers(continued)\n    return documentContinued(code)\n  }\n  /** @type {State} */\n\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length\n    lineStartOffset = self.now().offset\n    return flowStart(code)\n  }\n  /** @type {State} */\n\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n  /** @type {State} */\n\n  function containerContinue(code) {\n    continued++\n    stack.push([self.currentConstruct, self.containerState]) // Try another.\n\n    return documentContinued(code)\n  }\n  /** @type {State} */\n\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow()\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n  /** @type {State} */\n\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit('chunkFlow'), true)\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      writeToChild(effects.exit('chunkFlow')) // Get ready for the next line.\n\n      continued = 0\n      self.interrupt = undefined\n      return start\n    }\n\n    effects.consume(code)\n    return flowContinue\n  }\n  /**\n   * @param {Token} token\n   * @param {boolean} [eof]\n   * @returns {void}\n   */\n\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token)\n    if (eof) stream.push(null)\n    token.previous = childToken\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.defineSkip(token.start)\n    childFlow.write(stream) // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length\n\n      while (index--) {\n        if (\n          // The token starts before the line ending…\n          childFlow.events[index][1].start.offset < lineStartOffset && // …and either is not ended yet…\n          (!childFlow.events[index][1].end || // …or ends after it.\n            childFlow.events[index][1].end.offset > lineStartOffset)\n        ) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return\n        }\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {boolean|undefined} */\n\n      let seen\n      /** @type {Point|undefined} */\n\n      let point // Find the previous chunk (the one before the lazy line).\n\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end\n            break\n          }\n\n          seen = true\n        }\n      }\n\n      exitContainers(continued) // Fix positions.\n\n      index = indexBeforeExits\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      } // Inject the exits earlier (they’re still also at the end).\n\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      ) // Discard the duplicate exits.\n\n      self.events.length = index\n    }\n  }\n  /**\n   * @param {number} size\n   * @returns {void}\n   */\n\n  function exitContainers(size) {\n    let index = stack.length // Exit open containers.\n\n    while (index-- > size) {\n      const entry = stack[index]\n      self.containerState = entry[1]\n      entry[0].exit.call(self, effects)\n    }\n\n    stack.length = size\n  }\n\n  function closeFlow() {\n    childFlow.write([null])\n    childToken = undefined\n    childFlow = undefined\n    self.containerState._closeFlow = undefined\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix')\n  /** @type {State} */\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {splice} from 'micromark-util-chunked'\n\n/**\n * Tokenize subcontent.\n *\n * @param {Event[]} events\n * @returns {boolean}\n */\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {}\n  let index = -1\n  /** @type {Event} */\n\n  let event\n  /** @type {number|undefined} */\n\n  let lineIndex\n  /** @type {number} */\n\n  let otherIndex\n  /** @type {Event} */\n\n  let otherEvent\n  /** @type {Event[]} */\n\n  let parameters\n  /** @type {Event[]} */\n\n  let subevents\n  /** @type {boolean|undefined} */\n\n  let more\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n\n    event = events[index] // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    } // Enter.\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    } // Exit.\n    else if (event[1]._container) {\n      otherIndex = index\n      lineIndex = undefined\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start) // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n\n  return !more\n}\n/**\n * Tokenize embedded tokens.\n *\n * @param {Event[]} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\n\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {number[]} */\n\n  const startPositions = []\n  const tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  const childEvents = tokenizer.events\n  /** @type {[number, number][]} */\n\n  const jumps = []\n  /** @type {Record<string, number>} */\n\n  const gaps = {}\n  /** @type {Chunk[]} */\n\n  let stream\n  /** @type {Token|undefined} */\n\n  let previous\n  let index = -1\n  /** @type {Token|undefined} */\n\n  let current = token\n  let adjust = 0\n  let start = 0\n  const breaks = [start] // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {\n      // Empty.\n    }\n\n    startPositions.push(startPosition)\n\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current)\n\n      if (!current.next) {\n        stream.push(null)\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(current.start)\n      }\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n\n      tokenizer.write(stream)\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    } // Unravel the next token.\n\n    previous = current\n    current = current.next\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n  current = token\n\n  while (++index < childEvents.length) {\n    if (\n      // Find a void token that includes a break.\n      childEvents[index][0] === 'exit' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      start = index + 1\n      breaks.push(start) // Help GC.\n\n      current._tokenizer = undefined\n      current.previous = undefined\n      current = current.next\n    }\n  } // Help GC.\n\n  tokenizer.events = [] // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined\n    current.previous = undefined\n  } else {\n    breaks.pop()\n  } // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n\n  index = breaks.length\n\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1])\n    const start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\n\n  index = -1\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n\n  return gaps\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n}\n/** @type {Construct} */\n\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\n\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token} */\n  let previous\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n  /** @type {State} */\n\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous\n    })\n    previous = previous.next\n    return data\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this\n  return startLookahead\n  /** @type {State} */\n\n  function startLookahead(code) {\n    effects.exit('chunkContent')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n  /** @type {State} */\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    const tail = self.events[self.events.length - 1]\n\n    if (\n      !self.parser.constructs.disable.null.includes('codeIndented') &&\n      tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n    ) {\n      return ok(code)\n    }\n\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n}\n/** @type {Initializer} */\n\nfunction initializeFlow(effects) {\n  const self = this\n  const initial = effects.attempt(\n    // Try to parse a blank line.\n    blankLine,\n    atBlankEnding, // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n  /** @type {State} */\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n  /** @type {State} */\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nexport const resolver = {\n  resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n/**\n * @param {'string'|'text'} field\n * @returns {InitialConstruct}\n */\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n  /** @type {Initializer} */\n\n  function initializeText(effects) {\n    const self = this\n    const constructs = this.parser.constructs[field]\n    const text = effects.attempt(constructs, start, notText)\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n    /** @type {State} */\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n    /** @type {State} */\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      } // Data.\n\n      effects.consume(code)\n      return data\n    }\n    /**\n     * @param {Code} code\n     * @returns {boolean}\n     */\n\n    function atBreak(code) {\n      if (code === null) {\n        return true\n      }\n\n      const list = constructs[code]\n      let index = -1\n\n      if (list) {\n        while (++index < list.length) {\n          const item = list[index]\n\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true\n          }\n        }\n      }\n\n      return false\n    }\n  }\n}\n/**\n * @param {Resolver} [extraResolver]\n * @returns {Resolver}\n */\n\nfunction createResolver(extraResolver) {\n  return resolveAllText\n  /** @type {Resolver} */\n\n  function resolveAllText(events, context) {\n    let index = -1\n    /** @type {number|undefined} */\n\n    let enter // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index\n          index++\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end\n          events.splice(enter + 2, index - enter - 2)\n          index = enter + 2\n        }\n\n        enter = undefined\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events\n  }\n}\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\n\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0 // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\n      const data = events[eventIndex - 1][1]\n      const chunks = context.sliceStream(data)\n      let index = chunks.length\n      let bufferIndex = -1\n      let size = 0\n      /** @type {boolean|undefined} */\n\n      let tabs\n\n      while (index--) {\n        const chunk = chunks[index]\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n\n          if (bufferIndex) break\n          bufferIndex = -1\n        } // Number\n        else if (chunk === -2) {\n          tabs = true\n          size++\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++\n          break\n        }\n      }\n\n      if (size) {\n        const token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        }\n        data.end = Object.assign({}, token.start)\n\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n\n      eventIndex++\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {{resolveAll?: Resolver}[]} constructs\n * @param {Event[]} events\n * @param {TokenizeContext} context\n * @returns {Event[]}\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Resolver[]} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n */\n\n/**\n * @typedef Info\n * @property {() => void} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(\n    from\n      ? Object.assign({}, from)\n      : {\n          line: 1,\n          column: 1,\n          offset: 0\n        },\n    {\n      _index: 0,\n      _bufferIndex: -1\n    }\n  )\n  /** @type {Record<string, number>} */\n\n  const columnStart = {}\n  /** @type {Array<Construct>} */\n\n  const resolveAllConstructs = []\n  /** @type {Array<Chunk>} */\n\n  let chunks = []\n  /** @type {Array<Token>} */\n\n  let stack = []\n  /** @type {boolean|undefined} */\n\n  let consumed = true\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n\n  const effects = {\n    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  }\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n\n  const context = {\n    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  }\n  /**\n   * The state function.\n   *\n   * @type {State|void}\n   */\n\n  let state = initialize.tokenize.call(context, effects)\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n\n  let expectedCode\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  }\n\n  return context\n  /** @type {TokenizeContext['write']} */\n\n  function write(slice) {\n    chunks = push(chunks, slice)\n    main() // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n\n    addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  } //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs)\n  }\n  /** @type {TokenizeContext['sliceStream']} */\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n  /** @type {TokenizeContext['now']} */\n\n  function now() {\n    return Object.assign({}, point)\n  }\n  /** @type {TokenizeContext['defineSkip']} */\n\n  function defineSkip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  } //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {void}\n   */\n\n  function main() {\n    /** @type {number} */\n    let chunkIndex\n\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index] // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  }\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {void}\n   */\n\n  function go(code) {\n    consumed = undefined\n    expectedCode = code\n    state = state(code)\n  }\n  /** @type {Effects['consume']} */\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++\n      point.column = 1\n      point.offset += code === -3 ? 2 : 1\n      accountForPotentialSkip()\n    } else if (code !== -1) {\n      point.column++\n      point.offset++\n    } // Not in a string chunk.\n\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++ // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    } // Expose the previous character.\n\n    context.previous = code // Mark as consumed.\n\n    consumed = true\n  }\n  /** @type {Effects['enter']} */\n\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {}\n    token.type = type\n    token.start = now()\n    context.events.push(['enter', token, context])\n    stack.push(token)\n    return token\n  }\n  /** @type {Effects['exit']} */\n\n  function exit(type) {\n    const token = stack.pop()\n    token.end = now()\n    context.events.push(['exit', token, context])\n    return token\n  }\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  }\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n\n  function onsuccessfulcheck(_, info) {\n    info.restore()\n  }\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {Record<string, unknown>} [fields]\n   */\n\n  function constructFactory(onreturn, fields) {\n    return hook\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Construct|Array<Construct>|ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State} [bogusState]\n     * @returns {State}\n     */\n\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Array<Construct>} */\n      let listOfConstructs\n      /** @type {number} */\n\n      let constructIndex\n      /** @type {Construct} */\n\n      let currentConstruct\n      /** @type {Info} */\n\n      let info\n      return Array.isArray(constructs)\n        ? /* c8 ignore next 1 */\n          handleListOfConstructs(constructs)\n        : 'tokenize' in constructs // @ts-expect-error Looks like a construct.\n        ? handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n\n      function handleMapOfConstructs(map) {\n        return start\n        /** @type {State} */\n\n        function start(code) {\n          const def = code !== null && map[code]\n          const all = code !== null && map.null\n          const list = [\n            // To do: add more extension tests.\n\n            /* c8 ignore next 2 */\n            ...(Array.isArray(def) ? def : def ? [def] : []),\n            ...(Array.isArray(all) ? all : all ? [all] : [])\n          ]\n          return handleListOfConstructs(list)(code)\n        }\n      }\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Array<Construct>} list\n       * @returns {State}\n       */\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n\n        if (list.length === 0) {\n          return bogusState\n        }\n\n        return handleConstruct(list[constructIndex])\n      }\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n\n      function handleConstruct(construct) {\n        return start\n        /** @type {State} */\n\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\n            return nok(code)\n          }\n\n          return construct.tokenize.call(\n            // If we do have fields, create an object w/ `context` as its\n            // prototype.\n            // This allows a “live binding”, which is needed for `interrupt`.\n            fields ? Object.assign(Object.create(context), fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n      /** @type {State} */\n\n      function ok(code) {\n        consumed = true\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n      /** @type {State} */\n\n      function nok(code) {\n        consumed = true\n        info.restore()\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n\n        return bogusState\n      }\n    }\n  }\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {void}\n   */\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\n    }\n\n    if (construct.resolve) {\n      splice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   */\n\n  function store() {\n    const startPoint = now()\n    const startPrevious = context.previous\n    const startCurrentConstruct = context.currentConstruct\n    const startEventsIndex = context.events.length\n    const startStack = Array.from(stack)\n    return {\n      restore,\n      from: startEventsIndex\n    }\n    /**\n     * Restore state.\n     *\n     * @returns {void}\n     */\n\n    function restore() {\n      point = startPoint\n      context.previous = startPrevious\n      context.currentConstruct = startCurrentConstruct\n      context.events.length = startEventsIndex\n      stack = startStack\n      accountForPotentialSkip()\n    }\n  }\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {void}\n   */\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Array<Chunk>} chunks\n * @param {Pick<Token, 'start'|'end'>} token\n * @returns {Array<Chunk>}\n */\n\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index\n  const startBufferIndex = token.start._bufferIndex\n  const endIndex = token.end._index\n  const endBufferIndex = token.end._bufferIndex\n  /** @type {Array<Chunk>} */\n\n  let view\n\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n\n    if (startBufferIndex > -1) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view[0] = view[0].slice(startBufferIndex)\n    }\n\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n\n  return view\n}\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Array<Chunk>} chunks\n * @param {boolean} [expandTabs=false]\n * @returns {string}\n */\n\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {Array<string>} */\n\n  const result = []\n  /** @type {boolean|undefined} */\n\n  let atTab\n\n  while (++index < chunks.length) {\n    const chunk = chunks[index]\n    /** @type {string} */\n\n    let value\n\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n\n        case -4: {\n          value = '\\n'\n          break\n        }\n\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n\n        default: {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk)\n        }\n      }\n\n    atTab = chunk === -2\n    result.push(value)\n  }\n\n  return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('thematicBreak')\n    marker = code\n    return atBreak(code)\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    if (size < 3 || (code !== null && !markdownLineEnding(code))) {\n      return nok(code)\n    }\n\n    effects.exit('thematicBreak')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n\n    effects.exit('thematicBreakSequence')\n    return atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @typedef {Record<string, unknown> & {marker: Code, type: string, size: number}} ListContainerState\n * @typedef {TokenizeContext & {containerState: ListContainerState}} TokenizeContextWithState\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {asciiDigit, markdownSpace} from 'micromark-util-character'\nimport {blankLine} from './blank-line.js'\nimport {thematicBreak} from './thematic-break.js'\n/** @type {Construct} */\n\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n/** @type {Construct} */\n\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n/** @type {Construct} */\n\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n\n    return nok(code)\n  }\n  /**\n   * @type {State}\n   **/\n\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      blankLine, // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n  /** @type {State} */\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n  /** @type {State} */\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined\n      self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n\n    self.containerState.furtherBlankLines = undefined\n    self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n  /** @type {State} */\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n/**\n * @type {Exiter}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState\n\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        state.open = true\n      }\n\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(blockQuote, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n/** @type {Exiter} */\n\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} literalType\n * @param {string} literalMarkerType\n * @param {string} rawType\n * @param {string} stringType\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return destinationEnclosedBefore\n    }\n\n    if (code === null || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationRaw(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return destinationEnclosedBefore(code)\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed\n  }\n  /** @type {State} */\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return destinationEnclosed\n    }\n\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code)\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString')\n        effects.exit(stringType)\n        effects.exit(rawType)\n        effects.exit(type)\n        return ok(code)\n      }\n\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code)\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n\n    if (asciiControl(code)) return nok(code)\n    effects.consume(code)\n    return code === 92 ? destinationRawEscape : destinationRaw\n  }\n  /** @type {State} */\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    return destinationRaw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @this {TokenizeContext}\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n\n  let data\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      (code === 93 && !data) ||\n      /* To do: remove in the future once we’ve switched from\n       * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n       * which doesn’t need this */\n\n      /* Hidden footnotes hook */\n\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs) ||\n      size > 999\n    ) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return label(code)\n  }\n  /** @type {State} */\n\n  function label(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    effects.consume(code)\n    data = data || !markdownSpace(code)\n    return code === 92 ? labelEscape : label\n  }\n  /** @type {State} */\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return label\n    }\n\n    return label(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    marker = code === 40 ? 41 : code\n    return atFirstTitleBreak\n  }\n  /** @type {State} */\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    return atTitleBreak(code)\n  }\n  /** @type {State} */\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return atFirstTitleBreak(marker)\n    }\n\n    if (code === null) {\n      return nok(code)\n    } // Note: blank lines can’t exist in content.\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atTitleBreak, 'linePrefix')\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return title(code)\n  }\n  /** @type {State} */\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atTitleBreak(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? titleEscape : title\n  }\n  /** @type {State} */\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return title\n    }\n\n    return title(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n\n    return ok(code)\n  }\n}\n","/**\n * Normalize an identifier (such as used in definitions).\n *\n * @param {string} value\n * @returns {string}\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value // Collapse Markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n      .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factorySpace} from 'micromark-factory-space'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\n/** @type {Construct} */\n\nconst titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this\n  /** @type {string} */\n\n  let identifier\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('definition')\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(\n        effects,\n        factoryDestination(\n          effects,\n          effects.attempt(\n            titleConstruct,\n            factorySpace(effects, after, 'whitespace'),\n            factorySpace(effects, after, 'whitespace')\n          ),\n          nok,\n          'definitionDestination',\n          'definitionDestinationLiteral',\n          'definitionDestinationLiteralMarker',\n          'definitionDestinationRaw',\n          'definitionDestinationString'\n        )\n      )\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      if (!self.parser.defined.includes(identifier)) {\n        self.parser.defined.push(identifier)\n      }\n\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, before)(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factorySpace(effects, after, 'whitespace'),\n        nok,\n        'definitionTitle',\n        'definitionTitleMarker',\n        'definitionTitleString'\n      )(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n}\n/** @type {Construct} */\n\nconst indentedContent = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeIndented')\n    return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterStartPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? afterPrefix(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContent, afterPrefix, after)(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return content(code)\n  }\n  /** @type {State} */\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return afterPrefix(code)\n    }\n\n    effects.consume(code)\n    return content\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeIndented')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return start\n    }\n\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? ok(code)\n      : markdownLineEnding(code)\n      ? start(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n/** @type {Resolver} */\n\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2\n  let contentStart = 3\n  /** @type {Token} */\n\n  let content\n  /** @type {Token} */\n\n  let text // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  } // Suffix whitespace, part of the closing.\n\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    }\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      // @ts-expect-error Constants are fine to assign.\n      contentType: 'text'\n    }\n    splice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  const self = this\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('atxHeading')\n    effects.enter('atxHeadingSequence')\n    return fenceOpenInside(code)\n  }\n  /** @type {State} */\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return fenceOpenInside\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return self.interrupt ? ok(code) : headingBreak(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequence(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      return ok(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code)\n    }\n\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequence\n    }\n\n    effects.exit('atxHeadingSequence')\n    return headingBreak(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return headingBreak(code)\n    }\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n/** @type {Resolver} */\n\nfunction resolveToSetextUnderline(events, context) {\n  let index = events.length\n  /** @type {number|undefined} */\n\n  let content\n  /** @type {number|undefined} */\n\n  let text\n  /** @type {number|undefined} */\n\n  let definition // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  } // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText' // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = Object.assign({}, events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  } // Add the heading exit at the end.\n\n  events.push(['exit', heading, context])\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  /** @type {boolean} */\n\n  let paragraph // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (\n      self.events[index][1].type !== 'lineEnding' &&\n      self.events[index][1].type !== 'linePrefix' &&\n      self.events[index][1].type !== 'content'\n    ) {\n      paragraph = self.events[index][1].type === 'paragraph'\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      effects.enter('setextHeadingLineSequence')\n      marker = code\n      return closingSequence(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return closingSequence\n    }\n\n    effects.exit('setextHeadingLineSequence')\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)\n  }\n  /** @type {State} */\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result\n * in more relaxed rules (condition 6): because they are known blocks, the\n * HTML-like syntax doesn’t have to be strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result in\n * HTML that can include lines w/o exiting, until a closing tag also in this\n * list is found (condition 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * Note that `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'\nimport {blankLine} from './blank-line.js'\n/** @type {Construct} */\n\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\n/** @type {Construct} */\n\nconst nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n}\n/** @type {Resolver} */\n\nfunction resolveToHtmlFlow(events) {\n  let index = events.length\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start // Remove the line prefix.\n\n    events.splice(index - 2, 2)\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this\n  /** @type {number} */\n\n  let kind\n  /** @type {boolean} */\n\n  let startTag\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {Code} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationStart\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      kind = 3 // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      startTag = true\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code)\n      kind = 2\n      return commentOpenInside\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      kind = 5\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpenInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      kind = 4\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length\n        ? self.interrupt\n          ? ok\n          : continuation\n        : cdataOpenInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      if (\n        code !== 47 &&\n        startTag &&\n        htmlRawNames.includes(buffer.toLowerCase())\n      ) {\n        kind = 1\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        kind = 6\n\n        if (code === 47) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      kind = 7 // Do not support complete HTML when interrupting\n\n      return self.interrupt && !self.parser.lazy[self.now().line]\n        ? nok(code)\n        : startTag\n        ? completeAttributeNameBefore(code)\n        : completeClosingTagAfter(code)\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuation\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    return completeAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n\n    return completeAttributeNameBefore(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return completeAttributeValueQuoted\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    marker = null\n    return completeAttributeValueUnquoted(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuoted(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    if (code === marker) {\n      effects.consume(code)\n      return completeAttributeValueQuotedAfter\n    }\n\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return code === null || markdownLineEnding(code)\n      ? continuation(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code)\n      return continuationCharacterDataInside\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(\n        nextBlankConstruct,\n        continuationClose,\n        continuationAtLineEnding\n      )(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code)\n    }\n\n    effects.consume(code)\n    return continuation\n  }\n  /** @type {State} */\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData')\n    return htmlContinueStart(code)\n  }\n  /** @type {State} */\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        {\n          tokenize: htmlLineEnd,\n          partial: true\n        },\n        htmlContinueStart,\n        done\n      )(code)\n    }\n\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n  /** @type {Tokenizer} */\n\n  function htmlLineEnd(effects, ok, nok) {\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {State} */\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    } // More dashes.\n\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return done(code)\n    }\n\n    effects.consume(code)\n    return continuationClose\n  }\n  /** @type {State} */\n\n  function done(code) {\n    effects.exit('htmlFlow')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.exit('htmlFlowData')\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    return effects.attempt(blankLine, ok, nok)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this\n  /** @type {Construct} */\n\n  const closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  }\n  /** @type {Construct} */\n\n  const nonLazyLine = {\n    tokenize: tokenizeNonLazyLine,\n    partial: true\n  }\n  const tail = this.events[this.events.length - 1]\n  const initialPrefix =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let sizeOpen = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    marker = code\n    return sequenceOpen(code)\n  }\n  /** @type {State} */\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n\n    effects.exit('codeFencedFenceSequence')\n    return sizeOpen < 3\n      ? nok(code)\n      : factorySpace(effects, infoOpen, 'whitespace')(code)\n  }\n  /** @type {State} */\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n  /** @type {State} */\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, infoAfter, 'whitespace')(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return info\n  }\n  /** @type {State} */\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\n  }\n  /** @type {State} */\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceMeta')\n      return openAfter(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return meta\n  }\n  /** @type {State} */\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence')\n    return self.interrupt ? ok(code) : contentStart(code)\n  }\n  /** @type {State} */\n\n  function contentStart(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        nonLazyLine,\n        effects.attempt(\n          closingFenceConstruct,\n          after,\n          initialPrefix\n            ? factorySpace(\n                effects,\n                contentStart,\n                'linePrefix',\n                initialPrefix + 1\n              )\n            : contentStart\n        ),\n        after\n      )(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return contentContinue(code)\n  }\n  /** @type {State} */\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return contentStart(code)\n    }\n\n    effects.consume(code)\n    return contentContinue\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeNonLazyLine(effects, ok, nok) {\n    const self = this\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    let size = 0\n    return factorySpace(\n      effects,\n      closingSequenceStart,\n      'linePrefix',\n      this.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n    /** @type {State} */\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence')\n      effects.enter('codeFencedFenceSequence')\n      return closingSequence(code)\n    }\n    /** @type {State} */\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code)\n        size++\n        return closingSequence\n      }\n\n      if (size < sizeOpen) return nok(code)\n      effects.exit('codeFencedFenceSequence')\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)\n    }\n    /** @type {State} */\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n\n      return nok(code)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {\n  asciiAlphanumeric,\n  asciiDigit,\n  asciiHexDigit\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this\n  let size = 0\n  /** @type {number} */\n\n  let max\n  /** @type {(code: Code) => code is number} */\n\n  let test\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n  /** @type {State} */\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n  /** @type {State} */\n\n  function value(code) {\n    /** @type {Token} */\n    let token\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue')\n\n      if (\n        test === asciiAlphanumeric &&\n        !decodeNamedCharacterReference(self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {asciiPunctuation} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {markdownLineEndingOrSpace} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\n/** @type {Construct} */\n\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n}\n/** @type {Construct} */\n\nconst fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n}\n/** @type {Construct} */\n\nconst collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n}\n/** @type {Resolver} */\n\nfunction resolveAllLabelEnd(events) {\n  let index = -1\n  /** @type {Token} */\n\n  let token\n\n  while (++index < events.length) {\n    token = events[index][1]\n\n    if (\n      token.type === 'labelImage' ||\n      token.type === 'labelLink' ||\n      token.type === 'labelEnd'\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n\n  return events\n}\n/** @type {Resolver} */\n\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length\n  let offset = 0\n  /** @type {Token} */\n\n  let token\n  /** @type {number|undefined} */\n\n  let open\n  /** @type {number|undefined} */\n\n  let close\n  /** @type {Event[]} */\n\n  let media // Find an opening.\n\n  while (index--) {\n    token = events[index][1]\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  }\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ] // Opening marker.\n\n  media = push(media, events.slice(open + 1, open + offset + 3)) // Text open.\n\n  media = push(media, [['enter', text, context]]) // Between.\n\n  media = push(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  ) // Text close, marker close, label close.\n\n  media = push(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ]) // Reference, resource, or so.\n\n  media = push(media, events.slice(close + 1)) // Media close.\n\n  media = push(media, [['exit', group, context]])\n  splice(events, open, events.length, media)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Token} */\n\n  let labelStart\n  /** @type {boolean} */\n\n  let defined // Find an opening.\n\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code)\n    } // It’s a balanced bracket, but contains a link.\n\n    if (labelStart._inactive) return balanced(code)\n    defined = self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize({\n          start: labelStart.end,\n          end: self.now()\n        })\n      )\n    )\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return afterLabelEnd\n  }\n  /** @type {State} */\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        ok,\n        defined ? ok : balanced\n      )(code)\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(\n        fullReferenceConstruct,\n        ok,\n        defined\n          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)\n          : balanced\n      )(code)\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code)\n  }\n  /** @type {State} */\n\n  function balanced(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return factoryWhitespace(effects, open)\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 41) {\n      return end(code)\n    }\n\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      nok,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      32\n    )(code)\n  }\n  /** @type {State} */\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, between)(code)\n      : end(code)\n  }\n  /** @type {State} */\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factoryWhitespace(effects, end),\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      afterLabel,\n      nok,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function afterLabel(code) {\n    return self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    )\n      ? ok(code)\n      : nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n\n/**\n * Classify whether a character code represents whitespace, punctuation, or\n * something else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * Note that eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n * @returns {number|undefined}\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Point} Point\n */\nimport {push, splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n\nfunction resolveAllAttention(events, context) {\n  let index = -1\n  /** @type {number} */\n\n  let open\n  /** @type {Token} */\n\n  let group\n  /** @type {Token} */\n\n  let text\n  /** @type {Token} */\n\n  let openingSequence\n  /** @type {Token} */\n\n  let closingSequence\n  /** @type {number} */\n\n  let use\n  /** @type {Event[]} */\n\n  let nextEvents\n  /** @type {number} */\n\n  let offset // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open && // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          } // Number of markers to use from the sequence.\n\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\n          nextEvents = [] // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          } // Opening.\n\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ]) // Between.\n\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          ) // Closing.\n\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ]) // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = push(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n\n          splice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n  index = -1\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null\n  const previous = this.previous\n  const before = classifyCharacter(previous)\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('attentionSequence')\n    marker = code\n    return sequence(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return sequence\n    }\n\n    const token = effects.exit('attentionSequence')\n    const after = classifyCharacter(code)\n    const open =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !before || (before === 2 && after) || attentionMarkers.includes(previous)\n    token._open = Boolean(marker === 42 ? open : open && (before || !close))\n    token._close = Boolean(marker === 42 ? close : close && (after || !open))\n    return ok(code)\n  }\n}\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {void}\n */\n\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 1\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code)\n  }\n  /** @type {State} */\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)\n      ? schemeInsideOrEmailAtext(code)\n      : emailAtext(code)\n  }\n  /** @type {State} */\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return urlInside\n    }\n\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n\n    return emailAtext(code)\n  }\n  /** @type {State} */\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      return end(code)\n    }\n\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return urlInside\n  }\n  /** @type {State} */\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\n  }\n  /** @type {State} */\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      return end(code)\n    }\n\n    return emailValue(code)\n  }\n  /** @type {State} */\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code)\n      return code === 45 ? emailValue : emailLabel\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.exit('autolink')\n    return ok\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>|undefined} */\n\n  let marker\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {State} */\n\n  let returnState\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpen\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpen\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentStart\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentStartDash\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return comment\n  }\n  /** @type {State} */\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return end\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length ? cdata : cdataOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return cdata\n  }\n  /** @type {State} */\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return declaration\n  }\n  /** @type {State} */\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return instruction\n  }\n  /** @type {State} */\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return tagCloseBetween(code)\n  }\n  /** @type {State} */\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    return tagOpenAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n\n    return tagOpenBetween(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    effects.consume(code)\n    marker = undefined\n    return tagOpenAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return tagOpenAttributeValueQuotedAfter\n    }\n\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  /** @type {State} */\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(\n      effects,\n      afterPrefix,\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code)\n      effects.exit('htmlTextData')\n      effects.exit('htmlText')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n  /** @type {State} */\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook. */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker')\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n}\n/** @type {Resolver} */\n\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4\n  let headEnterIndex = 3\n  /** @type {number} */\n\n  let index\n  /** @type {number|undefined} */\n\n  let enter // If we start and end with an EOL or a space.\n\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[headEnterIndex][1].type = 'codeTextPadding'\n        events[tailExitIndex][1].type = 'codeTextPadding'\n        headEnterIndex += 2\n        tailExitIndex -= 2\n        break\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n  index = headEnterIndex - 1\n  tailExitIndex++\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n\n      enter = undefined\n    }\n  }\n\n  return events\n}\n/** @type {Previous} */\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this\n  let sizeOpen = 0\n  /** @type {number} */\n\n  let size\n  /** @type {Token} */\n\n  let token\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return openingSequence(code)\n  }\n  /** @type {State} */\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return openingSequence\n    }\n\n    effects.exit('codeTextSequence')\n    return gap(code)\n  }\n  /** @type {State} */\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    } // Closing fence?\n    // Could also be data.\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return closingSequence(code)\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return gap\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return gap\n    } // Data.\n\n    effects.enter('codeTextData')\n    return data(code)\n  } // In code.\n\n  /** @type {State} */\n\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return gap(code)\n    }\n\n    effects.consume(code)\n    return data\n  } // Closing fence.\n\n  /** @type {State} */\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return closingSequence\n    } // Done!\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    } // More or less accents: mark as data.\n\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n/** @type {Extension['document']} */\n\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n}\n/** @type {Extension['contentInitial']} */\n\nexport const contentInitial = {\n  [91]: definition\n}\n/** @type {Extension['flowInitial']} */\n\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n/** @type {Extension['flow']} */\n\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n}\n/** @type {Extension['string']} */\n\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n/** @type {Extension['text']} */\n\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n}\n/** @type {Extension['insideSpan']} */\n\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n/** @type {Extension['attentionMarkers']} */\n\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n/** @type {Extension['disable']} */\n\nexport const disable = {\n  null: []\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {boolean} [end=false]\n * @returns {Array<Chunk>}\n */\nconst search = /[\\0\\t\\n\\r]/g\n/**\n * @returns {Preprocessor}\n */\n\nexport function preprocess() {\n  let column = 1\n  let buffer = ''\n  /** @type {boolean|undefined} */\n\n  let start = true\n  /** @type {boolean|undefined} */\n\n  let atCarriageReturn\n  return preprocessor\n  /** @type {Preprocessor} */\n\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = []\n    /** @type {RegExpMatchArray|null} */\n\n    let match\n    /** @type {number} */\n\n    let next\n    /** @type {number} */\n\n    let startPosition\n    /** @type {number} */\n\n    let endPosition\n    /** @type {Code} */\n\n    let code // @ts-expect-error `Buffer` does allow an encoding.\n\n    value = buffer + value.toString(encoding)\n    startPosition = 0\n    buffer = ''\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n\n      start = undefined\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition =\n        match && match.index !== undefined ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3)\n        atCarriageReturn = undefined\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5)\n          atCarriageReturn = undefined\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n\n        switch (code) {\n          case 0: {\n            chunks.push(65533)\n            column++\n            break\n          }\n\n          case 9: {\n            next = Math.ceil(column / 4) * 4\n            chunks.push(-2)\n\n            while (column++ < next) chunks.push(-1)\n\n            break\n          }\n\n          case 10: {\n            chunks.push(-4)\n            column = 1\n            break\n          }\n\n          default: {\n            atCarriageReturn = true\n            column = 1\n          }\n        }\n      }\n\n      startPosition = endPosition + 1\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n\n    return chunks\n  }\n}\n","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base)\n\n  if (\n    // C0 except for HT, LF, FF, CR, space\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.\n    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) || // Noncharacters.\n    (code > 64975 && code < 65008) ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 || // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n\n  return String.fromCharCode(code)\n}\n","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n/**\n * Utility to decode markdown strings (which occur in places such as fenced\n * code info strings, destinations, labels, and titles).\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\n\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  } // Reference.\n\n  const head = $2.charCodeAt(0)\n\n  if (head === 35) {\n    const head = $2.charCodeAt(1)\n    const hex = head === 120 || head === 88\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n  }\n\n  return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {Root|Content} Node\n * @typedef {Extract<Node, UnistParent>} Parent\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n *\n * @typedef {UnistParent & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @typedef _CompileDataFields\n * @property {boolean|undefined} expectingFirstListItemValue\n * @property {boolean|undefined} flowCodeInside\n * @property {boolean|undefined} setextHeadingSlurpLineEnding\n * @property {boolean|undefined} atHardBreak\n * @property {'collapsed'|'full'} referenceType\n * @property {boolean|undefined} inReference\n * @property {'characterReferenceMarkerHexadecimal'|'characterReferenceMarkerNumeric'} characterReferenceType\n *\n * @typedef {Record<string, unknown> & Partial<_CompileDataFields>} CompileData\n *\n * @typedef {(tree: Root) => Root|void} Transform\n * @typedef {(this: CompileContext, token: Token) => void} Handle\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n * @typedef {Record<string, Record<string, unknown>|Array<unknown>> & {canContainEols: Array<string>, transforms: Array<Transform>, enter: Handles, exit: Handles}} NormalizedExtension\n * @typedef {Partial<NormalizedExtension>} Extension\n *   An mdast extension changes how markdown tokens are turned into mdast.\n *\n * @typedef {(this: Omit<CompileContext, 'sliceSerialize'>, left: Token|undefined, right: Token) => void} OnEnterError\n * @typedef {(this: Omit<CompileContext, 'sliceSerialize'>, left: Token, right: Token) => void} OnExitError\n *\n * @typedef CompileContext\n *   mdast compiler context\n * @property {Array<Node | Fragment>} stack\n * @property {Array<[Token, OnEnterError|undefined]>} tokenStack\n * @property {(key: string, value?: unknown) => void} setData\n *   Set data into the key-value store.\n * @property {<K extends string>(key: K) => CompileData[K]} getData\n *   Get data from the key-value store.\n * @property {(this: CompileContext) => void} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {<N extends Node>(this: CompileContext, node: N, token: Token, onError?: OnEnterError) => N} enter\n *   Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n *   Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {NormalizedExtension} config\n *   Configuration.\n *\n * @typedef {{mdastExtensions?: Array<Extension|Array<Extension>>}} FromMarkdownOptions\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n */\nimport {toString} from 'mdast-util-to-string'\nimport {parse} from 'micromark/lib/parse.js'\nimport {preprocess} from 'micromark/lib/preprocess.js'\nimport {postprocess} from 'micromark/lib/postprocess.js'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nimport {decodeString} from 'micromark-util-decode-string'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {stringifyPosition} from 'unist-util-stringify-position'\nconst own = {}.hasOwnProperty\n/**\n * @param value Markdown to parse (`string` or `Buffer`).\n * @param [encoding] Character encoding to understand `value` as when it’s a `Buffer` (`string`, default: `'utf8'`).\n * @param [options] Configuration\n */\n\nexport const fromMarkdown =\n  /**\n   * @type {(\n   *   ((value: Value, encoding: Encoding, options?: Options) => Root) &\n   *   ((value: Value, options?: Options) => Root)\n   * )}\n   */\n\n  /**\n   * @param {Value} value\n   * @param {Encoding} [encoding]\n   * @param {Options} [options]\n   * @returns {Root}\n   */\n  function (value, encoding, options) {\n    if (typeof encoding !== 'string') {\n      options = encoding\n      encoding = undefined\n    }\n\n    return compiler(options)(\n      postprocess(\n        parse(options).document().write(preprocess()(value, encoding, true))\n      )\n    )\n  }\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options} [options]\n */\n\nfunction compiler(options = {}) {\n  /** @type {NormalizedExtension} */\n  // @ts-expect-error: our base has all required fields, so the result will too.\n  const config = configure(\n    {\n      transforms: [],\n      canContainEols: [\n        'emphasis',\n        'fragment',\n        'heading',\n        'paragraph',\n        'strong'\n      ],\n      enter: {\n        autolink: opener(link),\n        autolinkProtocol: onenterdata,\n        autolinkEmail: onenterdata,\n        atxHeading: opener(heading),\n        blockQuote: opener(blockQuote),\n        characterEscape: onenterdata,\n        characterReference: onenterdata,\n        codeFenced: opener(codeFlow),\n        codeFencedFenceInfo: buffer,\n        codeFencedFenceMeta: buffer,\n        codeIndented: opener(codeFlow, buffer),\n        codeText: opener(codeText, buffer),\n        codeTextData: onenterdata,\n        data: onenterdata,\n        codeFlowValue: onenterdata,\n        definition: opener(definition),\n        definitionDestinationString: buffer,\n        definitionLabelString: buffer,\n        definitionTitleString: buffer,\n        emphasis: opener(emphasis),\n        hardBreakEscape: opener(hardBreak),\n        hardBreakTrailing: opener(hardBreak),\n        htmlFlow: opener(html, buffer),\n        htmlFlowData: onenterdata,\n        htmlText: opener(html, buffer),\n        htmlTextData: onenterdata,\n        image: opener(image),\n        label: buffer,\n        link: opener(link),\n        listItem: opener(listItem),\n        listItemValue: onenterlistitemvalue,\n        listOrdered: opener(list, onenterlistordered),\n        listUnordered: opener(list),\n        paragraph: opener(paragraph),\n        reference: onenterreference,\n        referenceString: buffer,\n        resourceDestinationString: buffer,\n        resourceTitleString: buffer,\n        setextHeading: opener(heading),\n        strong: opener(strong),\n        thematicBreak: opener(thematicBreak)\n      },\n      exit: {\n        atxHeading: closer(),\n        atxHeadingSequence: onexitatxheadingsequence,\n        autolink: closer(),\n        autolinkEmail: onexitautolinkemail,\n        autolinkProtocol: onexitautolinkprotocol,\n        blockQuote: closer(),\n        characterEscapeValue: onexitdata,\n        characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n        characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n        characterReferenceValue: onexitcharacterreferencevalue,\n        codeFenced: closer(onexitcodefenced),\n        codeFencedFence: onexitcodefencedfence,\n        codeFencedFenceInfo: onexitcodefencedfenceinfo,\n        codeFencedFenceMeta: onexitcodefencedfencemeta,\n        codeFlowValue: onexitdata,\n        codeIndented: closer(onexitcodeindented),\n        codeText: closer(onexitcodetext),\n        codeTextData: onexitdata,\n        data: onexitdata,\n        definition: closer(),\n        definitionDestinationString: onexitdefinitiondestinationstring,\n        definitionLabelString: onexitdefinitionlabelstring,\n        definitionTitleString: onexitdefinitiontitlestring,\n        emphasis: closer(),\n        hardBreakEscape: closer(onexithardbreak),\n        hardBreakTrailing: closer(onexithardbreak),\n        htmlFlow: closer(onexithtmlflow),\n        htmlFlowData: onexitdata,\n        htmlText: closer(onexithtmltext),\n        htmlTextData: onexitdata,\n        image: closer(onexitimage),\n        label: onexitlabel,\n        labelText: onexitlabeltext,\n        lineEnding: onexitlineending,\n        link: closer(onexitlink),\n        listItem: closer(),\n        listOrdered: closer(),\n        listUnordered: closer(),\n        paragraph: closer(),\n        referenceString: onexitreferencestring,\n        resourceDestinationString: onexitresourcedestinationstring,\n        resourceTitleString: onexitresourcetitlestring,\n        resource: onexitresource,\n        setextHeading: closer(onexitsetextheading),\n        setextHeadingLineSequence: onexitsetextheadinglinesequence,\n        setextHeadingText: onexitsetextheadingtext,\n        strong: closer(),\n        thematicBreak: closer()\n      }\n    },\n    options.mdastExtensions || []\n  )\n  /** @type {CompileData} */\n\n  const data = {}\n  return compile\n  /**\n   * @param {Array<Event>} events\n   * @returns {Root}\n   */\n\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    }\n    /** @type {CompileContext['stack']} */\n\n    const stack = [tree]\n    /** @type {CompileContext['tokenStack']} */\n\n    const tokenStack = []\n    /** @type {Array<number>} */\n\n    const listStack = []\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n\n    const context = {\n      stack,\n      tokenStack,\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      setData,\n      getData\n    }\n    let index = -1\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\n        if (events[index][0] === 'enter') {\n          listStack.push(index)\n        } else {\n          const tail = listStack.pop()\n          index = prepareList(events, tail, index)\n        }\n      }\n    }\n\n    index = -1\n\n    while (++index < events.length) {\n      const handler = config[events[index][0]]\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          Object.assign(\n            {\n              sliceSerialize: events[index][2].sliceSerialize\n            },\n            context\n          ),\n          events[index][1]\n        )\n      }\n    }\n\n    if (tokenStack.length > 0) {\n      const tail = tokenStack[tokenStack.length - 1]\n      const handler = tail[1] || defaultOnError\n      handler.call(context, undefined, tail[0])\n    } // Figure out `root` position.\n\n    tree.position = {\n      start: point(\n        events.length > 0\n          ? events[0][1].start\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      ),\n      end: point(\n        events.length > 0\n          ? events[events.length - 2][1].end\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      )\n    }\n    index = -1\n\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n\n    return tree\n  }\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n\n  function prepareList(events, start, length) {\n    let index = start - 1\n    let containerBalance = -1\n    let listSpread = false\n    /** @type {Token|undefined} */\n\n    let listItem\n    /** @type {number|undefined} */\n\n    let lineIndex\n    /** @type {number|undefined} */\n\n    let firstBlankLineIndex\n    /** @type {boolean|undefined} */\n\n    let atMarker\n\n    while (++index <= length) {\n      const event = events[index]\n\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          let tailIndex = index\n          lineIndex = undefined\n\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex]\n\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            // @ts-expect-error Patched.\n            listItem._spread = true\n          } // Fix position.\n\n          listItem.end = Object.assign(\n            {},\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n          index++\n          length++\n        } // Create a new list item.\n\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            // @ts-expect-error Patched\n            _spread: false,\n            start: Object.assign({}, event[1].start)\n          } // @ts-expect-error: `listItem` is most definitely defined, TS...\n\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    } // @ts-expect-error Patched.\n\n    events[start][1]._spread = listSpread\n    return length\n  }\n  /**\n   * @type {CompileContext['setData']}\n   * @param [value]\n   */\n\n  function setData(key, value) {\n    data[key] = value\n  }\n  /**\n   * @type {CompileContext['getData']}\n   * @template {string} K\n   * @param {K} key\n   * @returns {CompileData[K]}\n   */\n\n  function getData(key) {\n    return data[key]\n  }\n  /**\n   * @param {Point} d\n   * @returns {Point}\n   */\n\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    }\n  }\n  /**\n   * @param {(token: Token) => Node} create\n   * @param {Handle} [and]\n   * @returns {Handle}\n   */\n\n  function opener(create, and) {\n    return open\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n  /** @type {CompileContext['buffer']} */\n\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    })\n  }\n  /**\n   * @type {CompileContext['enter']}\n   * @template {Node} N\n   * @this {CompileContext}\n   * @param {N} node\n   * @param {Token} token\n   * @param {OnEnterError} [errorHandler]\n   * @returns {N}\n   */\n\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1]\n    // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n    parent.children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push([token, errorHandler]) // @ts-expect-error: `end` will be patched later.\n\n    node.position = {\n      start: point(token.start)\n    }\n    return node\n  }\n  /**\n   * @param {Handle} [and]\n   * @returns {Handle}\n   */\n\n  function closer(and) {\n    return close\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n  /**\n   * @type {CompileContext['exit']}\n   * @this {CompileContext}\n   * @param {Token} token\n   * @param {OnExitError} [onExitError]\n   * @returns {Node}\n   */\n\n  function exit(token, onExitError) {\n    const node = this.stack.pop()\n    const open = this.tokenStack.pop()\n\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({\n            start: token.start,\n            end: token.end\n          }) +\n          '): it’s not open'\n      )\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0])\n      } else {\n        const handler = open[1] || defaultOnError\n        handler.call(this, token, open[0])\n      }\n    }\n\n    node.position.end = point(token.end)\n    return node\n  }\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n\n  function resume() {\n    return toString(this.stack.pop())\n  } //\n  // Handlers.\n  //\n\n  /** @type {Handle} */\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n  /** @type {Handle} */\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      const ancestor =\n        /** @type {List} */\n        this.stack[this.stack.length - 2]\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)\n      setData('expectingFirstListItemValue')\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.lang = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfencemeta() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.meta = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n  /** @type {Handle} */\n\n  function onexitcodefenced() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '')\n    setData('flowCodeInside')\n  }\n  /** @type {Handle} */\n\n  function onexitcodeindented() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '')\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    const label = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitiontitlestring() {\n    const data = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.title = data\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.url = data\n  }\n  /** @type {Handle} */\n\n  function onexitatxheadingsequence(token) {\n    const node =\n      /** @type {Heading} */\n      this.stack[this.stack.length - 1]\n\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length\n      node.depth = depth\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheadinglinesequence(token) {\n    const node =\n      /** @type {Heading} */\n      this.stack[this.stack.length - 1]\n    node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n  /** @type {Handle} */\n\n  function onenterdata(token) {\n    const parent =\n      /** @type {Parent} */\n      this.stack[this.stack.length - 1]\n    /** @type {Node} */\n\n    let tail = parent.children[parent.children.length - 1]\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text() // @ts-expect-error: we’ll add `end` later.\n\n      tail.position = {\n        start: point(token.start)\n      } // @ts-expect-error: Assume `parent` accepts `text`.\n\n      parent.children.push(tail)\n    }\n\n    this.stack.push(tail)\n  }\n  /** @type {Handle} */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop()\n    tail.value += this.sliceSerialize(token)\n    tail.position.end = point(token.end)\n  }\n  /** @type {Handle} */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1]\n\n    // If we’re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      const tail = context.children[context.children.length - 1]\n      tail.position.end = point(token.end)\n      setData('atHardBreak')\n      return\n    }\n\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.includes(context.type)\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n  /** @type {Handle} */\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n  /** @type {Handle} */\n\n  function onexithtmlflow() {\n    const data = this.resume()\n    const node =\n      /** @type {HTML} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexithtmltext() {\n    const data = this.resume()\n    const node =\n      /** @type {HTML} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodetext() {\n    const data = this.resume()\n    const node =\n      /** @type {InlineCode} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexitlink() {\n    const context =\n      /** @type {Link & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference' // @ts-expect-error: mutate.\n\n      context.referenceType = getData('referenceType') || 'shortcut' // @ts-expect-error: mutate.\n\n      delete context.url\n      delete context.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete context.identifier // @ts-expect-error: mutate.\n\n      delete context.label\n    }\n\n    setData('referenceType')\n  }\n  /** @type {Handle} */\n\n  function onexitimage() {\n    const context =\n      /** @type {Image & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference' // @ts-expect-error: mutate.\n\n      context.referenceType = getData('referenceType') || 'shortcut' // @ts-expect-error: mutate.\n\n      delete context.url\n      delete context.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete context.identifier // @ts-expect-error: mutate.\n\n      delete context.label\n    }\n\n    setData('referenceType')\n  }\n  /** @type {Handle} */\n\n  function onexitlabeltext(token) {\n    const ancestor =\n      /** @type {(Link|Image) & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 2]\n    const string = this.sliceSerialize(token)\n    ancestor.label = decodeString(string)\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase()\n  }\n  /** @type {Handle} */\n\n  function onexitlabel() {\n    const fragment =\n      /** @type {Fragment} */\n      this.stack[this.stack.length - 1]\n    const value = this.resume()\n    const node =\n      /** @type {(Link|Image) & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // Assume a reference.\n\n    setData('inReference', true)\n\n    if (node.type === 'link') {\n      // @ts-expect-error: Assume static phrasing content.\n      node.children = fragment.children\n    } else {\n      node.alt = value\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume()\n    const node =\n      /** @type {Link|Image} */\n      this.stack[this.stack.length - 1]\n    node.url = data\n  }\n  /** @type {Handle} */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume()\n    const node =\n      /** @type {Link|Image} */\n      this.stack[this.stack.length - 1]\n    node.title = data\n  }\n  /** @type {Handle} */\n\n  function onexitresource() {\n    setData('inReference')\n  }\n  /** @type {Handle} */\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n  /** @type {Handle} */\n\n  function onexitreferencestring(token) {\n    const label = this.resume()\n    const node =\n      /** @type {LinkReference|ImageReference} */\n      this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n  /** @type {Handle} */\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n  /** @type {Handle} */\n\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token)\n    const type = getData('characterReferenceType')\n    /** @type {string} */\n\n    let value\n\n    if (type) {\n      value = decodeNumericCharacterReference(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n      setData('characterReferenceType')\n    } else {\n      // @ts-expect-error `decodeNamedCharacterReference` can return false for\n      // invalid named character references, but everything we’ve tokenized is\n      // valid.\n      value = decodeNamedCharacterReference(data)\n    }\n\n    const tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n  /** @type {Handle} */\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    const node =\n      /** @type {Link} */\n      this.stack[this.stack.length - 1]\n    node.url = this.sliceSerialize(token)\n  }\n  /** @type {Handle} */\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    const node =\n      /** @type {Link} */\n      this.stack[this.stack.length - 1]\n    node.url = 'mailto:' + this.sliceSerialize(token)\n  } //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    }\n  }\n  /** @returns {Code} */\n\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    }\n  }\n  /** @returns {InlineCode} */\n\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    }\n  }\n  /** @returns {Definition} */\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n  /** @returns {Emphasis} */\n\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    }\n  }\n  /** @returns {Heading} */\n\n  function heading() {\n    // @ts-expect-error `depth` will be set later.\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    }\n  }\n  /** @returns {Break} */\n\n  function hardBreak() {\n    return {\n      type: 'break'\n    }\n  }\n  /** @returns {HTML} */\n\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    }\n  }\n  /** @returns {Image} */\n\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    }\n  }\n  /** @returns {Link} */\n\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    }\n  }\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      children: []\n    }\n  }\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n  /** @returns {Paragraph} */\n\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    }\n  }\n  /** @returns {Strong} */\n\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    }\n  }\n  /** @returns {Text} */\n\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    }\n  }\n  /** @returns {ThematicBreak} */\n\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    }\n  }\n}\n/**\n * @param {Extension} combined\n * @param {Array<Extension|Array<Extension>>} extensions\n * @returns {Extension}\n */\n\nfunction configure(combined, extensions) {\n  let index = -1\n\n  while (++index < extensions.length) {\n    const value = extensions[index]\n\n    if (Array.isArray(value)) {\n      configure(combined, value)\n    } else {\n      extension(combined, value)\n    }\n  }\n\n  return combined\n}\n/**\n * @param {Extension} combined\n * @param {Extension} extension\n * @returns {void}\n */\n\nfunction extension(combined, extension) {\n  /** @type {string} */\n  let key\n\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      const list = key === 'canContainEols' || key === 'transforms'\n      const maybe = own.call(combined, key) ? combined[key] : undefined\n      /* c8 ignore next */\n\n      const left = maybe || (combined[key] = list ? [] : {})\n      const right = extension[key]\n\n      if (right) {\n        if (list) {\n          // @ts-expect-error: `left` is an array.\n          combined[key] = [...left, ...right]\n        } else {\n          Object.assign(left, right)\n        }\n      }\n    }\n  }\n}\n/** @type {OnEnterError} */\n\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error(\n      'Cannot close `' +\n        left.type +\n        '` (' +\n        stringifyPosition({\n          start: left.start,\n          end: left.end\n        }) +\n        '): a different token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is open'\n    )\n  } else {\n    throw new Error(\n      'Cannot close document, a token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is still open'\n    )\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * @param {Array<Event>} events\n * @returns {Array<Event>}\n */\n\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Create} Create\n */\nimport {combineExtensions} from 'micromark-util-combine-extensions'\nimport {content} from './initialize/content.js'\nimport {document} from './initialize/document.js'\nimport {flow} from './initialize/flow.js'\nimport {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n/**\n * @param {ParseOptions} [options]\n * @returns {ParseContext}\n */\n\nexport function parse(options = {}) {\n  /** @type {FullNormalizedExtension} */\n  // @ts-expect-error `defaultConstructs` is full, so the result will be too.\n  const constructs = combineExtensions(\n    // @ts-expect-error Same as above.\n    [defaultConstructs].concat(options.extensions || [])\n  )\n  /** @type {ParseContext} */\n\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  }\n  return parser\n  /**\n   * @param {InitialConstruct} initial\n   */\n\n  function create(initial) {\n    return creator\n    /** @type {Create} */\n\n    function creator(from) {\n      return createTokenizer(parser, initial, from)\n    }\n  }\n}\n","import remarkParse from './lib/index.js'\n\nexport default remarkParse\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */\nexport default function remarkParse(options) {\n  /** @type {import('unified').ParserFunction<Root>} */\n  const parser = (doc) => {\n    // Assume options.\n    const settings = /** @type {Options} */ (this.data('settings'))\n\n    return fromMarkdown(\n      doc,\n      Object.assign({}, settings, options, {\n        // Note: these options are not in the readme.\n        // The goal is for them to be set by plugins on `data` instead of being\n        // passed by users.\n        extensions: this.data('micromarkExtensions') || [],\n        mdastExtensions: this.data('fromMarkdownExtensions') || []\n      })\n    )\n  }\n\n  Object.assign(this, {Parser: parser})\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist').Literal} Literal\n * @typedef {Object.<string, unknown>} Props\n * @typedef {Array.<Node>|string} ChildrenOrValue\n *\n * @typedef {(<T extends string, P extends Record<string, unknown>, C extends Node[]>(type: T, props: P, children: C) => {type: T, children: C} & P)} BuildParentWithProps\n * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P, value: string) => {type: T, value: string} & P)} BuildLiteralWithProps\n * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P) => {type: T} & P)} BuildVoidWithProps\n * @typedef {(<T extends string, C extends Node[]>(type: T, children: C) => {type: T, children: C})} BuildParent\n * @typedef {(<T extends string>(type: T, value: string) => {type: T, value: string})} BuildLiteral\n * @typedef {(<T extends string>(type: T) => {type: T})} BuildVoid\n */\n\nexport var u = /**\n * @type {BuildVoid & BuildVoidWithProps & BuildLiteral & BuildLiteralWithProps & BuildParent & BuildParentWithProps}\n */ (\n  /**\n   * @param {string} type Type of node\n   * @param {Props|ChildrenOrValue} [props] Additional properties for node (or `children` or `value`)\n   * @param {ChildrenOrValue} [value] `children` or `value` of node\n   * @returns {Node}\n   */\n  function (type, props, value) {\n    /** @type {Node} */\n    var node = {type: String(type)}\n\n    if (\n      (value === undefined || value === null) &&\n      (typeof props === 'string' || Array.isArray(props))\n    ) {\n      value = props\n    } else {\n      Object.assign(node, props)\n    }\n\n    if (Array.isArray(value)) {\n      node.children = value\n    } else if (value !== undefined && value !== null) {\n      node.value = String(value)\n    }\n\n    return node\n  }\n)\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n *\n * @typedef {string} Type\n * @typedef {Object<string, unknown>} Props\n *\n * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test\n */\n\n/**\n * Check if a node passes a test\n *\n * @callback TestFunctionAnything\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean|void}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} X\n * @callback TestFunctionPredicate\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is X}\n */\n\n/**\n * @callback AssertAnything\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} Y\n * @callback AssertPredicate\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is Y}\n */\n\nexport const is =\n  /**\n   * Check if a node passes a test.\n   * When a `parent` node is known the `index` of node should also be given.\n   *\n   * @type {(\n   *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => node is T) &\n   *   ((node?: unknown, test?: Test, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * Check if a node passes a test.\n     * When a `parent` node is known the `index` of node should also be given.\n     *\n     * @param {unknown} [node] Node to check\n     * @param {Test} [test]\n     * When nullish, checks if `node` is a `Node`.\n     * When `string`, works like passing `function (node) {return node.type === test}`.\n     * When `function` checks if function passed the node is true.\n     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n     * When `array`, checks any one of the subtests pass.\n     * @param {number|null|undefined} [index] Position of `node` in `parent`\n     * @param {Parent|null|undefined} [parent] Parent of `node`\n     * @param {unknown} [context] Context object to invoke `test` with\n     * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).\n     */\n    // eslint-disable-next-line max-params\n    function is(node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      // @ts-expect-error Looks like a node.\n      return node && node.type && typeof node.type === 'string'\n        ? Boolean(check.call(context, node, index, parent))\n        : false\n    }\n  )\n\nexport const convert =\n  /**\n   * @type {(\n   *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &\n   *   ((test?: Test) => AssertAnything)\n   * )}\n   */\n  (\n    /**\n     * Generate an assertion from a check.\n     * @param {Test} [test]\n     * When nullish, checks if `node` is a `Node`.\n     * When `string`, works like passing `function (node) {return node.type === test}`.\n     * When `function` checks if function passed the node is true.\n     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n     * When `array`, checks any one of the subtests pass.\n     * @returns {AssertAnything}\n     */\n    function (test) {\n      if (test === undefined || test === null) {\n        return ok\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n/**\n * @param {Array.<Type|Props|TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n  /** @type {Array.<AssertAnything>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @param {unknown[]} parameters\n   * @returns {boolean}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].call(this, ...parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Utility to assert each property in `test` is represented in `node`, and each\n * values are strictly equal.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */\nfunction propsFactory(check) {\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      // @ts-expect-error: hush, it sure works as an index.\n      if (node[key] !== check[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n *\n * @param {Type} check\n * @returns {AssertAnything}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n  return assertion\n\n  /**\n   * @this {unknown}\n   * @param {Array.<unknown>} parameters\n   * @returns {boolean}\n   */\n  function assertion(...parameters) {\n    // @ts-expect-error: spreading is fine.\n    return Boolean(check.call(this, ...parameters))\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('./complex-types.js').Action} Action\n * @typedef {import('./complex-types.js').Index} Index\n * @typedef {import('./complex-types.js').ActionTuple} ActionTuple\n * @typedef {import('./complex-types.js').VisitorResult} VisitorResult\n * @typedef {import('./complex-types.js').Visitor} Visitor\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from './color.js'\n\n/**\n * Continue traversing as normal\n */\nexport const CONTINUE = true\n/**\n * Do not traverse this node’s children\n */\nexport const SKIP = 'skip'\n/**\n * Stop traversing immediately\n */\nexport const EXIT = false\n\n/**\n * Visit children of tree which pass test.\n *\n * @param tree\n *   Tree to walk\n * @param [test]\n *   `unist-util-is`-compatible test\n * @param visitor\n *   Function called for nodes that pass `test`.\n * @param [reverse=false]\n *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).\n */\nexport const visitParents =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {import('./complex-types.js').Visitor<Node>} visitor\n     * @param {boolean} [reverse=false]\n     */\n    function (tree, test, visitor, reverse) {\n      if (typeof test === 'function' && typeof visitor !== 'function') {\n        reverse = visitor\n        // @ts-expect-error no visitor given, so `visitor` is test.\n        visitor = test\n        test = null\n      }\n\n      const is = convert(test)\n      const step = reverse ? -1 : 1\n\n      factory(tree, null, [])()\n\n      /**\n       * @param {Node} node\n       * @param {number?} index\n       * @param {Array<Parent>} parents\n       */\n      function factory(node, index, parents) {\n        /** @type {Record<string, unknown>} */\n        // @ts-expect-error: hush\n        const value = typeof node === 'object' && node !== null ? node : {}\n        /** @type {string|undefined} */\n        let name\n\n        if (typeof value.type === 'string') {\n          name =\n            typeof value.tagName === 'string'\n              ? value.tagName\n              : typeof value.name === 'string'\n              ? value.name\n              : undefined\n\n          Object.defineProperty(visit, 'name', {\n            value:\n              'node (' +\n              color(value.type + (name ? '<' + name + '>' : '')) +\n              ')'\n          })\n        }\n\n        return visit\n\n        function visit() {\n          /** @type {ActionTuple} */\n          let result = []\n          /** @type {ActionTuple} */\n          let subresult\n          /** @type {number} */\n          let offset\n          /** @type {Array<Parent>} */\n          let grandparents\n\n          if (!test || is(node, index, parents[parents.length - 1] || null)) {\n            result = toResult(visitor(node, parents))\n\n            if (result[0] === EXIT) {\n              return result\n            }\n          }\n\n          // @ts-expect-error looks like a parent.\n          if (node.children && result[0] !== SKIP) {\n            // @ts-expect-error looks like a parent.\n            offset = (reverse ? node.children.length : -1) + step\n            // @ts-expect-error looks like a parent.\n            grandparents = parents.concat(node)\n\n            // @ts-expect-error looks like a parent.\n            while (offset > -1 && offset < node.children.length) {\n              // @ts-expect-error looks like a parent.\n              subresult = factory(node.children[offset], offset, grandparents)()\n\n              if (subresult[0] === EXIT) {\n                return subresult\n              }\n\n              offset =\n                typeof subresult[1] === 'number' ? subresult[1] : offset + step\n            }\n          }\n\n          return result\n        }\n      }\n    }\n  )\n\n/**\n * @param {VisitorResult} value\n * @returns {ActionTuple}\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return [value]\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n * @typedef {import('./complex-types.js').Visitor} Visitor\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\n/**\n * Visit children of tree which pass test.\n *\n * @param tree\n *   Tree to walk\n * @param [test]\n *   `unist-util-is`-compatible test\n * @param visitor\n *   Function called for nodes that pass `test`.\n * @param reverse\n *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).\n */\nexport const visit =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {import('./complex-types.js').Visitor} visitor\n     * @param {boolean} [reverse]\n     */\n    function (tree, test, visitor, reverse) {\n      if (typeof test === 'function' && typeof visitor !== 'function') {\n        reverse = visitor\n        visitor = test\n        test = null\n      }\n\n      visitParents(tree, test, overload, reverse)\n\n      /**\n       * @param {Node} node\n       * @param {Array<Parent>} parents\n       */\n      function overload(node, parents) {\n        const parent = parents[parents.length - 1]\n        return visitor(\n          node,\n          parent ? parent.children.indexOf(node) : null,\n          parent\n        )\n      }\n    }\n  )\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n","/**\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Node} Node\n * @typedef {Record<string, unknown> & {type: string, position?: PositionLike|undefined}} NodeLike\n * @typedef {import('unist').Point} Point\n *\n * @typedef {Partial<Point>} PointLike\n *\n * @typedef PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n */\n\nexport const pointStart = point('start')\nexport const pointEnd = point('end')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {NodeLike|Node} [node]\n * @returns {Position}\n */\nexport function position(node) {\n  return {start: pointStart(node), end: pointEnd(node)}\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'start'|'end'} type\n */\nfunction point(type) {\n  return point\n\n  /**\n   * Get the positional info of `node`.\n   *\n   * @param {NodeLike|Node} [node]\n   * @returns {Point}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    return {\n      line: point.line || null,\n      column: point.column || null,\n      offset: point.offset > -1 ? point.offset : null\n    }\n  }\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n * @typedef {import('mdast').Definition} Definition\n */\n\nimport {visit} from 'unist-util-visit'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Find definitions in `node`.\n * Uses CommonMark precedence, which means that earlier definitions are\n * preferred over duplicate later definitions.\n *\n * @param {Node} node\n */\nexport function definitions(node) {\n  /** @type {Record<string, Definition>} */\n  const cache = Object.create(null)\n\n  if (!node || !node.type) {\n    throw new Error('mdast-util-definitions expected node')\n  }\n\n  visit(node, 'definition', (definition) => {\n    const id = clean(definition.identifier)\n    if (id && !own.call(cache, id)) {\n      cache[id] = definition\n    }\n  })\n\n  return definition\n\n  /**\n   * Get a node from the bound definition cache.\n   *\n   * @param {string} identifier\n   * @returns {Definition|null}\n   */\n  function definition(identifier) {\n    const id = clean(identifier)\n    return id && own.call(cache, id) ? cache[id] : null\n  }\n}\n\n/**\n * @param {string} [value]\n * @returns {string}\n */\nfunction clean(value) {\n  return String(value || '').toUpperCase()\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('./index.js').H} H\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Transform an unknown node.\n * @type {Handler}\n * @param {MdastNode} node\n */\nfunction unknown(h, node) {\n  const data = node.data || {}\n\n  if (\n    'value' in node &&\n    !(\n      own.call(data, 'hName') ||\n      own.call(data, 'hProperties') ||\n      own.call(data, 'hChildren')\n    )\n  ) {\n    return h.augment(node, u('text', node.value))\n  }\n\n  return h(node, 'div', all(h, node))\n}\n\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\nexport function one(h, node, parent) {\n  const type = node && node.type\n  /** @type {Handler} */\n  let fn\n\n  // Fail on non-nodes.\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n\n  if (own.call(h.handlers, type)) {\n    fn = h.handlers[type]\n  } else if (h.passThrough && h.passThrough.includes(type)) {\n    fn = returnNode\n  } else {\n    fn = h.unknownHandler\n  }\n\n  return (typeof fn === 'function' ? fn : unknown)(h, node, parent)\n}\n\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\nfunction returnNode(h, node) {\n  // @ts-expect-error: Pass through custom node.\n  return 'children' in node ? {...node, children: all(h, node)} : node\n}\n\n/**\n * @param {H} h\n * @param {MdastNode} parent\n */\nexport function all(h, parent) {\n  /** @type {Array<Content>} */\n  const values = []\n\n  if ('children' in parent) {\n    const nodes = parent.children\n    let index = -1\n\n    while (++index < nodes.length) {\n      const result = one(h, nodes[index], parent)\n\n      if (result) {\n        if (index && nodes[index - 1].type === 'break') {\n          if (!Array.isArray(result) && result.type === 'text') {\n            result.value = result.value.replace(/^\\s+/, '')\n          }\n\n          if (!Array.isArray(result) && result.type === 'element') {\n            const head = result.children[0]\n\n            if (head && head.type === 'text') {\n              head.value = head.value.replace(/^\\s+/, '')\n            }\n          }\n        }\n\n        if (Array.isArray(result)) {\n          values.push(...result)\n        } else {\n          values.push(result)\n        }\n      }\n    }\n  }\n\n  return values\n}\n","import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\n\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri` below).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * Then, a regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`,\n * or `/^https?$/i` for `img[src]`.\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string|undefined} url\n * @param {RegExp} [protocol]\n * @returns {string}\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n\n  if (!protocol) {\n    return value\n  }\n\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) || // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n\n  return ''\n}\n/**\n * Normalize a URL (such as used in definitions).\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n  let start = 0\n  let skip = 0\n\n  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n\n    let replace = '' // A correct percent encoded value.\n\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    } // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    } // Astral.\n    else if (code > 55295 && code < 57344) {\n      const next = value.charCodeAt(index + 1) // A correct surrogate pair.\n\n      if (code < 56320 && next > 56319 && next < 57344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      } // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    } // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n\n  return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * Wrap `nodes` with line feeds between each entry.\n * Optionally adds line feeds at the start and end.\n *\n * @param {Array<Content>} nodes\n * @param {boolean} [loose=false]\n * @returns {Array<Content>}\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<Content>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push(u('text', '\\n'))\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push(u('text', '\\n'))\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push(u('text', '\\n'))\n  }\n\n  return result\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {FootnoteReference} node\n */\nexport function footnoteReference(h, node) {\n  const id = String(node.identifier)\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = h.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  if (index === -1) {\n    h.footnoteOrder.push(id)\n    h.footnoteCounts[id] = 1\n    counter = h.footnoteOrder.length\n  } else {\n    h.footnoteCounts[id]++\n    counter = index + 1\n  }\n\n  const reuseCounter = h.footnoteCounts[id]\n\n  return h(node, 'sup', [\n    h(\n      node.position,\n      'a',\n      {\n        href: '#' + h.clobberPrefix + 'fn-' + safeId,\n        id:\n          h.clobberPrefix +\n          'fnref-' +\n          safeId +\n          (reuseCounter > 1 ? '-' + reuseCounter : ''),\n        dataFootnoteRef: true,\n        ariaDescribedBy: 'footnote-label'\n      },\n      [u('text', String(counter))]\n    )\n  ])\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\nimport {all} from './traverse.js'\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @type {Handler}\n * @param {ImageReference|LinkReference} node\n * @returns {Content|Array<Content>}\n */\nexport function revert(h, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return u('text', '![' + node.alt + suffix)\n  }\n\n  const contents = all(h, node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift(u('text', '['))\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push(u('text', suffix))\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {ListItem} node\n * @param {List} parent\n */\nexport function listItem(h, node, parent) {\n  const result = all(h, node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const props = {}\n  /** @type {Array<Content>} */\n  const wrapped = []\n\n  if (typeof node.checked === 'boolean') {\n    /** @type {Element} */\n    let paragraph\n\n    if (\n      result[0] &&\n      result[0].type === 'element' &&\n      result[0].tagName === 'p'\n    ) {\n      paragraph = result[0]\n    } else {\n      paragraph = h(null, 'p', [])\n      result.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift(u('text', ' '))\n    }\n\n    paragraph.children.unshift(\n      h(null, 'input', {\n        type: 'checkbox',\n        checked: node.checked,\n        disabled: true\n      })\n    )\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    props.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < result.length) {\n    const child = result[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      wrapped.push(u('text', '\\n'))\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      wrapped.push(...child.children)\n    } else {\n      wrapped.push(child)\n    }\n  }\n\n  const tail = result[result.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || !('tagName' in tail) || tail.tagName !== 'p')) {\n    wrapped.push(u('text', '\\n'))\n  }\n\n  return h(node, 'li', props, wrapped)\n}\n\n/**\n * @param {List} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = node.spread\n  const children = node.children\n  let index = -1\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index])\n  }\n\n  return Boolean(loose)\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === undefined || spread === null\n    ? node.children.length > 1\n    : spread\n}\n","const tab = 9 /* `\\t` */\nconst space = 32 /* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Trimmed value.\n */\nexport function trimLines(value) {\n  const source = String(value)\n  const search = /\\r?\\n|\\r/g\n  let match = search.exec(source)\n  let last = 0\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (match) {\n    lines.push(\n      trimLine(source.slice(last, match.index), last > 0, true),\n      match[0]\n    )\n\n    last = match.index + match[0].length\n    match = search.exec(source)\n  }\n\n  lines.push(trimLine(source.slice(last), last > 0, false))\n\n  return lines.join('')\n}\n\n/**\n * @param {string} value\n *   Line to trim.\n * @param {boolean} start\n *   Whether to trim the start of the line.\n * @param {boolean} end\n *   Whether to trim the end of the line.\n * @returns {string}\n *   Trimmed line.\n */\nfunction trimLine(value, start, end) {\n  let startIndex = 0\n  let endIndex = value.length\n\n  if (start) {\n    let code = value.codePointAt(startIndex)\n\n    while (code === tab || code === space) {\n      startIndex++\n      code = value.codePointAt(startIndex)\n    }\n  }\n\n  if (end) {\n    let code = value.codePointAt(endIndex - 1)\n\n    while (code === tab || code === space) {\n      endIndex--\n      code = value.codePointAt(endIndex - 1)\n    }\n  }\n\n  return endIndex > startIndex ? value.slice(startIndex, endIndex) : ''\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {footnote} from './footnote.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  footnote,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  root,\n  strong,\n  table,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  return null\n}\n","/**\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Blockquote} node\n */\nexport function blockquote(h, node) {\n  return h(node, 'blockquote', wrap(all(h, node), true))\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Break} node\n * @returns {Array<Element|Text>}\n */\nexport function hardBreak(h, node) {\n  return [h(node, 'br'), u('text', '\\n')]\n}\n","/**\n * @typedef {import('mdast').Code} Code\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Code} node\n */\nexport function code(h, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n  // on for years in remark now.\n  const lang = node.lang && node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/)\n  /** @type {Properties} */\n  const props = {}\n\n  if (lang) {\n    props.className = ['language-' + lang]\n  }\n\n  const code = h(node, 'code', props, [u('text', value)])\n\n  if (node.meta) {\n    code.data = {meta: node.meta}\n  }\n\n  return h(node.position, 'pre', [code])\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Delete} node\n */\nexport function strikethrough(h, node) {\n  return h(node, 'del', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Emphasis} node\n */\nexport function emphasis(h, node) {\n  return h(node, 'em', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Footnote} Footnote\n * @typedef {import('../index.js').Handler} Handler\n *\n * @todo\n *   `footnote` (or “inline note”) are a pandoc footnotes feature (`^[a note]`)\n *   that does not exist in GFM.\n *   We still have support for it, so that things remain working with\n *   `micromark-extension-footnote` and `mdast-util-footnote`, but in the future\n *   we might be able to remove it?\n */\n\nimport {footnoteReference} from './footnote-reference.js'\n\n/**\n * @type {Handler}\n * @param {Footnote} node\n */\nexport function footnote(h, node) {\n  const footnoteById = h.footnoteById\n  let no = 1\n\n  while (no in footnoteById) no++\n\n  const identifier = String(no)\n\n  footnoteById[identifier] = {\n    type: 'footnoteDefinition',\n    identifier,\n    children: [{type: 'paragraph', children: node.children}],\n    position: node.position\n  }\n\n  return footnoteReference(h, {\n    type: 'footnoteReference',\n    identifier,\n    position: node.position\n  })\n}\n","/**\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Heading} node\n */\nexport function heading(h, node) {\n  return h(node, 'h' + node.depth, all(h, node))\n}\n","/**\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * Return either a `raw` node in dangerous mode, otherwise nothing.\n *\n * @type {Handler}\n * @param {HTML} node\n */\nexport function html(h, node) {\n  return h.dangerous ? h.augment(node, u('raw', node.value)) : null\n}\n","/**\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * @type {Handler}\n * @param {ImageReference} node\n */\nexport function imageReference(h, node) {\n  const def = h.definition(node.identifier)\n\n  if (!def) {\n    return revert(h, node)\n  }\n\n  /** @type {Properties} */\n  const props = {src: normalizeUri(def.url || ''), alt: node.alt}\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title\n  }\n\n  return h(node, 'img', props)\n}\n","/**\n * @typedef {import('mdast').Image} Image\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * @type {Handler}\n * @param {Image} node\n */\nexport function image(h, node) {\n  /** @type {Properties} */\n  const props = {src: normalizeUri(node.url), alt: node.alt}\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title\n  }\n\n  return h(node, 'img', props)\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {InlineCode} node\n */\nexport function inlineCode(h, node) {\n  return h(node, 'code', [u('text', node.value.replace(/\\r?\\n|\\r/g, ' '))])\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {LinkReference} node\n */\nexport function linkReference(h, node) {\n  const def = h.definition(node.identifier)\n\n  if (!def) {\n    return revert(h, node)\n  }\n\n  /** @type {Properties} */\n  const props = {href: normalizeUri(def.url || '')}\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title\n  }\n\n  return h(node, 'a', props, all(h, node))\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Link} node\n */\nexport function link(h, node) {\n  /** @type {Properties} */\n  const props = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title\n  }\n\n  return h(node, 'a', props, all(h, node))\n}\n","/**\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {List} node\n * @returns {Element}\n */\nexport function list(h, node) {\n  /** @type {Properties} */\n  const props = {}\n  const name = node.ordered ? 'ol' : 'ul'\n  const items = all(h, node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    props.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < items.length) {\n    const item = items[index]\n\n    if (\n      item.type === 'element' &&\n      item.tagName === 'li' &&\n      item.properties &&\n      Array.isArray(item.properties.className) &&\n      item.properties.className.includes('task-list-item')\n    ) {\n      props.className = ['contains-task-list']\n      break\n    }\n  }\n\n  return h(node, name, props, wrap(items, true))\n}\n","/**\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Paragraph} node\n */\nexport function paragraph(h, node) {\n  return h(node, 'p', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\nimport {all} from '../traverse.js'\nimport {wrap} from '../wrap.js'\n\n/**\n * @type {Handler}\n * @param {Root} node\n */\nexport function root(h, node) {\n  // @ts-expect-error `root`s are also fine.\n  return h.augment(node, u('root', wrap(all(h, node))))\n}\n","/**\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Strong} node\n */\nexport function strong(h, node) {\n  return h(node, 'strong', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Table} Table\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\n\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Table} node\n */\nexport function table(h, node) {\n  const rows = node.children\n  let index = -1\n  const align = node.align || []\n  /** @type {Array<Element>} */\n  const result = []\n\n  while (++index < rows.length) {\n    const row = rows[index].children\n    const name = index === 0 ? 'th' : 'td'\n    /** @type {Array<Content>} */\n    const out = []\n    let cellIndex = -1\n    const length = node.align ? align.length : row.length\n\n    while (++cellIndex < length) {\n      const cell = row[cellIndex]\n      out.push(\n        h(cell, name, {align: align[cellIndex]}, cell ? all(h, cell) : [])\n      )\n    }\n\n    result[index] = h(rows[index], 'tr', wrap(out, true))\n  }\n\n  return h(\n    node,\n    'table',\n    wrap(\n      [h(result[0].position, 'thead', wrap([result[0]], true))].concat(\n        result[1]\n          ? h(\n              {\n                start: pointStart(result[1]),\n                end: pointEnd(result[result.length - 1])\n              },\n              'tbody',\n              wrap(result.slice(1), true)\n            )\n          : []\n      ),\n      true\n    )\n  )\n}\n","/**\n * @typedef {import('mdast').Text} Text\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {trimLines} from 'trim-lines'\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Text} node\n */\nexport function text(h, node) {\n  return h.augment(node, u('text', trimLines(String(node.value))))\n}\n","/**\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n */\n\n/**\n * @type {Handler}\n * @param {ThematicBreak} [node]\n * @returns {Element}\n */\nexport function thematicBreak(h, node) {\n  return h(node, 'hr')\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('hast').Root|import('hast').Parent['children'][number]} HastNode\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} Content\n * @typedef {import('unist-util-position').PositionLike} PositionLike\n *\n * @typedef EmbeddedHastFields\n * @property {string} [hName]\n *   Defines the tag name of an element.\n * @property {Properties} [hProperties]\n *   Defines the properties of an element.\n * @property {Array<Content>} [hChildren]\n *   Defines the (hast) children of an element.\n *\n * @typedef {Record<string, unknown> & EmbeddedHastFields} Data\n *   unist data with embedded hast fields.\n *\n * @typedef {MdastNode & {data?: Data}} NodeWithData\n *   unist node with embedded hast data.\n *\n * @callback Handler\n *   Handle a node.\n * @param {H} h\n *   Handle context.\n * @param {any} node\n *   mdast node to handle.\n * @param {Parent|null} parent\n *   Parent of `node`.\n * @returns {Content|Array<Content>|null|undefined}\n *   hast node.\n *\n * @callback HFunctionProps\n * @param {MdastNode|PositionLike|null|undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {Properties} props\n *   Properties.\n * @param {Array<Content>?} [children]\n *   hast content.\n * @returns {Element}\n *   Compiled element.\n *\n * @callback HFunctionNoProps\n * @param {MdastNode|PositionLike|null|undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {Array<Content>?} [children]\n *   hast content\n * @returns {Element}\n *   Compiled element.\n *\n * @typedef HFields\n * @property {boolean} dangerous\n *   Whether HTML is allowed.\n * @property {string} clobberPrefix\n *   Prefix to use to prevent DOM clobbering.\n * @property {string} footnoteLabel\n *   Label to use to introduce the footnote section.\n * @property {string} footnoteLabelTagName\n *   HTML used for the footnote label.\n * @property {Properties} footnoteLabelProperties\n *   Properties on the HTML tag used for the footnote label.\n * @property {string} footnoteBackLabel\n *   Label to use to go back to a footnote call from the footnote section.\n * @property {(identifier: string) => Definition|null} definition\n *   Definition cache.\n * @property {Record<string, FootnoteDefinition>} footnoteById\n *   Footnote cache.\n * @property {Array<string>} footnoteOrder\n *   Order in which footnotes occur.\n * @property {Record<string, number>} footnoteCounts\n *   Counts the same footnote was used.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {Handler} unknownHandler\n *   Handler for any none not in `passThrough` or otherwise handled.\n * @property {(left: NodeWithData|PositionLike|null|undefined, right: Content) => Content} augment\n *   Like `h` but lower-level and usable on non-elements.\n * @property {Array<string>} passThrough\n *   List of node types to pass through untouched (except for their children).\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean} [allowDangerousHtml=false]\n *   Whether to allow `html` nodes and inject them as `raw` HTML.\n * @property {string} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` attribute to prevent it from *clobbering*.\n *   attributes.\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=x></p>\n *   <script>alert(x)</script>\n *   ```\n *\n *   Elements by their ID are made available in browsers on the `window` object.\n *   Using a prefix prevents this from being a problem.\n * @property {string} [footnoteLabel='Footnotes']\n *   Label to use for the footnotes section.\n *   Affects screen reader users.\n *   Change it if you’re authoring in a different language.\n * @property {string} [footnoteLabelTagName='h2']\n *   HTML tag to use for the footnote label.\n *   Can be changed to match your document structure and play well with your choice of css.\n * @property {Properties} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label.\n *   A 'sr-only' class is added by default to hide this from sighted users.\n *   Change it to make the label visible, or add classes for other purposes.\n * @property {string} [footnoteBackLabel='Back to content']\n *   Label to use from backreferences back to their footnote call.\n *   Affects screen reader users.\n *   Change it if you’re authoring in a different language.\n * @property {Handlers} [handlers]\n *   Object mapping mdast nodes to functions handling them\n * @property {Array<string>} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast\n * @property {Handler} [unknownHandler]\n *   Handler for all unknown nodes.\n *\n * @typedef {Record<string, Handler>} Handlers\n *   Map of node types to handlers\n * @typedef {HFunctionProps & HFunctionNoProps & HFields} H\n *   Handle context\n */\n\nimport {u} from 'unist-builder'\nimport {visit} from 'unist-util-visit'\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {generated} from 'unist-util-generated'\nimport {definitions} from 'mdast-util-definitions'\nimport {one} from './traverse.js'\nimport {footer} from './footer.js'\nimport {handlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Turn mdast into hast.\n *\n * @param {MdastNode} tree\n *   mdast node.\n * @param {Options} [options]\n *   Configuration (optional).\n * @returns {H}\n *   `h` function.\n */\nfunction factory(tree, options) {\n  const settings = options || {}\n  const dangerous = settings.allowDangerousHtml || false\n  /** @type {Record<string, FootnoteDefinition>} */\n  const footnoteById = {}\n\n  h.dangerous = dangerous\n  h.clobberPrefix =\n    settings.clobberPrefix === undefined || settings.clobberPrefix === null\n      ? 'user-content-'\n      : settings.clobberPrefix\n  h.footnoteLabel = settings.footnoteLabel || 'Footnotes'\n  h.footnoteLabelTagName = settings.footnoteLabelTagName || 'h2'\n  h.footnoteLabelProperties = settings.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  h.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content'\n  h.definition = definitions(tree)\n  h.footnoteById = footnoteById\n  /** @type {Array<string>} */\n  h.footnoteOrder = []\n  /** @type {Record<string, number>} */\n  h.footnoteCounts = {}\n  h.augment = augment\n  h.handlers = {...handlers, ...settings.handlers}\n  h.unknownHandler = settings.unknownHandler\n  h.passThrough = settings.passThrough\n\n  visit(tree, 'footnoteDefinition', (definition) => {\n    const id = String(definition.identifier).toUpperCase()\n\n    // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition\n    }\n  })\n\n  // @ts-expect-error Hush, it’s fine!\n  return h\n\n  /**\n   * Finalise the created `right`, a hast node, from `left`, an mdast node.\n   *\n   * @param {(NodeWithData|PositionLike)?} left\n   * @param {Content} right\n   * @returns {Content}\n   */\n  function augment(left, right) {\n    // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n    if (left && 'data' in left && left.data) {\n      /** @type {Data} */\n      const data = left.data\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          }\n        }\n\n        right.tagName = data.hName\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = {...right.properties, ...data.hProperties}\n      }\n\n      if ('children' in right && right.children && data.hChildren) {\n        right.children = data.hChildren\n      }\n    }\n\n    if (left) {\n      const ctx = 'type' in left ? left : {position: left}\n\n      if (!generated(ctx)) {\n        // @ts-expect-error: fine.\n        right.position = {start: pointStart(ctx), end: pointEnd(ctx)}\n      }\n    }\n\n    return right\n  }\n\n  /**\n   * Create an element for `node`.\n   *\n   * @type {HFunctionProps}\n   */\n  function h(node, tagName, props, children) {\n    if (Array.isArray(props)) {\n      children = props\n      props = {}\n    }\n\n    // @ts-expect-error augmenting an element yields an element.\n    return augment(node, {\n      type: 'element',\n      tagName,\n      properties: props || {},\n      children: children || []\n    })\n  }\n}\n\n/**\n * Transform `tree` (an mdast node) to a hast node.\n *\n * @param {MdastNode} tree mdast node\n * @param {Options} [options] Configuration\n * @returns {HastNode|null|undefined} hast node\n */\nexport function toHast(tree, options) {\n  const h = factory(tree, options)\n  const node = one(h, tree, null)\n  const foot = footer(h)\n\n  if (foot) {\n    // @ts-expect-error If there’s a footer, there were definitions, meaning block\n    // content.\n    // So assume `node` is a parent node.\n    node.children.push(u('text', '\\n'), foot)\n  }\n\n  return Array.isArray(node) ? {type: 'root', children: node} : node\n}\n\nexport {handlers as defaultHandlers} from './handlers/index.js'\n","/**\n * @typedef {Object} PointLike\n * @property {number} [line]\n * @property {number} [column]\n * @property {number} [offset]\n *\n * @typedef {Object} PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n *\n * @typedef {Object} NodeLike\n * @property {PositionLike} [position]\n */\n\n/**\n * Check if `node` is *generated*.\n *\n * @param {NodeLike} [node]\n * @returns {boolean}\n */\nexport function generated(node) {\n  return (\n    !node ||\n    !node.position ||\n    !node.position.start ||\n    !node.position.start.line ||\n    !node.position.start.column ||\n    !node.position.end ||\n    !node.position.end.line ||\n    !node.position.end.column\n  )\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('./index.js').H} H\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {u} from 'unist-builder'\nimport {all} from './traverse.js'\nimport {wrap} from './wrap.js'\n\n/**\n * @param {H} h\n * @returns {Element|null}\n */\nexport function footer(h) {\n  let index = -1\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n\n  while (++index < h.footnoteOrder.length) {\n    const def = h.footnoteById[h.footnoteOrder[index].toUpperCase()]\n\n    if (!def) {\n      continue\n    }\n\n    const content = all(h, def)\n    const id = String(def.identifier)\n    const safeId = normalizeUri(id.toLowerCase())\n    let referenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n\n    while (++referenceIndex <= h.footnoteCounts[id]) {\n      /** @type {Element} */\n      const backReference = {\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            h.clobberPrefix +\n            'fnref-' +\n            safeId +\n            (referenceIndex > 1 ? '-' + referenceIndex : ''),\n          dataFootnoteBackref: true,\n          className: ['data-footnote-backref'],\n          ariaLabel: h.footnoteBackLabel\n        },\n        children: [{type: 'text', value: '↩'}]\n      }\n\n      if (referenceIndex > 1) {\n        backReference.children.push({\n          type: 'element',\n          tagName: 'sup',\n          children: [{type: 'text', value: String(referenceIndex)}]\n        })\n      }\n\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      backReferences.push(backReference)\n    }\n\n    const tail = content[content.length - 1]\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1]\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' '\n      } else {\n        tail.children.push({type: 'text', value: ' '})\n      }\n\n      tail.children.push(...backReferences)\n    } else {\n      content.push(...backReferences)\n    }\n\n    /** @type {Element} */\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {id: h.clobberPrefix + 'fn-' + safeId},\n      children: wrap(content, true)\n    }\n\n    if (def.position) {\n      listItem.position = def.position\n    }\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return null\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: h.footnoteLabelTagName,\n        properties: {\n          ...JSON.parse(JSON.stringify(h.footnoteLabelProperties)),\n          id: 'footnote-label'\n        },\n        children: [u('text', h.footnoteLabel)]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('mdast-util-to-hast').Options} Options\n * @typedef {import('unified').Processor<any, any, any, any>} Processor\n *\n * @typedef {import('mdast-util-to-hast')} DoNotTouchAsThisImportIncludesRawInTree\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n// Note: the `<MdastRoot, HastRoot>` overload doesn’t seem to work :'(\n\n/**\n * Plugin that turns markdown into HTML to support rehype.\n *\n * *   If a destination processor is given, that processor runs with a new HTML\n *     (hast) tree (bridge-mode).\n *     As the given processor runs with a hast tree, and rehype plugins support\n *     hast, that means rehype plugins can be used with the given processor.\n *     The hast tree is discarded in the end.\n *     It’s highly unlikely that you want to do this.\n * *   The common case is to not pass a destination processor, in which case the\n *     current processor continues running with a new HTML (hast) tree\n *     (mutate-mode).\n *     As the current processor continues with a hast tree, and rehype plugins\n *     support hast, that means rehype plugins can be used after\n *     `remark-rehype`.\n *     It’s likely that this is what you want to do.\n *\n * @param destination\n *   Optional unified processor.\n * @param options\n *   Options passed to `mdast-util-to-hast`.\n */\nconst remarkRehype =\n  /** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */\n  (\n    function (destination, options) {\n      return destination && 'run' in destination\n        ? bridge(destination, options)\n        : mutate(destination || options)\n    }\n  )\n\nexport default remarkRehype\n\n/**\n * Bridge-mode.\n * Runs the destination with the new hast tree.\n *\n * @type {import('unified').Plugin<[Processor, Options?], MdastRoot>}\n */\nfunction bridge(destination, options) {\n  return (node, file, next) => {\n    destination.run(toHast(node, options), file, (error) => {\n      next(error)\n    })\n  }\n}\n\n/**\n * Mutate-mode.\n * Further plugins run on the hast tree.\n *\n * @type {import('unified').Plugin<[Options?]|void[], MdastRoot, HastRoot>}\n */\nfunction mutate(options) {\n  // @ts-expect-error: assume a corresponding node is returned by `toHast`.\n  return (node) => toHast(node, options)\n}\n","import {visit} from 'unist-util-visit'\n\n/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n *\n * @callback AllowElement\n * @param {Element} element\n * @param {number} index\n * @param {Element|Root} parent\n * @returns {boolean|undefined}\n *\n * @typedef Options\n * @property {Array<string>} [allowedElements]\n * @property {Array<string>} [disallowedElements=[]]\n * @property {AllowElement} [allowElement]\n * @property {boolean} [unwrapDisallowed=false]\n */\n\n/**\n * @type {import('unified').Plugin<[Options], Root>}\n */\nexport default function rehypeFilter(options) {\n  if (options.allowedElements && options.disallowedElements) {\n    throw new TypeError(\n      'Only one of `allowedElements` and `disallowedElements` should be defined'\n    )\n  }\n\n  if (\n    options.allowedElements ||\n    options.disallowedElements ||\n    options.allowElement\n  ) {\n    return (tree) => {\n      visit(tree, 'element', (node, index, parent_) => {\n        const parent = /** @type {Element|Root} */ (parent_)\n        /** @type {boolean|undefined} */\n        let remove\n\n        if (options.allowedElements) {\n          remove = !options.allowedElements.includes(node.tagName)\n        } else if (options.disallowedElements) {\n          remove = options.disallowedElements.includes(node.tagName)\n        }\n\n        if (!remove && options.allowElement && typeof index === 'number') {\n          remove = !options.allowElement(node, index, parent)\n        }\n\n        if (remove && typeof index === 'number') {\n          if (options.unwrapDisallowed && node.children) {\n            parent.children.splice(index, 1, ...node.children)\n          } else {\n            parent.children.splice(index, 1)\n          }\n\n          return index\n        }\n\n        return undefined\n      })\n    }\n  }\n}\n","const protocols = ['http', 'https', 'mailto', 'tel']\n\n/**\n * @param {string} uri\n * @returns {string}\n */\nexport function uriTransformer(uri) {\n  const url = (uri || '').trim()\n  const first = url.charAt(0)\n\n  if (first === '#' || first === '/') {\n    return url\n  }\n\n  const colon = url.indexOf(':')\n  if (colon === -1) {\n    return url\n  }\n\n  let index = -1\n\n  while (++index < protocols.length) {\n    const protocol = protocols[index]\n\n    if (\n      colon === protocol.length &&\n      url.slice(0, protocol.length).toLowerCase() === protocol\n    ) {\n      return url\n    }\n  }\n\n  index = url.indexOf('?')\n  if (index !== -1 && colon > index) {\n    return url\n  }\n\n  index = url.indexOf('#')\n  if (index !== -1 && colon > index) {\n    return url\n  }\n\n  // eslint-disable-next-line no-script-url\n  return 'javascript:void(0)'\n}\n","/**\n * @param {unknown} thing\n * @returns {boolean}\n */\nexport function whitespace(thing) {\n  /** @type {string} */\n  var value =\n    // @ts-ignore looks like a node.\n    thing && typeof thing === 'object' && thing.type === 'text'\n      ? // @ts-ignore looks like a text.\n        thing.value || ''\n      : thing\n\n  // HTML whitespace expression.\n  // See <https://html.spec.whatwg.org/#space-character>.\n  return typeof value === 'string' && value.replace(/[ \\t\\n\\f\\r]/g, '') === ''\n}\n","export const hastToReact = {\n  classId: 'classID',\n  dataType: 'datatype',\n  itemId: 'itemID',\n  strokeDashArray: 'strokeDasharray',\n  strokeDashOffset: 'strokeDashoffset',\n  strokeLineCap: 'strokeLinecap',\n  strokeLineJoin: 'strokeLinejoin',\n  strokeMiterLimit: 'strokeMiterlimit',\n  typeOf: 'typeof',\n  xLinkActuate: 'xlinkActuate',\n  xLinkArcRole: 'xlinkArcrole',\n  xLinkHref: 'xlinkHref',\n  xLinkRole: 'xlinkRole',\n  xLinkShow: 'xlinkShow',\n  xLinkTitle: 'xlinkTitle',\n  xLinkType: 'xlinkType',\n  xmlnsXLink: 'xmlnsXlink'\n}\n","/**\n * @template T\n * @typedef {import('react').ComponentType<T>} ComponentType<T>\n */\n\n/**\n * @template T\n * @typedef {import('react').ComponentPropsWithoutRef<T>} ComponentPropsWithoutRef<T>\n */\n\n/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('unist').Position} Position\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('./complex-types').ReactMarkdownProps} ReactMarkdownProps\n *\n * @typedef Raw\n * @property {'raw'} type\n * @property {string} value\n *\n * @typedef Context\n * @property {Options} options\n * @property {Schema} schema\n * @property {number} listDepth\n *\n * @callback TransformLink\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {string}\n *\n * @callback TransformImage\n * @param {string} src\n * @param {string} alt\n * @param {string?} title\n * @returns {string}\n *\n * @typedef {import('react').HTMLAttributeAnchorTarget} TransformLinkTargetType\n *\n * @callback TransformLinkTarget\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {TransformLinkTargetType|undefined}\n *\n * @typedef {keyof JSX.IntrinsicElements} ReactMarkdownNames\n *\n * To do: is `data-sourcepos` typeable?\n *\n * @typedef {ComponentPropsWithoutRef<'code'> & ReactMarkdownProps & {inline?: boolean}} CodeProps\n * @typedef {ComponentPropsWithoutRef<'h1'> & ReactMarkdownProps & {level: number}} HeadingProps\n * @typedef {ComponentPropsWithoutRef<'li'> & ReactMarkdownProps & {checked: boolean|null, index: number, ordered: boolean}} LiProps\n * @typedef {ComponentPropsWithoutRef<'ol'> & ReactMarkdownProps & {depth: number, ordered: true}} OrderedListProps\n * @typedef {ComponentPropsWithoutRef<'table'> & ReactMarkdownProps & {style?: Record<string, unknown>, isHeader: boolean}} TableCellProps\n * @typedef {ComponentPropsWithoutRef<'tr'> & ReactMarkdownProps & {isHeader: boolean}} TableRowProps\n * @typedef {ComponentPropsWithoutRef<'ul'> & ReactMarkdownProps & {depth: number, ordered: false}} UnorderedListProps\n *\n * @typedef {ComponentType<CodeProps>} CodeComponent\n * @typedef {ComponentType<HeadingProps>} HeadingComponent\n * @typedef {ComponentType<LiProps>} LiComponent\n * @typedef {ComponentType<OrderedListProps>} OrderedListComponent\n * @typedef {ComponentType<TableCellProps>} TableCellComponent\n * @typedef {ComponentType<TableRowProps>} TableRowComponent\n * @typedef {ComponentType<UnorderedListProps>} UnorderedListComponent\n *\n * @typedef SpecialComponents\n * @property {CodeComponent|ReactMarkdownNames} code\n * @property {HeadingComponent|ReactMarkdownNames} h1\n * @property {HeadingComponent|ReactMarkdownNames} h2\n * @property {HeadingComponent|ReactMarkdownNames} h3\n * @property {HeadingComponent|ReactMarkdownNames} h4\n * @property {HeadingComponent|ReactMarkdownNames} h5\n * @property {HeadingComponent|ReactMarkdownNames} h6\n * @property {LiComponent|ReactMarkdownNames} li\n * @property {OrderedListComponent|ReactMarkdownNames} ol\n * @property {TableCellComponent|ReactMarkdownNames} td\n * @property {TableCellComponent|ReactMarkdownNames} th\n * @property {TableRowComponent|ReactMarkdownNames} tr\n * @property {UnorderedListComponent|ReactMarkdownNames} ul\n *\n * @typedef {Partial<Omit<import('./complex-types').NormalComponents, keyof SpecialComponents> & SpecialComponents>} Components\n *\n * @typedef Options\n * @property {boolean} [sourcePos=false]\n * @property {boolean} [rawSourcePos=false]\n * @property {boolean} [skipHtml=false]\n * @property {boolean} [includeElementIndex=false]\n * @property {null|false|TransformLink} [transformLinkUri]\n * @property {TransformImage} [transformImageUri]\n * @property {TransformLinkTargetType|TransformLinkTarget} [linkTarget]\n * @property {Components} [components]\n */\n\nimport React from 'react'\nimport ReactIs from 'react-is'\nimport {whitespace} from 'hast-util-whitespace'\nimport {svg, find, hastToReact} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {stringify as commas} from 'comma-separated-tokens'\nimport style from 'style-to-object'\n\nconst own = {}.hasOwnProperty\n\n// The table-related elements that must not contain whitespace text according\n// to React.\nconst tableElements = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr'])\n\n/**\n * @param {Context} context\n * @param {Element|Root} node\n */\nexport function childrenToReact(context, node) {\n  /** @type {Array<ReactNode>} */\n  const children = []\n  let childIndex = -1\n  /** @type {Comment|Doctype|Element|Raw|Text} */\n  let child\n\n  while (++childIndex < node.children.length) {\n    child = node.children[childIndex]\n\n    if (child.type === 'element') {\n      children.push(toReact(context, child, childIndex, node))\n    } else if (child.type === 'text') {\n      // Currently, a warning is triggered by react for *any* white space in\n      // tables.\n      // So we drop it.\n      // See: <https://github.com/facebook/react/pull/7081>.\n      // See: <https://github.com/facebook/react/pull/7515>.\n      // See: <https://github.com/remarkjs/remark-react/issues/64>.\n      // See: <https://github.com/remarkjs/react-markdown/issues/576>.\n      if (\n        node.type !== 'element' ||\n        !tableElements.has(node.tagName) ||\n        !whitespace(child)\n      ) {\n        children.push(child.value)\n      }\n    } else if (child.type === 'raw' && !context.options.skipHtml) {\n      // Default behavior is to show (encoded) HTML.\n      children.push(child.value)\n    }\n  }\n\n  return children\n}\n\n/**\n * @param {Context} context\n * @param {Element} node\n * @param {number} index\n * @param {Element|Root} parent\n */\nfunction toReact(context, node, index, parent) {\n  const options = context.options\n  const parentSchema = context.schema\n  /** @type {ReactMarkdownNames} */\n  // @ts-expect-error assume a known HTML/SVG element.\n  const name = node.tagName\n  /** @type {Record<string, unknown>} */\n  const properties = {}\n  let schema = parentSchema\n  /** @type {string} */\n  let property\n\n  if (parentSchema.space === 'html' && name === 'svg') {\n    schema = svg\n    context.schema = schema\n  }\n\n  if (node.properties) {\n    for (property in node.properties) {\n      if (own.call(node.properties, property)) {\n        addProperty(properties, property, node.properties[property], context)\n      }\n    }\n  }\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth++\n  }\n\n  const children = childrenToReact(context, node)\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth--\n  }\n\n  // Restore parent schema.\n  context.schema = parentSchema\n\n  // Nodes created by plugins do not have positional info, in which case we use\n  // an object that matches the position interface.\n  const position = node.position || {\n    start: {line: null, column: null, offset: null},\n    end: {line: null, column: null, offset: null}\n  }\n  const component =\n    options.components && own.call(options.components, name)\n      ? options.components[name]\n      : name\n  const basic = typeof component === 'string' || component === React.Fragment\n\n  if (!ReactIs.isValidElementType(component)) {\n    throw new TypeError(\n      `Component for name \\`${name}\\` not defined or is not renderable`\n    )\n  }\n\n  properties.key = [\n    name,\n    position.start.line,\n    position.start.column,\n    index\n  ].join('-')\n\n  if (name === 'a' && options.linkTarget) {\n    properties.target =\n      typeof options.linkTarget === 'function'\n        ? options.linkTarget(\n            String(properties.href || ''),\n            node.children,\n            typeof properties.title === 'string' ? properties.title : null\n          )\n        : options.linkTarget\n  }\n\n  if (name === 'a' && options.transformLinkUri) {\n    properties.href = options.transformLinkUri(\n      String(properties.href || ''),\n      node.children,\n      typeof properties.title === 'string' ? properties.title : null\n    )\n  }\n\n  if (\n    !basic &&\n    name === 'code' &&\n    parent.type === 'element' &&\n    parent.tagName !== 'pre'\n  ) {\n    properties.inline = true\n  }\n\n  if (\n    !basic &&\n    (name === 'h1' ||\n      name === 'h2' ||\n      name === 'h3' ||\n      name === 'h4' ||\n      name === 'h5' ||\n      name === 'h6')\n  ) {\n    properties.level = Number.parseInt(name.charAt(1), 10)\n  }\n\n  if (name === 'img' && options.transformImageUri) {\n    properties.src = options.transformImageUri(\n      String(properties.src || ''),\n      String(properties.alt || ''),\n      typeof properties.title === 'string' ? properties.title : null\n    )\n  }\n\n  if (!basic && name === 'li' && parent.type === 'element') {\n    const input = getInputElement(node)\n    properties.checked =\n      input && input.properties ? Boolean(input.properties.checked) : null\n    properties.index = getElementsBeforeCount(parent, node)\n    properties.ordered = parent.tagName === 'ol'\n  }\n\n  if (!basic && (name === 'ol' || name === 'ul')) {\n    properties.ordered = name === 'ol'\n    properties.depth = context.listDepth\n  }\n\n  if (name === 'td' || name === 'th') {\n    if (properties.align) {\n      if (!properties.style) properties.style = {}\n      // @ts-expect-error assume `style` is an object\n      properties.style.textAlign = properties.align\n      delete properties.align\n    }\n\n    if (!basic) {\n      properties.isHeader = name === 'th'\n    }\n  }\n\n  if (!basic && name === 'tr' && parent.type === 'element') {\n    properties.isHeader = Boolean(parent.tagName === 'thead')\n  }\n\n  // If `sourcePos` is given, pass source information (line/column info from markdown source).\n  if (options.sourcePos) {\n    properties['data-sourcepos'] = flattenPosition(position)\n  }\n\n  if (!basic && options.rawSourcePos) {\n    properties.sourcePosition = node.position\n  }\n\n  // If `includeElementIndex` is given, pass node index info to components.\n  if (!basic && options.includeElementIndex) {\n    properties.index = getElementsBeforeCount(parent, node)\n    properties.siblingCount = getElementsBeforeCount(parent)\n  }\n\n  if (!basic) {\n    properties.node = node\n  }\n\n  // Ensure no React warnings are emitted for void elements w/ children.\n  return children.length > 0\n    ? React.createElement(component, properties, children)\n    : React.createElement(component, properties)\n}\n\n/**\n * @param {Element|Root} node\n * @returns {Element?}\n */\nfunction getInputElement(node) {\n  let index = -1\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n\n    if (child.type === 'element' && child.tagName === 'input') {\n      return child\n    }\n  }\n\n  return null\n}\n\n/**\n * @param {Element|Root} parent\n * @param {Element} [node]\n * @returns {number}\n */\nfunction getElementsBeforeCount(parent, node) {\n  let index = -1\n  let count = 0\n\n  while (++index < parent.children.length) {\n    if (parent.children[index] === node) break\n    if (parent.children[index].type === 'element') count++\n  }\n\n  return count\n}\n\n/**\n * @param {Record<string, unknown>} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n */\nfunction addProperty(props, prop, value, ctx) {\n  const info = find(ctx.schema, prop)\n  let result = value\n\n  // Ignore nullish and `NaN` values.\n  // eslint-disable-next-line no-self-compare\n  if (result === null || result === undefined || result !== result) {\n    return\n  }\n\n  // Accept `array`.\n  // Most props are space-separated.\n  if (Array.isArray(result)) {\n    result = info.commaSeparated ? commas(result) : spaces(result)\n  }\n\n  if (info.property === 'style' && typeof result === 'string') {\n    result = parseStyle(result)\n  }\n\n  if (info.space && info.property) {\n    props[\n      own.call(hastToReact, info.property)\n        ? hastToReact[info.property]\n        : info.property\n    ] = result\n  } else if (info.attribute) {\n    props[info.attribute] = result\n  }\n}\n\n/**\n * @param {string} value\n * @returns {Record<string, string>}\n */\nfunction parseStyle(value) {\n  /** @type {Record<string, string>} */\n  const result = {}\n\n  try {\n    style(value, iterator)\n  } catch {\n    // Silent.\n  }\n\n  return result\n\n  /**\n   * @param {string} name\n   * @param {string} v\n   */\n  function iterator(name, v) {\n    const k = name.slice(0, 4) === '-ms-' ? `ms-${name.slice(4)}` : name\n    result[k.replace(/-([a-z])/g, styleReplacer)] = v\n  }\n}\n\n/**\n * @param {unknown} _\n * @param {string} $1\n */\nfunction styleReplacer(_, $1) {\n  return $1.toUpperCase()\n}\n\n/**\n * @param {Position|{start: {line: null, column: null, offset: null}, end: {line: null, column: null, offset: null}}} pos\n * @returns {string}\n */\nfunction flattenPosition(pos) {\n  return [\n    pos.start.line,\n    ':',\n    pos.start.column,\n    '-',\n    pos.end.line,\n    ':',\n    pos.end.column\n  ]\n    .map((d) => String(d))\n    .join('')\n}\n","/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('react').ReactElement<{}>} ReactElement\n * @typedef {import('unified').PluggableList} PluggableList\n * @typedef {import('hast').Root} Root\n * @typedef {import('./rehype-filter.js').Options} FilterOptions\n * @typedef {import('./ast-to-react.js').Options} TransformOptions\n *\n * @typedef CoreOptions\n * @property {string} children\n *\n * @typedef PluginOptions\n * @property {PluggableList} [remarkPlugins=[]]\n * @property {PluggableList} [rehypePlugins=[]]\n * @property {import('remark-rehype').Options | undefined} [remarkRehypeOptions={}]\n *\n * @typedef LayoutOptions\n * @property {string} [className]\n *\n * @typedef {CoreOptions & PluginOptions & LayoutOptions & FilterOptions & TransformOptions} ReactMarkdownOptions\n *\n * @typedef Deprecation\n * @property {string} id\n * @property {string} [to]\n */\n\nimport React from 'react'\nimport {VFile} from 'vfile'\nimport {unified} from 'unified'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport PropTypes from 'prop-types'\nimport {html} from 'property-information'\nimport rehypeFilter from './rehype-filter.js'\nimport {uriTransformer} from './uri-transformer.js'\nimport {childrenToReact} from './ast-to-react.js'\n\nconst own = {}.hasOwnProperty\nconst changelog =\n  'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {Record<string, Deprecation>} */\nconst deprecated = {\n  plugins: {to: 'plugins', id: 'change-plugins-to-remarkplugins'},\n  renderers: {to: 'components', id: 'change-renderers-to-components'},\n  astPlugins: {id: 'remove-buggy-html-in-markdown-parser'},\n  allowDangerousHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n  escapeHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n  source: {to: 'children', id: 'change-source-to-children'},\n  allowNode: {\n    to: 'allowElement',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  allowedTypes: {\n    to: 'allowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  disallowedTypes: {\n    to: 'disallowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  includeNodeIndex: {\n    to: 'includeElementIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  }\n}\n\n/**\n * React component to render markdown.\n *\n * @param {ReactMarkdownOptions} options\n * @returns {ReactElement}\n */\nexport function ReactMarkdown(options) {\n  for (const key in deprecated) {\n    if (own.call(deprecated, key) && own.call(options, key)) {\n      const deprecation = deprecated[key]\n      console.warn(\n        `[react-markdown] Warning: please ${\n          deprecation.to ? `use \\`${deprecation.to}\\` instead of` : 'remove'\n        } \\`${key}\\` (see <${changelog}#${deprecation.id}> for more info)`\n      )\n      delete deprecated[key]\n    }\n  }\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(options.remarkPlugins || [])\n    .use(remarkRehype, {\n      ...options.remarkRehypeOptions,\n      allowDangerousHtml: true\n    })\n    .use(options.rehypePlugins || [])\n    .use(rehypeFilter, options)\n\n  const file = new VFile()\n\n  if (typeof options.children === 'string') {\n    file.value = options.children\n  } else if (options.children !== undefined && options.children !== null) {\n    console.warn(\n      `[react-markdown] Warning: please pass a string as \\`children\\` (not: \\`${options.children}\\`)`\n    )\n  }\n\n  const hastNode = processor.runSync(processor.parse(file), file)\n\n  if (hastNode.type !== 'root') {\n    throw new TypeError('Expected a `root` node')\n  }\n\n  /** @type {ReactElement} */\n  let result = React.createElement(\n    React.Fragment,\n    {},\n    childrenToReact({options, schema: html, listDepth: 0}, hastNode)\n  )\n\n  if (options.className) {\n    result = React.createElement('div', {className: options.className}, result)\n  }\n\n  return result\n}\n\nReactMarkdown.defaultProps = {transformLinkUri: uriTransformer}\n\nReactMarkdown.propTypes = {\n  // Core options:\n  children: PropTypes.string,\n  // Layout options:\n  className: PropTypes.string,\n  // Filter options:\n  allowElement: PropTypes.func,\n  allowedElements: PropTypes.arrayOf(PropTypes.string),\n  disallowedElements: PropTypes.arrayOf(PropTypes.string),\n  unwrapDisallowed: PropTypes.bool,\n  // Plugin options:\n  remarkPlugins: PropTypes.arrayOf(\n    PropTypes.oneOfType([\n      PropTypes.object,\n      PropTypes.func,\n      PropTypes.arrayOf(\n        PropTypes.oneOfType([\n          PropTypes.bool,\n          PropTypes.string,\n          PropTypes.object,\n          PropTypes.func,\n          PropTypes.arrayOf(\n            // prettier-ignore\n            // type-coverage:ignore-next-line\n            PropTypes.any\n          )\n        ])\n      )\n    ])\n  ),\n  rehypePlugins: PropTypes.arrayOf(\n    PropTypes.oneOfType([\n      PropTypes.object,\n      PropTypes.func,\n      PropTypes.arrayOf(\n        PropTypes.oneOfType([\n          PropTypes.bool,\n          PropTypes.string,\n          PropTypes.object,\n          PropTypes.func,\n          PropTypes.arrayOf(\n            // prettier-ignore\n            // type-coverage:ignore-next-line\n            PropTypes.any\n          )\n        ])\n      )\n    ])\n  ),\n  // Transform options:\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  includeElementIndex: PropTypes.bool,\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  components: PropTypes.object\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiControl,\n  asciiDigit,\n  markdownLineEndingOrSpace,\n  markdownLineEnding,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\nconst www = {\n  tokenize: tokenizeWww,\n  partial: true\n}\nconst domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n}\nconst path = {\n  tokenize: tokenizePath,\n  partial: true\n}\nconst punctuation = {\n  tokenize: tokenizePunctuation,\n  partial: true\n}\nconst namedCharacterReference = {\n  tokenize: tokenizeNamedCharacterReference,\n  partial: true\n}\nconst wwwAutolink = {\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n}\nconst httpAutolink = {\n  tokenize: tokenizeHttpAutolink,\n  previous: previousHttp\n}\nconst emailAutolink = {\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n}\n/** @type {ConstructRecord} */\n\nconst text = {}\n/** @type {Extension} */\n\nexport const gfmAutolinkLiteral = {\n  text\n}\nlet code = 48 // Add alphanumerics.\n\nwhile (code < 123) {\n  text[code] = emailAutolink\n  code++\n  if (code === 58) code = 65\n  else if (code === 91) code = 97\n}\n\ntext[43] = emailAutolink\ntext[45] = emailAutolink\ntext[46] = emailAutolink\ntext[95] = emailAutolink\ntext[72] = [emailAutolink, httpAutolink]\ntext[104] = [emailAutolink, httpAutolink]\ntext[87] = [emailAutolink, wwwAutolink]\ntext[119] = [emailAutolink, wwwAutolink]\n/** @type {Tokenizer} */\n\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  const self = this\n  /** @type {boolean} */\n\n  let hasDot\n  /** @type {boolean|undefined} */\n\n  let hasDigitInLastSegment\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (\n      !gfmAtext(code) ||\n      !previousEmail(self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\n      return nok(code)\n    }\n\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkEmail')\n    return atext(code)\n  }\n  /** @type {State} */\n\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code)\n      return atext\n    }\n\n    if (code === 64) {\n      effects.consume(code)\n      return label\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function label(code) {\n    if (code === 46) {\n      return effects.check(punctuation, done, dotContinuation)(code)\n    }\n\n    if (code === 45 || code === 95) {\n      return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code)\n    }\n\n    if (asciiAlphanumeric(code)) {\n      if (!hasDigitInLastSegment && asciiDigit(code)) {\n        hasDigitInLastSegment = true\n      }\n\n      effects.consume(code)\n      return label\n    }\n\n    return done(code)\n  }\n  /** @type {State} */\n\n  function dotContinuation(code) {\n    effects.consume(code)\n    hasDot = true\n    hasDigitInLastSegment = undefined\n    return label\n  }\n  /** @type {State} */\n\n  function dashOrUnderscoreContinuation(code) {\n    effects.consume(code)\n    return afterDashOrUnderscore\n  }\n  /** @type {State} */\n\n  function afterDashOrUnderscore(code) {\n    if (code === 46) {\n      return effects.check(punctuation, nok, dotContinuation)(code)\n    }\n\n    return label(code)\n  }\n  /** @type {State} */\n\n  function done(code) {\n    if (hasDot && !hasDigitInLastSegment) {\n      effects.exit('literalAutolinkEmail')\n      effects.exit('literalAutolink')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (\n      (code !== 87 && code !== 119) ||\n      !previousWww(self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\n      return nok(code)\n    }\n\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkWww') // For `www.` we check instead of attempt, because when it matches, GH\n    // treats it as part of a domain (yes, it says a valid domain must come\n    // after `www.`, but that’s not how it’s implemented by them).\n\n    return effects.check(\n      www,\n      effects.attempt(domain, effects.attempt(path, done), nok),\n      nok\n    )(code)\n  }\n  /** @type {State} */\n\n  function done(code) {\n    effects.exit('literalAutolinkWww')\n    effects.exit('literalAutolink')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHttpAutolink(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (\n      (code !== 72 && code !== 104) ||\n      !previousHttp(self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\n      return nok(code)\n    }\n\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkHttp')\n    effects.consume(code)\n    return t1\n  }\n  /** @type {State} */\n\n  function t1(code) {\n    if (code === 84 || code === 116) {\n      effects.consume(code)\n      return t2\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function t2(code) {\n    if (code === 84 || code === 116) {\n      effects.consume(code)\n      return p\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function p(code) {\n    if (code === 80 || code === 112) {\n      effects.consume(code)\n      return s\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function s(code) {\n    if (code === 83 || code === 115) {\n      effects.consume(code)\n      return colon\n    }\n\n    return colon(code)\n  }\n  /** @type {State} */\n\n  function colon(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return slash1\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function slash1(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return slash2\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function slash2(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    return code === null ||\n      asciiControl(code) ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)\n      ? nok(code)\n      : effects.attempt(domain, effects.attempt(path, done), nok)(code)\n  }\n  /** @type {State} */\n\n  function done(code) {\n    effects.exit('literalAutolinkHttp')\n    effects.exit('literalAutolink')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeWww(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.consume(code)\n    return w2\n  }\n  /** @type {State} */\n\n  function w2(code) {\n    if (code === 87 || code === 119) {\n      effects.consume(code)\n      return w3\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function w3(code) {\n    if (code === 87 || code === 119) {\n      effects.consume(code)\n      return dot\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function dot(code) {\n    if (code === 46) {\n      effects.consume(code)\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? nok(code) : ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeDomain(effects, ok, nok) {\n  /** @type {boolean|undefined} */\n  let hasUnderscoreInLastSegment\n  /** @type {boolean|undefined} */\n\n  let hasUnderscoreInLastLastSegment\n  return domain\n  /** @type {State} */\n\n  function domain(code) {\n    if (code === 38) {\n      return effects.check(\n        namedCharacterReference,\n        done,\n        punctuationContinuation\n      )(code)\n    }\n\n    if (code === 46 || code === 95) {\n      return effects.check(punctuation, done, punctuationContinuation)(code)\n    } // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n    // so that’s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n\n    if (\n      code === null ||\n      asciiControl(code) ||\n      unicodeWhitespace(code) ||\n      (code !== 45 && unicodePunctuation(code))\n    ) {\n      return done(code)\n    }\n\n    effects.consume(code)\n    return domain\n  }\n  /** @type {State} */\n\n  function punctuationContinuation(code) {\n    if (code === 46) {\n      hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment\n      hasUnderscoreInLastSegment = undefined\n      effects.consume(code)\n      return domain\n    }\n\n    if (code === 95) hasUnderscoreInLastSegment = true\n    effects.consume(code)\n    return domain\n  }\n  /** @type {State} */\n\n  function done(code) {\n    if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizePath(effects, ok) {\n  let balance = 0\n  return inPath\n  /** @type {State} */\n\n  function inPath(code) {\n    if (code === 38) {\n      return effects.check(\n        namedCharacterReference,\n        ok,\n        continuedPunctuation\n      )(code)\n    }\n\n    if (code === 40) {\n      balance++\n    }\n\n    if (code === 41) {\n      return effects.check(\n        punctuation,\n        parenAtPathEnd,\n        continuedPunctuation\n      )(code)\n    }\n\n    if (pathEnd(code)) {\n      return ok(code)\n    }\n\n    if (trailingPunctuation(code)) {\n      return effects.check(punctuation, ok, continuedPunctuation)(code)\n    }\n\n    effects.consume(code)\n    return inPath\n  }\n  /** @type {State} */\n\n  function continuedPunctuation(code) {\n    effects.consume(code)\n    return inPath\n  }\n  /** @type {State} */\n\n  function parenAtPathEnd(code) {\n    balance--\n    return balance < 0 ? ok(code) : continuedPunctuation(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeNamedCharacterReference(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.consume(code)\n    return inside\n  }\n  /** @type {State} */\n\n  function inside(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (code === 59) {\n      effects.consume(code)\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    // If the named character reference is followed by the end of the path, it’s\n    // not continued punctuation.\n    return pathEnd(code) ? ok(code) : nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizePunctuation(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.consume(code)\n    return after\n  }\n  /** @type {State} */\n\n  function after(code) {\n    // Check the next.\n    if (trailingPunctuation(code)) {\n      effects.consume(code)\n      return after\n    } // If the punctuation marker is followed by the end of the path, it’s not\n    // continued punctuation.\n\n    return pathEnd(code) ? ok(code) : nok(code)\n  }\n}\n/**\n * @param {Code} code\n * @returns {boolean}\n */\n\nfunction trailingPunctuation(code) {\n  return (\n    code === 33 ||\n    code === 34 ||\n    code === 39 ||\n    code === 41 ||\n    code === 42 ||\n    code === 44 ||\n    code === 46 ||\n    code === 58 ||\n    code === 59 ||\n    code === 60 ||\n    code === 63 ||\n    code === 95 ||\n    code === 126\n  )\n}\n/**\n * @param {Code} code\n * @returns {boolean}\n */\n\nfunction pathEnd(code) {\n  return code === null || code === 60 || markdownLineEndingOrSpace(code)\n}\n/**\n * @param {Code} code\n * @returns {boolean}\n */\n\nfunction gfmAtext(code) {\n  return (\n    code === 43 ||\n    code === 45 ||\n    code === 46 ||\n    code === 95 ||\n    asciiAlphanumeric(code)\n  )\n}\n/** @type {Previous} */\n\nfunction previousWww(code) {\n  return (\n    code === null ||\n    code === 40 ||\n    code === 42 ||\n    code === 95 ||\n    code === 126 ||\n    markdownLineEndingOrSpace(code)\n  )\n}\n/** @type {Previous} */\n\nfunction previousHttp(code) {\n  return code === null || !asciiAlpha(code)\n}\n/** @type {Previous} */\n\nfunction previousEmail(code) {\n  return code !== 47 && previousHttp(code)\n}\n/**\n * @param {Array<Event>} events\n * @returns {boolean}\n */\n\nfunction previousUnbalanced(events) {\n  let index = events.length\n  let result = false\n\n  while (index--) {\n    const token = events[index][1]\n\n    if (\n      (token.type === 'labelLink' || token.type === 'labelImage') &&\n      !token._balanced\n    ) {\n      result = true\n      break\n    } // @ts-expect-error If we’ve seen this token, and it was marked as not\n    // having any unbalanced bracket before it, we can exit.\n\n    if (token._gfmAutolinkLiteralWalkedInto) {\n      result = false\n      break\n    }\n  }\n\n  if (events.length > 0 && !result) {\n    // @ts-expect-error Mark the last token as “walked into” w/o finding\n    // anything.\n    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true\n  }\n\n  return result\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {blankLine} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nconst indent = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n/**\n * @returns {Extension}\n */\n\nexport function gfmFootnote() {\n  /** @type {Extension} */\n  return {\n    document: {\n      [91]: {\n        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  /** @type {Token} */\n\n  let labelStart // Find an opening.\n\n  while (index--) {\n    const token = self.events[index][1]\n\n    if (token.type === 'labelImage') {\n      labelStart = token\n      break\n    } // Exit if we’ve walked far enough.\n\n    if (\n      token.type === 'gfmFootnoteCall' ||\n      token.type === 'labelLink' ||\n      token.type === 'label' ||\n      token.type === 'image' ||\n      token.type === 'link'\n    ) {\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!labelStart || !labelStart._balanced) {\n      return nok(code)\n    }\n\n    const id = normalizeIdentifier(\n      self.sliceSerialize({\n        start: labelStart.end,\n        end: self.now()\n      })\n    )\n\n    if (id.charCodeAt(0) !== 94 || !defined.includes(id.slice(1))) {\n      return nok(code)\n    }\n\n    effects.enter('gfmFootnoteCallLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallLabelMarker')\n    return ok(code)\n  }\n}\n/** @type {Resolver} */\n\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n  let index = events.length\n  /** @type {Token|undefined} */\n\n  let labelStart // Find an opening.\n\n  while (index--) {\n    if (\n      events[index][1].type === 'labelImage' &&\n      events[index][0] === 'enter'\n    ) {\n      labelStart = events[index][1]\n      break\n    }\n  }\n\n  // Change the `labelImageMarker` to a `data`.\n  events[index + 1][1].type = 'data'\n  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker' // The whole (without `!`):\n\n  const call = {\n    type: 'gfmFootnoteCall',\n    start: Object.assign({}, events[index + 3][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  } // The `^` marker\n\n  const marker = {\n    type: 'gfmFootnoteCallMarker',\n    start: Object.assign({}, events[index + 3][1].end),\n    end: Object.assign({}, events[index + 3][1].end)\n  } // Increment the end 1 character.\n\n  marker.end.column++\n  marker.end.offset++\n  marker.end._bufferIndex++\n  const string = {\n    type: 'gfmFootnoteCallString',\n    start: Object.assign({}, marker.end),\n    end: Object.assign({}, events[events.length - 1][1].start)\n  }\n  const chunk = {\n    type: 'chunkString',\n    contentType: 'string',\n    start: Object.assign({}, string.start),\n    end: Object.assign({}, string.end)\n  }\n  /** @type {Array<Event>} */\n\n  const replacement = [\n    // Take the `labelImageMarker` (now `data`, the `!`)\n    events[index + 1],\n    events[index + 2],\n    ['enter', call, context], // The `[`\n    events[index + 3],\n    events[index + 4], // The `^`.\n    ['enter', marker, context],\n    ['exit', marker, context], // Everything in between.\n    ['enter', string, context],\n    ['enter', chunk, context],\n    ['exit', chunk, context],\n    ['exit', string, context], // The ending (`]`, properly parsed and labelled).\n    events[events.length - 2],\n    events[events.length - 1],\n    ['exit', call, context]\n  ]\n  events.splice(index, events.length - index + 1, ...replacement)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n  const self = this\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  let size = 0\n  /** @type {boolean} */\n\n  let data\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('gfmFootnoteCall')\n    effects.enter('gfmFootnoteCallLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallLabelMarker')\n    return callStart\n  }\n  /** @type {State} */\n\n  function callStart(code) {\n    if (code !== 94) return nok(code)\n    effects.enter('gfmFootnoteCallMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallMarker')\n    effects.enter('gfmFootnoteCallString')\n    effects.enter('chunkString').contentType = 'string'\n    return callData\n  }\n  /** @type {State} */\n\n  function callData(code) {\n    /** @type {Token} */\n    let token\n\n    if (code === null || code === 91 || size++ > 999) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      if (!data) {\n        return nok(code)\n      }\n\n      effects.exit('chunkString')\n      token = effects.exit('gfmFootnoteCallString')\n      return defined.includes(normalizeIdentifier(self.sliceSerialize(token)))\n        ? end(code)\n        : nok(code)\n    }\n\n    effects.consume(code)\n\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true\n    }\n\n    return code === 92 ? callEscape : callData\n  }\n  /** @type {State} */\n\n  function callEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return callData\n    }\n\n    return callData(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    effects.enter('gfmFootnoteCallLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallLabelMarker')\n    effects.exit('gfmFootnoteCall')\n    return ok\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n  const self = this\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  /** @type {string} */\n\n  let identifier\n  let size = 0\n  /** @type {boolean|undefined} */\n\n  let data\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('gfmFootnoteDefinition')._container = true\n    effects.enter('gfmFootnoteDefinitionLabel')\n    effects.enter('gfmFootnoteDefinitionLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteDefinitionLabelMarker')\n    return labelStart\n  }\n  /** @type {State} */\n\n  function labelStart(code) {\n    if (code === 94) {\n      effects.enter('gfmFootnoteDefinitionMarker')\n      effects.consume(code)\n      effects.exit('gfmFootnoteDefinitionMarker')\n      effects.enter('gfmFootnoteDefinitionLabelString')\n      return atBreak\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    /** @type {Token} */\n    let token\n\n    if (code === null || code === 91 || size > 999) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      if (!data) {\n        return nok(code)\n      }\n\n      token = effects.exit('gfmFootnoteDefinitionLabelString')\n      identifier = normalizeIdentifier(self.sliceSerialize(token))\n      effects.enter('gfmFootnoteDefinitionLabelMarker')\n      effects.consume(code)\n      effects.exit('gfmFootnoteDefinitionLabelMarker')\n      effects.exit('gfmFootnoteDefinitionLabel')\n      return labelAfter\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      size++\n      return atBreak\n    }\n\n    effects.enter('chunkString').contentType = 'string'\n    return label(code)\n  }\n  /** @type {State} */\n\n  function label(code) {\n    if (\n      code === null ||\n      markdownLineEnding(code) ||\n      code === 91 ||\n      code === 93 ||\n      size > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true\n    }\n\n    size++\n    effects.consume(code)\n    return code === 92 ? labelEscape : label\n  }\n  /** @type {State} */\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return label\n    }\n\n    return label(code)\n  }\n  /** @type {State} */\n\n  function labelAfter(code) {\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Any whitespace after the marker is eaten, forming indented code\n      // is not possible.\n      // No space is also fine, just like a block quote marker.\n\n      return factorySpace(effects, done, 'gfmFootnoteDefinitionWhitespace')\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function done(code) {\n    if (!defined.includes(identifier)) {\n      defined.push(identifier)\n    }\n\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n  // Either a blank line, which is okay, or an indented thing.\n  return effects.check(blankLine, ok, effects.attempt(indent, ok, nok))\n}\n/** @type {Exiter} */\n\nfunction gfmFootnoteDefinitionEnd(effects) {\n  effects.exit('gfmFootnoteDefinition')\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'gfmFootnoteDefinitionIndent',\n    4 + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'gfmFootnoteDefinitionIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === 4\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Event} Event\n */\n\n/**\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean} [singleTilde=true]\n *   Whether to support strikethrough with a single tilde (`boolean`, default:\n *   `true`).\n *   Single tildes work on github.com, but are technically prohibited by the\n *   GFM spec.\n */\nimport {splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/**\n * @param {Options} [options]\n * @returns {Extension}\n */\nexport function gfmStrikethrough(options = {}) {\n  let single = options.singleTilde\n  const tokenizer = {\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  }\n\n  if (single === null || single === undefined) {\n    single = true\n  }\n\n  return {\n    text: {\n      [126]: tokenizer\n    },\n    insideSpan: {\n      null: [tokenizer]\n    },\n    attentionMarkers: {\n      null: [126]\n    }\n  }\n  /**\n   * Take events and resolve strikethrough.\n   *\n   * @type {Resolver}\n   */\n\n  function resolveAllStrikethrough(events, context) {\n    let index = -1 // Walk through all events.\n\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (\n        events[index][0] === 'enter' &&\n        events[index][1].type === 'strikethroughSequenceTemporary' &&\n        events[index][1]._close\n      ) {\n        let open = index // Now walk back to find an opener.\n\n        while (open--) {\n          // Find a token that can open the closer.\n          if (\n            events[open][0] === 'exit' &&\n            events[open][1].type === 'strikethroughSequenceTemporary' &&\n            events[open][1]._open && // If the sizes are the same:\n            events[index][1].end.offset - events[index][1].start.offset ===\n              events[open][1].end.offset - events[open][1].start.offset\n          ) {\n            events[index][1].type = 'strikethroughSequence'\n            events[open][1].type = 'strikethroughSequence'\n            const strikethrough = {\n              type: 'strikethrough',\n              start: Object.assign({}, events[open][1].start),\n              end: Object.assign({}, events[index][1].end)\n            }\n            const text = {\n              type: 'strikethroughText',\n              start: Object.assign({}, events[open][1].end),\n              end: Object.assign({}, events[index][1].start)\n            } // Opening.\n\n            const nextEvents = [\n              ['enter', strikethrough, context],\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context],\n              ['enter', text, context]\n            ] // Between.\n\n            splice(\n              nextEvents,\n              nextEvents.length,\n              0,\n              resolveAll(\n                context.parser.constructs.insideSpan.null,\n                events.slice(open + 1, index),\n                context\n              )\n            ) // Closing.\n\n            splice(nextEvents, nextEvents.length, 0, [\n              ['exit', text, context],\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context],\n              ['exit', strikethrough, context]\n            ])\n            splice(events, open - 1, index - open + 3, nextEvents)\n            index = open + nextEvents.length - 2\n            break\n          }\n        }\n      }\n    }\n\n    index = -1\n\n    while (++index < events.length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = 'data'\n      }\n    }\n\n    return events\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeStrikethrough(effects, ok, nok) {\n    const previous = this.previous\n    const events = this.events\n    let size = 0\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      if (\n        previous === 126 &&\n        events[events.length - 1][1].type !== 'characterEscape'\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('strikethroughSequenceTemporary')\n      return more(code)\n    }\n    /** @type {State} */\n\n    function more(code) {\n      const before = classifyCharacter(previous)\n\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code)\n        effects.consume(code)\n        size++\n        return more\n      }\n\n      if (size < 2 && !single) return nok(code)\n      const token = effects.exit('strikethroughSequenceTemporary')\n      const after = classifyCharacter(code)\n      token._open = !after || (after === 2 && Boolean(before))\n      token._close = !before || (before === 2 && Boolean(after))\n      return ok(code)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n */\n\n/**\n * @typedef {'left'|'center'|'right'|'none'} Align\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n\n/** @type {Extension} */\nexport const gfmTable = {\n  flow: {\n    null: {\n      tokenize: tokenizeTable,\n      resolve: resolveTable\n    }\n  }\n}\nconst nextPrefixedOrBlank = {\n  tokenize: tokenizeNextPrefixedOrBlank,\n  partial: true\n}\n/** @type {Resolver} */\n\nfunction resolveTable(events, context) {\n  let index = -1\n  /** @type {boolean|undefined} */\n\n  let inHead\n  /** @type {boolean|undefined} */\n\n  let inDelimiterRow\n  /** @type {boolean|undefined} */\n\n  let inRow\n  /** @type {number|undefined} */\n\n  let contentStart\n  /** @type {number|undefined} */\n\n  let contentEnd\n  /** @type {number|undefined} */\n\n  let cellStart\n  /** @type {boolean|undefined} */\n\n  let seenCellInRow\n\n  while (++index < events.length) {\n    const token = events[index][1]\n\n    if (inRow) {\n      if (token.type === 'temporaryTableCellContent') {\n        contentStart = contentStart || index\n        contentEnd = index\n      }\n\n      if (\n        // Combine separate content parts into one.\n        (token.type === 'tableCellDivider' || token.type === 'tableRow') &&\n        contentEnd\n      ) {\n        const content = {\n          type: 'tableContent',\n          start: events[contentStart][1].start,\n          end: events[contentEnd][1].end\n        }\n        /** @type {Token} */\n\n        const text = {\n          type: 'chunkText',\n          start: content.start,\n          end: content.end,\n          // @ts-expect-error It’s fine.\n          contentType: 'text'\n        }\n        events.splice(\n          contentStart,\n          contentEnd - contentStart + 1,\n          ['enter', content, context],\n          ['enter', text, context],\n          ['exit', text, context],\n          ['exit', content, context]\n        )\n        index -= contentEnd - contentStart - 3\n        contentStart = undefined\n        contentEnd = undefined\n      }\n    }\n\n    if (\n      events[index][0] === 'exit' &&\n      cellStart !== undefined &&\n      cellStart + (seenCellInRow ? 0 : 1) < index &&\n      (token.type === 'tableCellDivider' ||\n        (token.type === 'tableRow' &&\n          (cellStart + 3 < index ||\n            events[cellStart][1].type !== 'whitespace')))\n    ) {\n      const cell = {\n        type: inDelimiterRow\n          ? 'tableDelimiter'\n          : inHead\n          ? 'tableHeader'\n          : 'tableData',\n        start: events[cellStart][1].start,\n        end: events[index][1].end\n      }\n      events.splice(index + (token.type === 'tableCellDivider' ? 1 : 0), 0, [\n        'exit',\n        cell,\n        context\n      ])\n      events.splice(cellStart, 0, ['enter', cell, context])\n      index += 2\n      cellStart = index + 1\n      seenCellInRow = true\n    }\n\n    if (token.type === 'tableRow') {\n      inRow = events[index][0] === 'enter'\n\n      if (inRow) {\n        cellStart = index + 1\n        seenCellInRow = false\n      }\n    }\n\n    if (token.type === 'tableDelimiterRow') {\n      inDelimiterRow = events[index][0] === 'enter'\n\n      if (inDelimiterRow) {\n        cellStart = index + 1\n        seenCellInRow = false\n      }\n    }\n\n    if (token.type === 'tableHead') {\n      inHead = events[index][0] === 'enter'\n    }\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeTable(effects, ok, nok) {\n  const self = this\n  /** @type {Array<Align>} */\n\n  const align = []\n  let tableHeaderCount = 0\n  /** @type {boolean|undefined} */\n\n  let seenDelimiter\n  /** @type {boolean|undefined} */\n\n  let hasDash\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    // @ts-expect-error Custom.\n    effects.enter('table')._align = align\n    effects.enter('tableHead')\n    effects.enter('tableRow') // If we start with a pipe, we open a cell marker.\n\n    if (code === 124) {\n      return cellDividerHead(code)\n    }\n\n    tableHeaderCount++\n    effects.enter('temporaryTableCellContent') // Can’t be space or eols at the start of a construct, so we’re in a cell.\n\n    return inCellContentHead(code)\n  }\n  /** @type {State} */\n\n  function cellDividerHead(code) {\n    effects.enter('tableCellDivider')\n    effects.consume(code)\n    effects.exit('tableCellDivider')\n    seenDelimiter = true\n    return cellBreakHead\n  }\n  /** @type {State} */\n\n  function cellBreakHead(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return atRowEndHead(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.enter('whitespace')\n      effects.consume(code)\n      return inWhitespaceHead\n    }\n\n    if (seenDelimiter) {\n      seenDelimiter = undefined\n      tableHeaderCount++\n    }\n\n    if (code === 124) {\n      return cellDividerHead(code)\n    } // Anything else is cell content.\n\n    effects.enter('temporaryTableCellContent')\n    return inCellContentHead(code)\n  }\n  /** @type {State} */\n\n  function inWhitespaceHead(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return inWhitespaceHead\n    }\n\n    effects.exit('whitespace')\n    return cellBreakHead(code)\n  }\n  /** @type {State} */\n\n  function inCellContentHead(code) {\n    // EOF, whitespace, pipe\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit('temporaryTableCellContent')\n      return cellBreakHead(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? inCellContentEscapeHead : inCellContentHead\n  }\n  /** @type {State} */\n\n  function inCellContentEscapeHead(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code)\n      return inCellContentHead\n    } // Anything else.\n\n    return inCellContentHead(code)\n  }\n  /** @type {State} */\n\n  function atRowEndHead(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    effects.exit('tableRow')\n    effects.exit('tableHead')\n    const originalInterrupt = self.interrupt\n    self.interrupt = true\n    return effects.attempt(\n      {\n        tokenize: tokenizeRowEnd,\n        partial: true\n      },\n      function (code) {\n        self.interrupt = originalInterrupt\n        effects.enter('tableDelimiterRow')\n        return atDelimiterRowBreak(code)\n      },\n      function (code) {\n        self.interrupt = originalInterrupt\n        return nok(code)\n      }\n    )(code)\n  }\n  /** @type {State} */\n\n  function atDelimiterRowBreak(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return rowEndDelimiter(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.enter('whitespace')\n      effects.consume(code)\n      return inWhitespaceDelimiter\n    }\n\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller')\n      effects.consume(code)\n      hasDash = true\n      align.push('none')\n      return inFillerDelimiter\n    }\n\n    if (code === 58) {\n      effects.enter('tableDelimiterAlignment')\n      effects.consume(code)\n      effects.exit('tableDelimiterAlignment')\n      align.push('left')\n      return afterLeftAlignment\n    } // If we start with a pipe, we open a cell marker.\n\n    if (code === 124) {\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      return atDelimiterRowBreak\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function inWhitespaceDelimiter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return inWhitespaceDelimiter\n    }\n\n    effects.exit('whitespace')\n    return atDelimiterRowBreak(code)\n  }\n  /** @type {State} */\n\n  function inFillerDelimiter(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return inFillerDelimiter\n    }\n\n    effects.exit('tableDelimiterFiller')\n\n    if (code === 58) {\n      effects.enter('tableDelimiterAlignment')\n      effects.consume(code)\n      effects.exit('tableDelimiterAlignment')\n      align[align.length - 1] =\n        align[align.length - 1] === 'left' ? 'center' : 'right'\n      return afterRightAlignment\n    }\n\n    return atDelimiterRowBreak(code)\n  }\n  /** @type {State} */\n\n  function afterLeftAlignment(code) {\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller')\n      effects.consume(code)\n      hasDash = true\n      return inFillerDelimiter\n    } // Anything else is not ok.\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function afterRightAlignment(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return rowEndDelimiter(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.enter('whitespace')\n      effects.consume(code)\n      return inWhitespaceDelimiter\n    } // `|`\n\n    if (code === 124) {\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      return atDelimiterRowBreak\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function rowEndDelimiter(code) {\n    effects.exit('tableDelimiterRow') // Exit if there was no dash at all, or if the header cell count is not the\n    // delimiter cell count.\n\n    if (!hasDash || tableHeaderCount !== align.length) {\n      return nok(code)\n    }\n\n    if (code === null) {\n      return tableClose(code)\n    }\n\n    return effects.check(\n      nextPrefixedOrBlank,\n      tableClose,\n      effects.attempt(\n        {\n          tokenize: tokenizeRowEnd,\n          partial: true\n        },\n        factorySpace(effects, bodyStart, 'linePrefix', 4),\n        tableClose\n      )\n    )(code)\n  }\n  /** @type {State} */\n\n  function tableClose(code) {\n    effects.exit('table')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function bodyStart(code) {\n    effects.enter('tableBody')\n    return rowStartBody(code)\n  }\n  /** @type {State} */\n\n  function rowStartBody(code) {\n    effects.enter('tableRow') // If we start with a pipe, we open a cell marker.\n\n    if (code === 124) {\n      return cellDividerBody(code)\n    }\n\n    effects.enter('temporaryTableCellContent') // Can’t be space or eols at the start of a construct, so we’re in a cell.\n\n    return inCellContentBody(code)\n  }\n  /** @type {State} */\n\n  function cellDividerBody(code) {\n    effects.enter('tableCellDivider')\n    effects.consume(code)\n    effects.exit('tableCellDivider')\n    return cellBreakBody\n  }\n  /** @type {State} */\n\n  function cellBreakBody(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return atRowEndBody(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.enter('whitespace')\n      effects.consume(code)\n      return inWhitespaceBody\n    } // `|`\n\n    if (code === 124) {\n      return cellDividerBody(code)\n    } // Anything else is cell content.\n\n    effects.enter('temporaryTableCellContent')\n    return inCellContentBody(code)\n  }\n  /** @type {State} */\n\n  function inWhitespaceBody(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return inWhitespaceBody\n    }\n\n    effects.exit('whitespace')\n    return cellBreakBody(code)\n  }\n  /** @type {State} */\n\n  function inCellContentBody(code) {\n    // EOF, whitespace, pipe\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit('temporaryTableCellContent')\n      return cellBreakBody(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? inCellContentEscapeBody : inCellContentBody\n  }\n  /** @type {State} */\n\n  function inCellContentEscapeBody(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code)\n      return inCellContentBody\n    } // Anything else.\n\n    return inCellContentBody(code)\n  }\n  /** @type {State} */\n\n  function atRowEndBody(code) {\n    effects.exit('tableRow')\n\n    if (code === null) {\n      return tableBodyClose(code)\n    }\n\n    return effects.check(\n      nextPrefixedOrBlank,\n      tableBodyClose,\n      effects.attempt(\n        {\n          tokenize: tokenizeRowEnd,\n          partial: true\n        },\n        factorySpace(effects, rowStartBody, 'linePrefix', 4),\n        tableBodyClose\n      )\n    )(code)\n  }\n  /** @type {State} */\n\n  function tableBodyClose(code) {\n    effects.exit('tableBody')\n    return tableClose(code)\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeRowEnd(effects, ok, nok) {\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, prefixed, 'linePrefix')\n    }\n    /** @type {State} */\n\n    function prefixed(code) {\n      // Blank or interrupting line.\n      if (\n        self.parser.lazy[self.now().line] ||\n        code === null ||\n        markdownLineEnding(code)\n      ) {\n        return nok(code)\n      }\n\n      const tail = self.events[self.events.length - 1] // Indented code can interrupt delimiter and body rows.\n\n      if (\n        !self.parser.constructs.disable.null.includes('codeIndented') &&\n        tail &&\n        tail[1].type === 'linePrefix' &&\n        tail[2].sliceSerialize(tail[1], true).length >= 4\n      ) {\n        return nok(code)\n      }\n\n      self._gfmTableDynamicInterruptHack = true\n      return effects.check(\n        self.parser.constructs.flow,\n        function (code) {\n          self._gfmTableDynamicInterruptHack = false\n          return nok(code)\n        },\n        function (code) {\n          self._gfmTableDynamicInterruptHack = false\n          return ok(code)\n        }\n      )(code)\n    }\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeNextPrefixedOrBlank(effects, ok, nok) {\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    // This is a check, so we don’t care about tokens, but we open a bogus one\n    // so we’re valid.\n    effects.enter('check') // EOL.\n\n    effects.consume(code)\n    return whitespace\n  }\n  /** @type {State} */\n\n  function whitespace(code) {\n    if (code === -1 || code === 32) {\n      effects.consume(code)\n      size++\n      return size === 4 ? ok : whitespace\n    } // EOF or whitespace\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      return ok(code)\n    } // Anything else.\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\nconst tasklistCheck = {\n  tokenize: tokenizeTasklistCheck\n}\nexport const gfmTaskListItem = {\n  text: {\n    [91]: tasklistCheck\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  const self = this\n  return open\n  /** @type {State} */\n\n  function open(code) {\n    if (\n      // Exit if there’s stuff before.\n      self.previous !== null || // Exit if not in the first content that is the first child of a list\n      // item.\n      !self._gfmTasklistFirstContentOfListItem\n    ) {\n      return nok(code)\n    }\n\n    effects.enter('taskListCheck')\n    effects.enter('taskListCheckMarker')\n    effects.consume(code)\n    effects.exit('taskListCheckMarker')\n    return inside\n  }\n  /** @type {State} */\n\n  function inside(code) {\n    // To match how GH works in comments, use `markdownSpace` (`[ \\t]`) instead\n    // of `markdownLineEndingOrSpace` (`[ \\t\\r\\n]`).\n    if (markdownLineEndingOrSpace(code)) {\n      effects.enter('taskListCheckValueUnchecked')\n      effects.consume(code)\n      effects.exit('taskListCheckValueUnchecked')\n      return close\n    }\n\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked')\n      effects.consume(code)\n      effects.exit('taskListCheckValueChecked')\n      return close\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function close(code) {\n    if (code === 93) {\n      effects.enter('taskListCheckMarker')\n      effects.consume(code)\n      effects.exit('taskListCheckMarker')\n      effects.exit('taskListCheck')\n      return effects.check(\n        {\n          tokenize: spaceThenNonSpace\n        },\n        ok,\n        nok\n      )\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction spaceThenNonSpace(effects, ok, nok) {\n  const self = this\n  return factorySpace(effects, after, 'whitespace')\n  /** @type {State} */\n\n  function after(code) {\n    const tail = self.events[self.events.length - 1]\n    return (\n      // We either found spaces…\n      ((tail && tail[1].type === 'whitespace') || // …or it was followed by a line ending, in which case, there has to be\n        // non-whitespace after that line ending, because otherwise we’d get an\n        // EOF as the content is closed with blank lines.\n        markdownLineEnding(code)) &&\n        code !== null\n        ? ok(code)\n        : nok(code)\n    )\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options\n * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions\n */\n\nimport {\n  combineExtensions,\n  combineHtmlExtensions\n} from 'micromark-util-combine-extensions'\nimport {\n  gfmAutolinkLiteral,\n  gfmAutolinkLiteralHtml\n} from 'micromark-extension-gfm-autolink-literal'\nimport {gfmFootnote, gfmFootnoteHtml} from 'micromark-extension-gfm-footnote'\nimport {\n  gfmStrikethrough,\n  gfmStrikethroughHtml\n} from 'micromark-extension-gfm-strikethrough'\nimport {gfmTable, gfmTableHtml} from 'micromark-extension-gfm-table'\nimport {gfmTagfilterHtml} from 'micromark-extension-gfm-tagfilter'\nimport {\n  gfmTaskListItem,\n  gfmTaskListItemHtml\n} from 'micromark-extension-gfm-task-list-item'\n\n/**\n * Support GFM or markdown on github.com.\n *\n * @param {Options} [options]\n * @returns {Extension}\n */\nexport function gfm(options) {\n  return combineExtensions([\n    gfmAutolinkLiteral,\n    gfmFootnote(),\n    gfmStrikethrough(options),\n    gfmTable,\n    gfmTaskListItem\n  ])\n}\n\n/**\n * Support to compile GFM to HTML.\n *\n * @param {HtmlOptions} [options]\n * @returns {HtmlExtension}\n */\nexport function gfmHtml(options) {\n  return combineHtmlExtensions([\n    gfmAutolinkLiteralHtml,\n    gfmFootnoteHtml(options),\n    gfmStrikethroughHtml,\n    gfmTableHtml,\n    gfmTagfilterHtml,\n    gfmTaskListItemHtml\n  ])\n}\n","/**\n * Count how often a character (or substring) is used in a string.\n *\n * @param {string} value\n *   Value to search in.\n * @param {string} character\n *   Character (or substring) to look for.\n * @return {number}\n *   Number of times `character` occurred in `value`.\n */\nexport function ccount(value, character) {\n  const source = String(value)\n\n  if (typeof character !== 'string') {\n    throw new TypeError('Expected character')\n  }\n\n  let count = 0\n  let index = source.indexOf(character)\n\n  while (index !== -1) {\n    count++\n    index = source.indexOf(character, index + character.length)\n  }\n\n  return count\n}\n","/**\n * @typedef Options\n *   Configuration (optional).\n * @property {Test} [ignore]\n *   `unist-util-is` test used to assert parents\n *\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Text} Text\n * @typedef {Content|Root} Node\n * @typedef {Exclude<Extract<Node, import('mdast').Parent>, Root>} Parent\n *\n * @typedef {import('unist-util-visit-parents').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n *\n * @typedef RegExpMatchObject\n * @property {number} index\n * @property {string} input\n * @property {[Root, ...Array<Parent>, Text]} stack\n *\n * @typedef {string|RegExp} Find\n * @typedef {string|ReplaceFunction} Replace\n *\n * @typedef {[Find, Replace]} FindAndReplaceTuple\n * @typedef {Record<string, Replace>} FindAndReplaceSchema\n * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList\n *\n * @typedef {[RegExp, ReplaceFunction]} Pair\n * @typedef {Array<Pair>} Pairs\n */\n\n/**\n * @callback ReplaceFunction\n * @param {...any} parameters\n * @returns {Array<PhrasingContent>|PhrasingContent|string|false|undefined|null}\n */\n\nimport escape from 'escape-string-regexp'\nimport {visitParents} from 'unist-util-visit-parents'\nimport {convert} from 'unist-util-is'\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param tree mdast tree\n * @param find Value to find and remove. When `string`, escaped and made into a global `RegExp`\n * @param [replace] Value to insert.\n *   * When `string`, turned into a Text node.\n *   * When `Function`, called with the results of calling `RegExp.exec` as\n *     arguments, in which case it can return a single or a list of `Node`,\n *     a `string` (which is wrapped in a `Text` node), or `false` to not replace\n * @param [options] Configuration.\n */\nexport const findAndReplace =\n  /**\n   * @type {(\n   *   ((tree: Node, find: Find, replace?: Replace, options?: Options) => Node) &\n   *   ((tree: Node, schema: FindAndReplaceSchema|FindAndReplaceList, options?: Options) => Node)\n   * )}\n   **/\n  (\n    /**\n     * @param {Node} tree\n     * @param {Find|FindAndReplaceSchema|FindAndReplaceList} find\n     * @param {Replace|Options} [replace]\n     * @param {Options} [options]\n     */\n    function (tree, find, replace, options) {\n      /** @type {Options|undefined} */\n      let settings\n      /** @type {FindAndReplaceSchema|FindAndReplaceList} */\n      let schema\n\n      if (typeof find === 'string' || find instanceof RegExp) {\n        // @ts-expect-error don’t expect options twice.\n        schema = [[find, replace]]\n        settings = options\n      } else {\n        schema = find\n        // @ts-expect-error don’t expect replace twice.\n        settings = replace\n      }\n\n      if (!settings) {\n        settings = {}\n      }\n\n      const ignored = convert(settings.ignore || [])\n      const pairs = toPairs(schema)\n      let pairIndex = -1\n\n      while (++pairIndex < pairs.length) {\n        visitParents(tree, 'text', visitor)\n      }\n\n      return tree\n\n      /** @type {import('unist-util-visit-parents/complex-types').BuildVisitor<Root, 'text'>} */\n      function visitor(node, parents) {\n        let index = -1\n        /** @type {Parent|undefined} */\n        let grandparent\n\n        while (++index < parents.length) {\n          const parent = /** @type {Parent} */ (parents[index])\n\n          if (\n            ignored(\n              parent,\n              // @ts-expect-error mdast vs. unist parent.\n              grandparent ? grandparent.children.indexOf(parent) : undefined,\n              grandparent\n            )\n          ) {\n            return\n          }\n\n          grandparent = parent\n        }\n\n        if (grandparent) {\n          // @ts-expect-error: stack is fine.\n          return handler(node, parents)\n        }\n      }\n\n      /**\n       * @param {Text} node\n       * @param {[Root, ...Array<Parent>]} parents\n       * @returns {VisitorResult}\n       */\n      function handler(node, parents) {\n        const parent = parents[parents.length - 1]\n        const find = pairs[pairIndex][0]\n        const replace = pairs[pairIndex][1]\n        let start = 0\n        // @ts-expect-error: TS is wrong, some of these children can be text.\n        const index = parent.children.indexOf(node)\n        let change = false\n        /** @type {Array<PhrasingContent>} */\n        let nodes = []\n        /** @type {number|undefined} */\n        let position\n\n        find.lastIndex = 0\n\n        let match = find.exec(node.value)\n\n        while (match) {\n          position = match.index\n          /** @type {RegExpMatchObject} */\n          const matchObject = {\n            index: match.index,\n            input: match.input,\n            stack: [...parents, node]\n          }\n          let value = replace(...match, matchObject)\n\n          if (typeof value === 'string') {\n            value = value.length > 0 ? {type: 'text', value} : undefined\n          }\n\n          if (value !== false) {\n            if (start !== position) {\n              nodes.push({\n                type: 'text',\n                value: node.value.slice(start, position)\n              })\n            }\n\n            if (Array.isArray(value)) {\n              nodes.push(...value)\n            } else if (value) {\n              nodes.push(value)\n            }\n\n            start = position + match[0].length\n            change = true\n          }\n\n          if (!find.global) {\n            break\n          }\n\n          match = find.exec(node.value)\n        }\n\n        if (change) {\n          if (start < node.value.length) {\n            nodes.push({type: 'text', value: node.value.slice(start)})\n          }\n\n          parent.children.splice(index, 1, ...nodes)\n        } else {\n          nodes = [node]\n        }\n\n        return index + nodes.length\n      }\n    }\n  )\n\n/**\n * @param {FindAndReplaceSchema|FindAndReplaceList} schema\n * @returns {Pairs}\n */\nfunction toPairs(schema) {\n  /** @type {Pairs} */\n  const result = []\n\n  if (typeof schema !== 'object') {\n    throw new TypeError('Expected array or object as schema')\n  }\n\n  if (Array.isArray(schema)) {\n    let index = -1\n\n    while (++index < schema.length) {\n      result.push([\n        toExpression(schema[index][0]),\n        toFunction(schema[index][1])\n      ])\n    }\n  } else {\n    /** @type {string} */\n    let key\n\n    for (key in schema) {\n      if (own.call(schema, key)) {\n        result.push([toExpression(key), toFunction(schema[key])])\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * @param {Find} find\n * @returns {RegExp}\n */\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find\n}\n\n/**\n * @param {Replace} replace\n * @returns {ReplaceFunction}\n */\nfunction toFunction(replace) {\n  return typeof replace === 'function' ? replace : () => replace\n}\n","export default function escapeStringRegexp(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Transform} FromMarkdownTransform\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown/lib/types.js').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction\n * @typedef {import('mdast-util-find-and-replace').RegExpMatchObject} RegExpMatchObject\n * @typedef {import('mdast-util-find-and-replace').PhrasingContent} PhrasingContent\n */\n\nimport {ccount} from 'ccount'\nimport {findAndReplace} from 'mdast-util-find-and-replace'\nimport {unicodePunctuation, unicodeWhitespace} from 'micromark-util-character'\n\nconst inConstruct = 'phrasing'\nconst notInConstruct = ['autolink', 'link', 'image', 'label']\n\n/** @type {FromMarkdownExtension} */\nexport const gfmAutolinkLiteralFromMarkdown = {\n  transforms: [transformGfmAutolinkLiterals],\n  enter: {\n    literalAutolink: enterLiteralAutolink,\n    literalAutolinkEmail: enterLiteralAutolinkValue,\n    literalAutolinkHttp: enterLiteralAutolinkValue,\n    literalAutolinkWww: enterLiteralAutolinkValue\n  },\n  exit: {\n    literalAutolink: exitLiteralAutolink,\n    literalAutolinkEmail: exitLiteralAutolinkEmail,\n    literalAutolinkHttp: exitLiteralAutolinkHttp,\n    literalAutolinkWww: exitLiteralAutolinkWww\n  }\n}\n\n/** @type {ToMarkdownExtension} */\nexport const gfmAutolinkLiteralToMarkdown = {\n  unsafe: [\n    {\n      character: '@',\n      before: '[+\\\\-.\\\\w]',\n      after: '[\\\\-.\\\\w]',\n      inConstruct,\n      notInConstruct\n    },\n    {\n      character: '.',\n      before: '[Ww]',\n      after: '[\\\\-.\\\\w]',\n      inConstruct,\n      notInConstruct\n    },\n    {character: ':', before: '[ps]', after: '\\\\/', inConstruct, notInConstruct}\n  ]\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterLiteralAutolink(token) {\n  this.enter({type: 'link', title: null, url: '', children: []}, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterLiteralAutolinkValue(token) {\n  this.config.enter.autolinkProtocol.call(this, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitLiteralAutolinkHttp(token) {\n  this.config.exit.autolinkProtocol.call(this, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitLiteralAutolinkWww(token) {\n  this.config.exit.data.call(this, token)\n  const node = /** @type {Link} */ (this.stack[this.stack.length - 1])\n  node.url = 'http://' + this.sliceSerialize(token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitLiteralAutolinkEmail(token) {\n  this.config.exit.autolinkEmail.call(this, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitLiteralAutolink(token) {\n  this.exit(token)\n}\n\n/** @type {FromMarkdownTransform} */\nfunction transformGfmAutolinkLiterals(tree) {\n  findAndReplace(\n    tree,\n    [\n      [/(https?:\\/\\/|www(?=\\.))([-.\\w]+)([^ \\t\\r\\n]*)/gi, findUrl],\n      [/([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)/g, findEmail]\n    ],\n    {ignore: ['link', 'linkReference']}\n  )\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} protocol\n * @param {string} domain\n * @param {string} path\n * @param {RegExpMatchObject} match\n */\n// eslint-disable-next-line max-params\nfunction findUrl(_, protocol, domain, path, match) {\n  let prefix = ''\n\n  // Not an expected previous character.\n  if (!previous(match)) {\n    return false\n  }\n\n  // Treat `www` as part of the domain.\n  if (/^w/i.test(protocol)) {\n    domain = protocol + domain\n    protocol = ''\n    prefix = 'http://'\n  }\n\n  if (!isCorrectDomain(domain)) {\n    return false\n  }\n\n  const parts = splitUrl(domain + path)\n\n  if (!parts[0]) return false\n\n  /** @type {PhrasingContent} */\n  const result = {\n    type: 'link',\n    title: null,\n    url: prefix + protocol + parts[0],\n    children: [{type: 'text', value: protocol + parts[0]}]\n  }\n\n  if (parts[1]) {\n    return [result, {type: 'text', value: parts[1]}]\n  }\n\n  return result\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} atext\n * @param {string} label\n * @param {RegExpMatchObject} match\n */\nfunction findEmail(_, atext, label, match) {\n  if (\n    // Not an expected previous character.\n    !previous(match, true) ||\n    // Label ends in not allowed character.\n    /[_-\\d]$/.test(label)\n  ) {\n    return false\n  }\n\n  return {\n    type: 'link',\n    title: null,\n    url: 'mailto:' + atext + '@' + label,\n    children: [{type: 'text', value: atext + '@' + label}]\n  }\n}\n\n/**\n * @param {string} domain\n * @returns {boolean}\n */\nfunction isCorrectDomain(domain) {\n  const parts = domain.split('.')\n\n  if (\n    parts.length < 2 ||\n    (parts[parts.length - 1] &&\n      (/_/.test(parts[parts.length - 1]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 1]))) ||\n    (parts[parts.length - 2] &&\n      (/_/.test(parts[parts.length - 2]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 2])))\n  ) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * @param {string} url\n * @returns {[string, string|undefined]}\n */\nfunction splitUrl(url) {\n  const trailExec = /[!\"&'),.:;<>?\\]}]+$/.exec(url)\n  /** @type {number} */\n  let closingParenIndex\n  /** @type {number} */\n  let openingParens\n  /** @type {number} */\n  let closingParens\n  /** @type {string|undefined} */\n  let trail\n\n  if (trailExec) {\n    url = url.slice(0, trailExec.index)\n    trail = trailExec[0]\n    closingParenIndex = trail.indexOf(')')\n    openingParens = ccount(url, '(')\n    closingParens = ccount(url, ')')\n\n    while (closingParenIndex !== -1 && openingParens > closingParens) {\n      url += trail.slice(0, closingParenIndex + 1)\n      trail = trail.slice(closingParenIndex + 1)\n      closingParenIndex = trail.indexOf(')')\n      closingParens++\n    }\n  }\n\n  return [url, trail]\n}\n\n/**\n * @param {RegExpMatchObject} match\n * @param {boolean} [email=false]\n * @returns {boolean}\n */\nfunction previous(match, email) {\n  const code = match.input.charCodeAt(match.index - 1)\n\n  return (\n    (match.index === 0 ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)) &&\n    (!email || code !== 47)\n  )\n}\n","/**\n * @typedef {import('mdast').Association} Association\n */\n\nimport {decodeString} from 'micromark-util-decode-string'\n\n/**\n * The `label` of an association is the string value: character escapes and\n * references work, and casing is intact.\n * The `identifier` is used to match one association to another: controversially,\n * character escapes and references don’t work in this matching: `&copy;` does\n * not match `©`, and `\\+` does not match `+`.\n * But casing is ignored (and whitespace) is trimmed and collapsed: ` A\\nb`\n * matches `a b`.\n * So, we do prefer the label when figuring out how we’re going to serialize:\n * it has whitespace, casing, and we can ignore most useless character escapes\n * and all character references.\n *\n * @param {Association} node\n * @returns {string}\n */\nexport function association(node) {\n  if (node.label || !node.identifier) {\n    return node.label || ''\n  }\n\n  return decodeString(node.identifier)\n}\n","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('../types.js').TrackFields} TrackFields\n */\n\n/**\n * Functions to track output positions.\n * This info isn’t used yet but suchs functionality allows line wrapping,\n * and theoretically source maps (though, is there practical use in that?).\n *\n * @param {TrackFields} options_\n */\nexport function track(options_) {\n  // Defaults are used to prevent crashes when older utilities somehow activate\n  // this code.\n  /* c8 ignore next 5 */\n  const options = options_ || {}\n  const now = options.now || {}\n  let lineShift = options.lineShift || 0\n  let line = now.line || 1\n  let column = now.column || 1\n\n  return {move, current, shift}\n\n  /**\n   * Get the current tracked info.\n   *\n   * @returns {{now: Point, lineShift: number}}\n   */\n  function current() {\n    return {now: {line, column}, lineShift}\n  }\n\n  /**\n   * Define an increased line shift (the typical indent for lines).\n   *\n   * @param {number} value\n   */\n  function shift(value) {\n    lineShift += value\n  }\n\n  /**\n   * Move past a string.\n   *\n   * @param {string} value\n   * @returns {string}\n   */\n  function move(value = '') {\n    const chunks = value.split(/\\r?\\n|\\r/g)\n    const tail = chunks[chunks.length - 1]\n    line += chunks.length - 1\n    column =\n      chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift\n    return value\n  }\n}\n","/**\n * @typedef {import('../types.js').Node} Node\n * @typedef {import('../types.js').Parent} Parent\n * @typedef {import('../types.js').Join} Join\n * @typedef {import('../types.js').Context} Context\n * @typedef {import('../types.js').TrackFields} TrackFields\n */\n\nimport {track} from './track.js'\n\n/**\n * @param {Parent} parent\n * @param {Context} context\n * @param {TrackFields} safeOptions\n * @returns {string}\n */\nexport function containerFlow(parent, context, safeOptions) {\n  const indexStack = context.indexStack\n  const children = parent.children || []\n  const tracker = track(safeOptions)\n  /** @type {Array<string>} */\n  const results = []\n  let index = -1\n\n  indexStack.push(-1)\n\n  while (++index < children.length) {\n    const child = children[index]\n\n    indexStack[indexStack.length - 1] = index\n\n    results.push(\n      tracker.move(\n        context.handle(child, parent, context, {\n          before: '\\n',\n          after: '\\n',\n          ...tracker.current()\n        })\n      )\n    )\n\n    if (child.type !== 'list') {\n      context.bulletLastUsed = undefined\n    }\n\n    if (index < children.length - 1) {\n      results.push(tracker.move(between(child, children[index + 1])))\n    }\n  }\n\n  indexStack.pop()\n\n  return results.join('')\n\n  /**\n   * @param {Node} left\n   * @param {Node} right\n   * @returns {string}\n   */\n  function between(left, right) {\n    let index = context.join.length\n\n    while (index--) {\n      const result = context.join[index](left, right, parent, context)\n\n      if (result === true || result === 1) {\n        break\n      }\n\n      if (typeof result === 'number') {\n        return '\\n'.repeat(1 + result)\n      }\n\n      if (result === false) {\n        return '\\n\\n<!---->\\n\\n'\n      }\n    }\n\n    return '\\n\\n'\n  }\n}\n","/**\n * @callback Map\n * @param {string} value\n * @param {number} line\n * @param {boolean} blank\n * @returns {string}\n */\n\nconst eol = /\\r?\\n|\\r/g\n\n/**\n * @param {string} value\n * @param {Map} map\n * @returns {string}\n */\nexport function indentLines(value, map) {\n  /** @type {Array<string>} */\n  const result = []\n  let start = 0\n  let line = 0\n  /** @type {RegExpExecArray|null} */\n  let match\n\n  while ((match = eol.exec(value))) {\n    one(value.slice(start, match.index))\n    result.push(match[0])\n    start = match.index + match[0].length\n    line++\n  }\n\n  one(value.slice(start))\n\n  return result.join('')\n\n  /**\n   * @param {string} value\n   */\n  function one(value) {\n    result.push(map(value, line, !value))\n  }\n}\n","/**\n * @typedef {import('../types.js').Unsafe} Unsafe\n */\n\n/**\n * @param {Unsafe} pattern\n * @returns {RegExp}\n */\nexport function patternCompile(pattern) {\n  if (!pattern._compiled) {\n    const before =\n      (pattern.atBreak ? '[\\\\r\\\\n][\\\\t ]*' : '') +\n      (pattern.before ? '(?:' + pattern.before + ')' : '')\n\n    pattern._compiled = new RegExp(\n      (before ? '(' + before + ')' : '') +\n        (/[|\\\\{}()[\\]^$+*?.-]/.test(pattern.character) ? '\\\\' : '') +\n        pattern.character +\n        (pattern.after ? '(?:' + pattern.after + ')' : ''),\n      'g'\n    )\n  }\n\n  return pattern._compiled\n}\n","/**\n * @typedef {import('../types.js').Unsafe} Unsafe\n */\n\n/**\n * @param {Array<string>} stack\n * @param {Unsafe} pattern\n * @returns {boolean}\n */\nexport function patternInScope(stack, pattern) {\n  return (\n    listInScope(stack, pattern.inConstruct, true) &&\n    !listInScope(stack, pattern.notInConstruct, false)\n  )\n}\n\n/**\n * @param {Array<string>} stack\n * @param {Unsafe['inConstruct']} list\n * @param {boolean} none\n * @returns {boolean}\n */\nfunction listInScope(stack, list, none) {\n  if (!list) {\n    return none\n  }\n\n  if (typeof list === 'string') {\n    list = [list]\n  }\n\n  let index = -1\n\n  while (++index < list.length) {\n    if (stack.includes(list[index])) {\n      return true\n    }\n  }\n\n  return false\n}\n","/**\n * @typedef {import('../types.js').Context} Context\n * @typedef {import('../types.js').SafeOptions} SafeOptions\n */\n\nimport {patternCompile} from './pattern-compile.js'\nimport {patternInScope} from './pattern-in-scope.js'\n\n/**\n * @param {Context} context\n * @param {string|null|undefined} input\n * @param {SafeOptions & {encode?: Array<string>}} config\n * @returns {string}\n */\nexport function safe(context, input, config) {\n  const value = (config.before || '') + (input || '') + (config.after || '')\n  /** @type {Array<number>} */\n  const positions = []\n  /** @type {Array<string>} */\n  const result = []\n  /** @type {Record<number, {before: boolean, after: boolean}>} */\n  const infos = {}\n  let index = -1\n\n  while (++index < context.unsafe.length) {\n    const pattern = context.unsafe[index]\n\n    if (!patternInScope(context.stack, pattern)) {\n      continue\n    }\n\n    const expression = patternCompile(pattern)\n    /** @type {RegExpExecArray|null} */\n    let match\n\n    while ((match = expression.exec(value))) {\n      const before = 'before' in pattern || Boolean(pattern.atBreak)\n      const after = 'after' in pattern\n      const position = match.index + (before ? match[1].length : 0)\n\n      if (positions.includes(position)) {\n        if (infos[position].before && !before) {\n          infos[position].before = false\n        }\n\n        if (infos[position].after && !after) {\n          infos[position].after = false\n        }\n      } else {\n        positions.push(position)\n        infos[position] = {before, after}\n      }\n    }\n  }\n\n  positions.sort(numerical)\n\n  let start = config.before ? config.before.length : 0\n  const end = value.length - (config.after ? config.after.length : 0)\n  index = -1\n\n  while (++index < positions.length) {\n    const position = positions[index]\n\n    // Character before or after matched:\n    if (position < start || position >= end) {\n      continue\n    }\n\n    // If this character is supposed to be escaped because it has a condition on\n    // the next character, and the next character is definitly being escaped,\n    // then skip this escape.\n    if (\n      (position + 1 < end &&\n        positions[index + 1] === position + 1 &&\n        infos[position].after &&\n        !infos[position + 1].before &&\n        !infos[position + 1].after) ||\n      (positions[index - 1] === position - 1 &&\n        infos[position].before &&\n        !infos[position - 1].before &&\n        !infos[position - 1].after)\n    ) {\n      continue\n    }\n\n    if (start !== position) {\n      // If we have to use a character reference, an ampersand would be more\n      // correct, but as backslashes only care about punctuation, either will\n      // do the trick\n      result.push(escapeBackslashes(value.slice(start, position), '\\\\'))\n    }\n\n    start = position\n\n    if (\n      /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&\n      (!config.encode || !config.encode.includes(value.charAt(position)))\n    ) {\n      // Character escape.\n      result.push('\\\\')\n    } else {\n      // Character reference.\n      result.push(\n        '&#x' + value.charCodeAt(position).toString(16).toUpperCase() + ';'\n      )\n      start++\n    }\n  }\n\n  result.push(escapeBackslashes(value.slice(start, end), config.after))\n\n  return result.join('')\n}\n\n/**\n * @param {number} a\n * @param {number} b\n * @returns {number}\n */\nfunction numerical(a, b) {\n  return a - b\n}\n\n/**\n * @param {string} value\n * @param {string} after\n * @returns {string}\n */\nfunction escapeBackslashes(value, after) {\n  const expression = /\\\\(?=[!-/:-@[-`{-~])/g\n  /** @type {Array<number>} */\n  const positions = []\n  /** @type {Array<string>} */\n  const results = []\n  const whole = value + after\n  let index = -1\n  let start = 0\n  /** @type {RegExpExecArray|null} */\n  let match\n\n  while ((match = expression.exec(whole))) {\n    positions.push(match.index)\n  }\n\n  while (++index < positions.length) {\n    if (start !== positions[index]) {\n      results.push(value.slice(start, positions[index]))\n    }\n\n    results.push('\\\\')\n    start = positions[index]\n  }\n\n  results.push(value.slice(start))\n\n  return results.join('')\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Map} Map\n */\n\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {association} from 'mdast-util-to-markdown/lib/util/association.js'\nimport {containerFlow} from 'mdast-util-to-markdown/lib/util/container-flow.js'\nimport {indentLines} from 'mdast-util-to-markdown/lib/util/indent-lines.js'\nimport {safe} from 'mdast-util-to-markdown/lib/util/safe.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\n/**\n * @returns {FromMarkdownExtension}\n */\nexport function gfmFootnoteFromMarkdown() {\n  return {\n    enter: {\n      gfmFootnoteDefinition: enterFootnoteDefinition,\n      gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,\n      gfmFootnoteCall: enterFootnoteCall,\n      gfmFootnoteCallString: enterFootnoteCallString\n    },\n    exit: {\n      gfmFootnoteDefinition: exitFootnoteDefinition,\n      gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,\n      gfmFootnoteCall: exitFootnoteCall,\n      gfmFootnoteCallString: exitFootnoteCallString\n    }\n  }\n\n  /** @type {FromMarkdownHandle} */\n  function enterFootnoteDefinition(token) {\n    this.enter(\n      {type: 'footnoteDefinition', identifier: '', label: '', children: []},\n      token\n    )\n  }\n\n  /** @type {FromMarkdownHandle} */\n  function enterFootnoteDefinitionLabelString() {\n    this.buffer()\n  }\n\n  /** @type {FromMarkdownHandle} */\n  function exitFootnoteDefinitionLabelString(token) {\n    const label = this.resume()\n    const node = /** @type {FootnoteDefinition} */ (\n      this.stack[this.stack.length - 1]\n    )\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  /** @type {FromMarkdownHandle} */\n  function exitFootnoteDefinition(token) {\n    this.exit(token)\n  }\n\n  /** @type {FromMarkdownHandle} */\n  function enterFootnoteCall(token) {\n    this.enter({type: 'footnoteReference', identifier: '', label: ''}, token)\n  }\n\n  /** @type {FromMarkdownHandle} */\n  function enterFootnoteCallString() {\n    this.buffer()\n  }\n\n  /** @type {FromMarkdownHandle} */\n  function exitFootnoteCallString(token) {\n    const label = this.resume()\n    const node = /** @type {FootnoteDefinition} */ (\n      this.stack[this.stack.length - 1]\n    )\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  /** @type {FromMarkdownHandle} */\n  function exitFootnoteCall(token) {\n    this.exit(token)\n  }\n}\n\n/**\n * @returns {ToMarkdownExtension}\n */\nexport function gfmFootnoteToMarkdown() {\n  footnoteReference.peek = footnoteReferencePeek\n\n  return {\n    // This is on by default already.\n    unsafe: [{character: '[', inConstruct: ['phrasing', 'label', 'reference']}],\n    handlers: {footnoteDefinition, footnoteReference}\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {FootnoteReference} node\n   */\n  function footnoteReference(node, _, context, safeOptions) {\n    const tracker = track(safeOptions)\n    let value = tracker.move('[^')\n    const exit = context.enter('footnoteReference')\n    const subexit = context.enter('reference')\n    value += tracker.move(\n      safe(context, association(node), {\n        ...tracker.current(),\n        before: value,\n        after: ']'\n      })\n    )\n    subexit()\n    exit()\n    value += tracker.move(']')\n    return value\n  }\n\n  /** @type {ToMarkdownHandle} */\n  function footnoteReferencePeek() {\n    return '['\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {FootnoteDefinition} node\n   */\n  function footnoteDefinition(node, _, context, safeOptions) {\n    const tracker = track(safeOptions)\n    let value = tracker.move('[^')\n    const exit = context.enter('footnoteDefinition')\n    const subexit = context.enter('label')\n    value += tracker.move(\n      safe(context, association(node), {\n        ...tracker.current(),\n        before: value,\n        after: ']'\n      })\n    )\n    subexit()\n    value += tracker.move(\n      ']:' + (node.children && node.children.length > 0 ? ' ' : '')\n    )\n    tracker.shift(4)\n    value += tracker.move(\n      indentLines(containerFlow(node, context, tracker.current()), map)\n    )\n    exit()\n\n    return value\n\n    /** @type {Map} */\n    function map(line, index, blank) {\n      if (index) {\n        return (blank ? '' : '    ') + line\n      }\n\n      return line\n    }\n  }\n}\n","/**\n * @typedef {import('../types.js').Node} Node\n * @typedef {import('../types.js').Parent} Parent\n * @typedef {import('../types.js').SafeOptions} SafeOptions\n * @typedef {import('../types.js').Context} Context\n */\n\nimport {track} from './track.js'\n\n/**\n * @param {Parent} parent\n * @param {Context} context\n * @param {SafeOptions} safeOptions\n * @returns {string}\n */\nexport function containerPhrasing(parent, context, safeOptions) {\n  const indexStack = context.indexStack\n  const children = parent.children || []\n  /** @type {Array<string>} */\n  const results = []\n  let index = -1\n  let before = safeOptions.before\n\n  indexStack.push(-1)\n  let tracker = track(safeOptions)\n\n  while (++index < children.length) {\n    const child = children[index]\n    /** @type {string} */\n    let after\n\n    indexStack[indexStack.length - 1] = index\n\n    if (index + 1 < children.length) {\n      // @ts-expect-error: hush, it’s actually a `zwitch`.\n      let handle = context.handle.handlers[children[index + 1].type]\n      if (handle && handle.peek) handle = handle.peek\n      after = handle\n        ? handle(children[index + 1], parent, context, {\n            before: '',\n            after: '',\n            ...tracker.current()\n          }).charAt(0)\n        : ''\n    } else {\n      after = safeOptions.after\n    }\n\n    // In some cases, html (text) can be found in phrasing right after an eol.\n    // When we’d serialize that, in most cases that would be seen as html\n    // (flow).\n    // As we can’t escape or so to prevent it from happening, we take a somewhat\n    // reasonable approach: replace that eol with a space.\n    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>\n    if (\n      results.length > 0 &&\n      (before === '\\r' || before === '\\n') &&\n      child.type === 'html'\n    ) {\n      results[results.length - 1] = results[results.length - 1].replace(\n        /(\\r?\\n|\\r)$/,\n        ' '\n      )\n      before = ' '\n\n      // To do: does this work to reset tracker?\n      tracker = track(safeOptions)\n      tracker.move(results.join(''))\n    }\n\n    results.push(\n      tracker.move(\n        context.handle(child, parent, context, {\n          ...tracker.current(),\n          before,\n          after\n        })\n      )\n    )\n\n    before = results[results.length - 1].slice(-1)\n  }\n\n  indexStack.pop()\n\n  return results.join('')\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n */\n\nimport {containerPhrasing} from 'mdast-util-to-markdown/lib/util/container-phrasing.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\n/** @type {FromMarkdownExtension} */\nexport const gfmStrikethroughFromMarkdown = {\n  canContainEols: ['delete'],\n  enter: {strikethrough: enterStrikethrough},\n  exit: {strikethrough: exitStrikethrough}\n}\n\n/** @type {ToMarkdownExtension} */\nexport const gfmStrikethroughToMarkdown = {\n  unsafe: [{character: '~', inConstruct: 'phrasing'}],\n  handlers: {delete: handleDelete}\n}\n\nhandleDelete.peek = peekDelete\n\n/** @type {FromMarkdownHandle} */\nfunction enterStrikethrough(token) {\n  this.enter({type: 'delete', children: []}, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitStrikethrough(token) {\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {Delete} node\n */\nfunction handleDelete(node, _, context, safeOptions) {\n  const tracker = track(safeOptions)\n  const exit = context.enter('emphasis')\n  let value = tracker.move('~~')\n  value += containerPhrasing(node, context, {\n    ...tracker.current(),\n    before: value,\n    after: '~'\n  })\n  value += tracker.move('~~')\n  exit()\n  return value\n}\n\n/** @type {ToMarkdownHandle} */\nfunction peekDelete() {\n  return '~'\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../types.js').Handle} Handle\n */\n\nimport {patternCompile} from '../util/pattern-compile.js'\n\ninlineCode.peek = inlineCodePeek\n\n/**\n * @type {Handle}\n * @param {InlineCode} node\n */\nexport function inlineCode(node, _, context) {\n  let value = node.value || ''\n  let sequence = '`'\n  let index = -1\n\n  // If there is a single grave accent on its own in the code, use a fence of\n  // two.\n  // If there are two in a row, use one.\n  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {\n    sequence += '`'\n  }\n\n  // If this is not just spaces or eols (tabs don’t count), and either the\n  // first or last character are a space, eol, or tick, then pad with spaces.\n  if (\n    /[^ \\r\\n]/.test(value) &&\n    ((/^[ \\r\\n]/.test(value) && /[ \\r\\n]$/.test(value)) || /^`|`$/.test(value))\n  ) {\n    value = ' ' + value + ' '\n  }\n\n  // We have a potential problem: certain characters after eols could result in\n  // blocks being seen.\n  // For example, if someone injected the string `'\\n# b'`, then that would\n  // result in an ATX heading.\n  // We can’t escape characters in `inlineCode`, but because eols are\n  // transformed to spaces when going from markdown to HTML anyway, we can swap\n  // them out.\n  while (++index < context.unsafe.length) {\n    const pattern = context.unsafe[index]\n    const expression = patternCompile(pattern)\n    /** @type {RegExpExecArray|null} */\n    let match\n\n    // Only look for `atBreak`s.\n    // Btw: note that `atBreak` patterns will always start the regex at LF or\n    // CR.\n    if (!pattern.atBreak) continue\n\n    while ((match = expression.exec(value))) {\n      let position = match.index\n\n      // Support CRLF (patterns only look for one of the characters).\n      if (\n        value.charCodeAt(position) === 10 /* `\\n` */ &&\n        value.charCodeAt(position - 1) === 13 /* `\\r` */\n      ) {\n        position--\n      }\n\n      value = value.slice(0, position) + ' ' + value.slice(match.index + 1)\n    }\n  }\n\n  return sequence + value + sequence\n}\n\n/**\n * @type {Handle}\n */\nfunction inlineCodePeek() {\n  return '`'\n}\n","/**\n * @typedef Options\n *   Configuration (optional).\n * @property {string|null|Array<string|null|undefined>} [align]\n *   One style for all columns, or styles for their respective columns.\n *   Each style is either `'l'` (left), `'r'` (right), or `'c'` (center).\n *   Other values are treated as `''`, which doesn’t place the colon in the\n *   alignment row but does align left.\n *   *Only the lowercased first character is used, so `Right` is fine.*\n * @property {boolean} [padding=true]\n *   Whether to add a space of padding between delimiters and cells.\n *\n *   When `true`, there is padding:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there is no padding:\n *\n *   ```markdown\n *   |Alpha|B    |\n *   |-----|-----|\n *   |C    |Delta|\n *   ```\n * @property {boolean} [delimiterStart=true]\n *   Whether to begin each row with the delimiter.\n *\n *   > 👉 **Note**: please don’t use this: it could create fragile structures\n *   > that aren’t understandable to some markdown parsers.\n *\n *   When `true`, there are starting delimiters:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there are no starting delimiters:\n *\n *   ```markdown\n *   Alpha | B     |\n *   ----- | ----- |\n *   C     | Delta |\n *   ```\n * @property {boolean} [delimiterEnd=true]\n *   Whether to end each row with the delimiter.\n *\n *   > 👉 **Note**: please don’t use this: it could create fragile structures\n *   > that aren’t understandable to some markdown parsers.\n *\n *   When `true`, there are ending delimiters:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there are no ending delimiters:\n *\n *   ```markdown\n *   | Alpha | B\n *   | ----- | -----\n *   | C     | Delta\n *   ```\n * @property {boolean} [alignDelimiters=true]\n *   Whether to align the delimiters.\n *   By default, they are aligned:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   Pass `false` to make them staggered:\n *\n *   ```markdown\n *   | Alpha | B |\n *   | - | - |\n *   | C | Delta |\n *   ```\n * @property {(value: string) => number} [stringLength]\n *   Function to detect the length of table cell content.\n *   This is used when aligning the delimiters (`|`) between table cells.\n *   Full-width characters and emoji mess up delimiter alignment when viewing\n *   the markdown source.\n *   To fix this, you can pass this function, which receives the cell content\n *   and returns its “visible” size.\n *   Note that what is and isn’t visible depends on where the text is displayed.\n *\n *   Without such a function, the following:\n *\n *   ```js\n *   markdownTable([\n *     ['Alpha', 'Bravo'],\n *     ['中文', 'Charlie'],\n *     ['👩‍❤️‍👩', 'Delta']\n *   ])\n *   ```\n *\n *   Yields:\n *\n *   ```markdown\n *   | Alpha | Bravo |\n *   | - | - |\n *   | 中文 | Charlie |\n *   | 👩‍❤️‍👩 | Delta |\n *   ```\n *\n *   With [`string-width`](https://github.com/sindresorhus/string-width):\n *\n *   ```js\n *   import stringWidth from 'string-width'\n *\n *   markdownTable(\n *     [\n *       ['Alpha', 'Bravo'],\n *       ['中文', 'Charlie'],\n *       ['👩‍❤️‍👩', 'Delta']\n *     ],\n *     {stringLength: stringWidth}\n *   )\n *   ```\n *\n *   Yields:\n *\n *   ```markdown\n *   | Alpha | Bravo   |\n *   | ----- | ------- |\n *   | 中文  | Charlie |\n *   | 👩‍❤️‍👩    | Delta   |\n *   ```\n */\n\n/**\n * @typedef {Options} MarkdownTableOptions\n * @todo\n *   Remove next major.\n */\n\n/**\n * Generate a markdown ([GFM](https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/organizing-information-with-tables)) table..\n *\n * @param {Array<Array<string|null|undefined>>} table\n *   Table data (matrix of strings).\n * @param {Options} [options]\n *   Configuration (optional).\n * @returns {string}\n */\nexport function markdownTable(table, options = {}) {\n  const align = (options.align || []).concat()\n  const stringLength = options.stringLength || defaultStringLength\n  /** @type {Array<number>} Character codes as symbols for alignment per column. */\n  const alignments = []\n  /** @type {Array<Array<string>>} Cells per row. */\n  const cellMatrix = []\n  /** @type {Array<Array<number>>} Sizes of each cell per row. */\n  const sizeMatrix = []\n  /** @type {Array<number>} */\n  const longestCellByColumn = []\n  let mostCellsPerRow = 0\n  let rowIndex = -1\n\n  // This is a superfluous loop if we don’t align delimiters, but otherwise we’d\n  // do superfluous work when aligning, so optimize for aligning.\n  while (++rowIndex < table.length) {\n    /** @type {Array<string>} */\n    const row = []\n    /** @type {Array<number>} */\n    const sizes = []\n    let columnIndex = -1\n\n    if (table[rowIndex].length > mostCellsPerRow) {\n      mostCellsPerRow = table[rowIndex].length\n    }\n\n    while (++columnIndex < table[rowIndex].length) {\n      const cell = serialize(table[rowIndex][columnIndex])\n\n      if (options.alignDelimiters !== false) {\n        const size = stringLength(cell)\n        sizes[columnIndex] = size\n\n        if (\n          longestCellByColumn[columnIndex] === undefined ||\n          size > longestCellByColumn[columnIndex]\n        ) {\n          longestCellByColumn[columnIndex] = size\n        }\n      }\n\n      row.push(cell)\n    }\n\n    cellMatrix[rowIndex] = row\n    sizeMatrix[rowIndex] = sizes\n  }\n\n  // Figure out which alignments to use.\n  let columnIndex = -1\n\n  if (typeof align === 'object' && 'length' in align) {\n    while (++columnIndex < mostCellsPerRow) {\n      alignments[columnIndex] = toAlignment(align[columnIndex])\n    }\n  } else {\n    const code = toAlignment(align)\n\n    while (++columnIndex < mostCellsPerRow) {\n      alignments[columnIndex] = code\n    }\n  }\n\n  // Inject the alignment row.\n  columnIndex = -1\n  /** @type {Array<string>} */\n  const row = []\n  /** @type {Array<number>} */\n  const sizes = []\n\n  while (++columnIndex < mostCellsPerRow) {\n    const code = alignments[columnIndex]\n    let before = ''\n    let after = ''\n\n    if (code === 99 /* `c` */) {\n      before = ':'\n      after = ':'\n    } else if (code === 108 /* `l` */) {\n      before = ':'\n    } else if (code === 114 /* `r` */) {\n      after = ':'\n    }\n\n    // There *must* be at least one hyphen-minus in each alignment cell.\n    let size =\n      options.alignDelimiters === false\n        ? 1\n        : Math.max(\n            1,\n            longestCellByColumn[columnIndex] - before.length - after.length\n          )\n\n    const cell = before + '-'.repeat(size) + after\n\n    if (options.alignDelimiters !== false) {\n      size = before.length + size + after.length\n\n      if (size > longestCellByColumn[columnIndex]) {\n        longestCellByColumn[columnIndex] = size\n      }\n\n      sizes[columnIndex] = size\n    }\n\n    row[columnIndex] = cell\n  }\n\n  // Inject the alignment row.\n  cellMatrix.splice(1, 0, row)\n  sizeMatrix.splice(1, 0, sizes)\n\n  rowIndex = -1\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (++rowIndex < cellMatrix.length) {\n    const row = cellMatrix[rowIndex]\n    const sizes = sizeMatrix[rowIndex]\n    columnIndex = -1\n    /** @type {Array<string>} */\n    const line = []\n\n    while (++columnIndex < mostCellsPerRow) {\n      const cell = row[columnIndex] || ''\n      let before = ''\n      let after = ''\n\n      if (options.alignDelimiters !== false) {\n        const size =\n          longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0)\n        const code = alignments[columnIndex]\n\n        if (code === 114 /* `r` */) {\n          before = ' '.repeat(size)\n        } else if (code === 99 /* `c` */) {\n          if (size % 2) {\n            before = ' '.repeat(size / 2 + 0.5)\n            after = ' '.repeat(size / 2 - 0.5)\n          } else {\n            before = ' '.repeat(size / 2)\n            after = before\n          }\n        } else {\n          after = ' '.repeat(size)\n        }\n      }\n\n      if (options.delimiterStart !== false && !columnIndex) {\n        line.push('|')\n      }\n\n      if (\n        options.padding !== false &&\n        // Don’t add the opening space if we’re not aligning and the cell is\n        // empty: there will be a closing space.\n        !(options.alignDelimiters === false && cell === '') &&\n        (options.delimiterStart !== false || columnIndex)\n      ) {\n        line.push(' ')\n      }\n\n      if (options.alignDelimiters !== false) {\n        line.push(before)\n      }\n\n      line.push(cell)\n\n      if (options.alignDelimiters !== false) {\n        line.push(after)\n      }\n\n      if (options.padding !== false) {\n        line.push(' ')\n      }\n\n      if (\n        options.delimiterEnd !== false ||\n        columnIndex !== mostCellsPerRow - 1\n      ) {\n        line.push('|')\n      }\n    }\n\n    lines.push(\n      options.delimiterEnd === false\n        ? line.join('').replace(/ +$/, '')\n        : line.join('')\n    )\n  }\n\n  return lines.join('\\n')\n}\n\n/**\n * @param {string|null|undefined} [value]\n * @returns {string}\n */\nfunction serialize(value) {\n  return value === null || value === undefined ? '' : String(value)\n}\n\n/**\n * @param {string} value\n * @returns {number}\n */\nfunction defaultStringLength(value) {\n  return value.length\n}\n\n/**\n * @param {string|null|undefined} value\n * @returns {number}\n */\nfunction toAlignment(value) {\n  const code = typeof value === 'string' ? value.codePointAt(0) : 0\n\n  return code === 67 /* `C` */ || code === 99 /* `c` */\n    ? 99 /* `c` */\n    : code === 76 /* `L` */ || code === 108 /* `l` */\n    ? 108 /* `l` */\n    : code === 82 /* `R` */ || code === 114 /* `r` */\n    ? 114 /* `r` */\n    : 0\n}\n","/**\n * @typedef {import('mdast').AlignType} AlignType\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('markdown-table').MarkdownTableOptions} MarkdownTableOptions\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Context} ToMarkdownContext\n * @typedef {import('mdast-util-to-markdown').SafeOptions} SafeOptions\n *\n * @typedef Options\n * @property {boolean} [tableCellPadding=true]\n * @property {boolean} [tablePipeAlign=true]\n * @property {MarkdownTableOptions['stringLength']} [stringLength]\n */\n\nimport {containerPhrasing} from 'mdast-util-to-markdown/lib/util/container-phrasing.js'\nimport {inlineCode} from 'mdast-util-to-markdown/lib/handle/inline-code.js'\nimport {markdownTable} from 'markdown-table'\n\n/** @type {FromMarkdownExtension} */\nexport const gfmTableFromMarkdown = {\n  enter: {\n    table: enterTable,\n    tableData: enterCell,\n    tableHeader: enterCell,\n    tableRow: enterRow\n  },\n  exit: {\n    codeText: exitCodeText,\n    table: exitTable,\n    tableData: exit,\n    tableHeader: exit,\n    tableRow: exit\n  }\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterTable(token) {\n  /** @type {Array<'left'|'right'|'center'|'none'>} */\n  // @ts-expect-error: `align` is custom.\n  const align = token._align\n  this.enter(\n    {\n      type: 'table',\n      align: align.map((d) => (d === 'none' ? null : d)),\n      children: []\n    },\n    token\n  )\n  this.setData('inTable', true)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitTable(token) {\n  this.exit(token)\n  this.setData('inTable')\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterRow(token) {\n  this.enter({type: 'tableRow', children: []}, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exit(token) {\n  this.exit(token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterCell(token) {\n  this.enter({type: 'tableCell', children: []}, token)\n}\n\n// Overwrite the default code text data handler to unescape escaped pipes when\n// they are in tables.\n/** @type {FromMarkdownHandle} */\nfunction exitCodeText(token) {\n  let value = this.resume()\n\n  if (this.getData('inTable')) {\n    value = value.replace(/\\\\([\\\\|])/g, replace)\n  }\n\n  const node = /** @type {InlineCode} */ (this.stack[this.stack.length - 1])\n  node.value = value\n  this.exit(token)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @returns {string}\n */\nfunction replace($0, $1) {\n  // Pipes work, backslashes don’t (but can’t escape pipes).\n  return $1 === '|' ? $1 : $0\n}\n\n/**\n * @param {Options} [options]\n * @returns {ToMarkdownExtension}\n */\nexport function gfmTableToMarkdown(options) {\n  const settings = options || {}\n  const padding = settings.tableCellPadding\n  const alignDelimiters = settings.tablePipeAlign\n  const stringLength = settings.stringLength\n  const around = padding ? ' ' : '|'\n\n  return {\n    unsafe: [\n      {character: '\\r', inConstruct: 'tableCell'},\n      {character: '\\n', inConstruct: 'tableCell'},\n      // A pipe, when followed by a tab or space (padding), or a dash or colon\n      // (unpadded delimiter row), could result in a table.\n      {atBreak: true, character: '|', after: '[\\t :-]'},\n      // A pipe in a cell must be encoded.\n      {character: '|', inConstruct: 'tableCell'},\n      // A colon must be followed by a dash, in which case it could start a\n      // delimiter row.\n      {atBreak: true, character: ':', after: '-'},\n      // A delimiter row can also start with a dash, when followed by more\n      // dashes, a colon, or a pipe.\n      // This is a stricter version than the built in check for lists, thematic\n      // breaks, and setex heading underlines though:\n      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>\n      {atBreak: true, character: '-', after: '[:|-]'}\n    ],\n    handlers: {\n      table: handleTable,\n      tableRow: handleTableRow,\n      tableCell: handleTableCell,\n      inlineCode: inlineCodeWithTable\n    }\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {Table} node\n   */\n  function handleTable(node, _, context, safeOptions) {\n    return serializeData(\n      handleTableAsData(node, context, safeOptions),\n      // @ts-expect-error: fixed in `markdown-table@3.0.1`.\n      node.align\n    )\n  }\n\n  /**\n   * This function isn’t really used normally, because we handle rows at the\n   * table level.\n   * But, if someone passes in a table row, this ensures we make somewhat sense.\n   *\n   * @type {ToMarkdownHandle}\n   * @param {TableRow} node\n   */\n  function handleTableRow(node, _, context, safeOptions) {\n    const row = handleTableRowAsData(node, context, safeOptions)\n    // `markdown-table` will always add an align row\n    const value = serializeData([row])\n    return value.slice(0, value.indexOf('\\n'))\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {TableCell} node\n   */\n  function handleTableCell(node, _, context, safeOptions) {\n    const exit = context.enter('tableCell')\n    const subexit = context.enter('phrasing')\n    const value = containerPhrasing(node, context, {\n      ...safeOptions,\n      before: around,\n      after: around\n    })\n    subexit()\n    exit()\n    return value\n  }\n\n  /**\n   * @param {Array<Array<string>>} matrix\n   * @param {Array<string>} [align]\n   */\n  function serializeData(matrix, align) {\n    return markdownTable(matrix, {\n      align,\n      alignDelimiters,\n      padding,\n      stringLength\n    })\n  }\n\n  /**\n   * @param {Table} node\n   * @param {ToMarkdownContext} context\n   * @param {SafeOptions} safeOptions\n   */\n  function handleTableAsData(node, context, safeOptions) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<Array<string>>} */\n    const result = []\n    const subexit = context.enter('table')\n\n    while (++index < children.length) {\n      result[index] = handleTableRowAsData(\n        children[index],\n        context,\n        safeOptions\n      )\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @param {TableRow} node\n   * @param {ToMarkdownContext} context\n   * @param {SafeOptions} safeOptions\n   */\n  function handleTableRowAsData(node, context, safeOptions) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<string>} */\n    const result = []\n    const subexit = context.enter('tableRow')\n\n    while (++index < children.length) {\n      // Note: the positional info as used here is incorrect.\n      // Making it correct would be impossible due to aligning cells?\n      // And it would need copy/pasting `markdown-table` into this project.\n      result[index] = handleTableCell(\n        children[index],\n        node,\n        context,\n        safeOptions\n      )\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {InlineCode} node\n   */\n  function inlineCodeWithTable(node, parent, context) {\n    let value = inlineCode(node, parent, context)\n\n    if (context.stack.includes('tableCell')) {\n      value = value.replace(/\\|/g, '\\\\$&')\n    }\n\n    return value\n  }\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').List} List\n * @typedef {import('../util/indent-lines.js').Map} Map\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').Handle} Handle\n */\n\nimport {checkBullet} from '../util/check-bullet.js'\nimport {checkListItemIndent} from '../util/check-list-item-indent.js'\nimport {containerFlow} from '../util/container-flow.js'\nimport {indentLines} from '../util/indent-lines.js'\nimport {track} from '../util/track.js'\n\n/**\n * @type {Handle}\n * @param {ListItem} node\n */\nexport function listItem(node, parent, context, safeOptions) {\n  const listItemIndent = checkListItemIndent(context)\n  let bullet = context.bulletCurrent || checkBullet(context)\n\n  // Add the marker value for ordered lists.\n  if (parent && parent.type === 'list' && parent.ordered) {\n    bullet =\n      (typeof parent.start === 'number' && parent.start > -1\n        ? parent.start\n        : 1) +\n      (context.options.incrementListMarker === false\n        ? 0\n        : parent.children.indexOf(node)) +\n      bullet\n  }\n\n  let size = bullet.length + 1\n\n  if (\n    listItemIndent === 'tab' ||\n    (listItemIndent === 'mixed' &&\n      ((parent && parent.type === 'list' && parent.spread) || node.spread))\n  ) {\n    size = Math.ceil(size / 4) * 4\n  }\n\n  const tracker = track(safeOptions)\n  tracker.move(bullet + ' '.repeat(size - bullet.length))\n  tracker.shift(size)\n  const exit = context.enter('listItem')\n  const value = indentLines(\n    containerFlow(node, context, tracker.current()),\n    map\n  )\n  exit()\n\n  return value\n\n  /** @type {Map} */\n  function map(line, index, blank) {\n    if (index) {\n      return (blank ? '' : ' '.repeat(size)) + line\n    }\n\n    return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line\n  }\n}\n","/**\n * @typedef {import('../types.js').Context} Context\n * @typedef {import('../types.js').Options} Options\n */\n\n/**\n * @param {Context} context\n * @returns {Exclude<Options['listItemIndent'], undefined>}\n */\nexport function checkListItemIndent(context) {\n  const style = context.options.listItemIndent || 'tab'\n\n  // To do: remove in a major.\n  // @ts-expect-error: deprecated.\n  if (style === 1 || style === '1') {\n    return 'one'\n  }\n\n  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        style +\n        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'\n    )\n  }\n\n  return style\n}\n","/**\n * @typedef {import('../types.js').Context} Context\n * @typedef {import('../types.js').Options} Options\n */\n\n/**\n * @param {Context} context\n * @returns {Exclude<Options['bullet'], undefined>}\n */\nexport function checkBullet(context) {\n  const marker = context.options.bullet || '*'\n\n  if (marker !== '*' && marker !== '+' && marker !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bullet`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @typedef {Extract<import('mdast').Root|import('mdast').Content, import('unist').Parent>} Parent\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').BlockContent} BlockContent\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n */\n\nimport {listItem} from 'mdast-util-to-markdown/lib/handle/list-item.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\n/** @type {FromMarkdownExtension} */\nexport const gfmTaskListItemFromMarkdown = {\n  exit: {\n    taskListCheckValueChecked: exitCheck,\n    taskListCheckValueUnchecked: exitCheck,\n    paragraph: exitParagraphWithTaskListItem\n  }\n}\n\n/** @type {ToMarkdownExtension} */\nexport const gfmTaskListItemToMarkdown = {\n  unsafe: [{atBreak: true, character: '-', after: '[:|-]'}],\n  handlers: {listItem: listItemWithTaskListItem}\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitCheck(token) {\n  const node = /** @type {ListItem} */ (this.stack[this.stack.length - 2])\n  // We’re always in a paragraph, in a list item.\n  node.checked = token.type === 'taskListCheckValueChecked'\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitParagraphWithTaskListItem(token) {\n  const parent = /** @type {Parent} */ (this.stack[this.stack.length - 2])\n  const node = /** @type {Paragraph} */ (this.stack[this.stack.length - 1])\n  const siblings = parent.children\n  const head = node.children[0]\n  let index = -1\n  /** @type {Paragraph|undefined} */\n  let firstParaghraph\n\n  if (\n    parent &&\n    parent.type === 'listItem' &&\n    typeof parent.checked === 'boolean' &&\n    head &&\n    head.type === 'text'\n  ) {\n    while (++index < siblings.length) {\n      const sibling = siblings[index]\n      if (sibling.type === 'paragraph') {\n        firstParaghraph = sibling\n        break\n      }\n    }\n\n    if (firstParaghraph === node) {\n      // Must start with a space or a tab.\n      head.value = head.value.slice(1)\n\n      if (head.value.length === 0) {\n        node.children.shift()\n      } else if (\n        node.position &&\n        head.position &&\n        typeof head.position.start.offset === 'number'\n      ) {\n        head.position.start.column++\n        head.position.start.offset++\n        node.position.start = Object.assign({}, head.position.start)\n      }\n    }\n  }\n\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {ListItem} node\n */\nfunction listItemWithTaskListItem(node, parent, context, safeOptions) {\n  const head = node.children[0]\n  const checkable =\n    typeof node.checked === 'boolean' && head && head.type === 'paragraph'\n  const checkbox = '[' + (node.checked ? 'x' : ' ') + '] '\n  const tracker = track(safeOptions)\n\n  if (checkable) {\n    tracker.move(checkbox)\n  }\n\n  let value = listItem(node, parent, context, {\n    ...safeOptions,\n    ...tracker.current()\n  })\n\n  if (checkable) {\n    value = value.replace(/^(?:[*+-]|\\d+\\.)([\\r\\n]| {1,3})/, check)\n  }\n\n  return value\n\n  /**\n   * @param {string} $0\n   * @returns {string}\n   */\n  function check($0) {\n    return $0 + checkbox\n  }\n}\n","/**\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n *\n * @typedef {import('mdast-util-gfm-table').Options} Options\n */\n\nimport {\n  gfmAutolinkLiteralFromMarkdown,\n  gfmAutolinkLiteralToMarkdown\n} from 'mdast-util-gfm-autolink-literal'\nimport {\n  gfmFootnoteFromMarkdown,\n  gfmFootnoteToMarkdown\n} from 'mdast-util-gfm-footnote'\nimport {\n  gfmStrikethroughFromMarkdown,\n  gfmStrikethroughToMarkdown\n} from 'mdast-util-gfm-strikethrough'\nimport {gfmTableFromMarkdown, gfmTableToMarkdown} from 'mdast-util-gfm-table'\nimport {\n  gfmTaskListItemFromMarkdown,\n  gfmTaskListItemToMarkdown\n} from 'mdast-util-gfm-task-list-item'\n\n/**\n * @returns {Array<FromMarkdownExtension>}\n */\nexport function gfmFromMarkdown() {\n  return [\n    gfmAutolinkLiteralFromMarkdown,\n    gfmFootnoteFromMarkdown(),\n    gfmStrikethroughFromMarkdown,\n    gfmTableFromMarkdown,\n    gfmTaskListItemFromMarkdown\n  ]\n}\n\n/**\n * @param {Options} [options]\n * @returns {ToMarkdownExtension}\n */\nexport function gfmToMarkdown(options) {\n  return {\n    extensions: [\n      gfmAutolinkLiteralToMarkdown,\n      gfmFootnoteToMarkdown(),\n      gfmStrikethroughToMarkdown,\n      gfmTableToMarkdown(options),\n      gfmTaskListItemToMarkdown\n    ]\n  }\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('micromark-extension-gfm').Options & import('mdast-util-gfm').Options} Options\n */\n\nimport {gfm} from 'micromark-extension-gfm'\nimport {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'\n\n/**\n * Plugin to support GFM (autolink literals, footnotes, strikethrough, tables, tasklists).\n *\n * @type {import('unified').Plugin<[Options?]|void[], Root>}\n */\nexport default function remarkGfm(options = {}) {\n  const data = this.data()\n\n  add('micromarkExtensions', gfm(options))\n  add('fromMarkdownExtensions', gfmFromMarkdown())\n  add('toMarkdownExtensions', gfmToMarkdown(options))\n\n  /**\n   * @param {string} field\n   * @param {unknown} value\n   */\n  function add(field, value) {\n    const list = /** @type {unknown[]} */ (\n      // Other extensions\n      /* c8 ignore next 2 */\n      data[field] ? data[field] : (data[field] = [])\n    )\n\n    list.push(value)\n  }\n}\n","/**\n * @typedef {import('./core.js').HChild} Child\n * @typedef {import('./core.js').HProperties} Properties\n *\n * @typedef {import('./jsx-classic').Element} s.JSX.Element\n * @typedef {import('./jsx-classic').IntrinsicAttributes} s.JSX.IntrinsicAttributes\n * @typedef {import('./jsx-classic').IntrinsicElements} s.JSX.IntrinsicElements\n * @typedef {import('./jsx-classic').ElementChildrenAttribute} s.JSX.ElementChildrenAttribute\n */\n\nimport {svg} from 'property-information'\nimport {core} from './core.js'\nimport {svgCaseSensitiveTagNames} from './svg-case-sensitive-tag-names.js'\n\nexport const s = core(svg, 'g', svgCaseSensitiveTagNames)\n","export const svgCaseSensitiveTagNames = [\n  'altGlyph',\n  'altGlyphDef',\n  'altGlyphItem',\n  'animateColor',\n  'animateMotion',\n  'animateTransform',\n  'clipPath',\n  'feBlend',\n  'feColorMatrix',\n  'feComponentTransfer',\n  'feComposite',\n  'feConvolveMatrix',\n  'feDiffuseLighting',\n  'feDisplacementMap',\n  'feDistantLight',\n  'feDropShadow',\n  'feFlood',\n  'feFuncA',\n  'feFuncB',\n  'feFuncG',\n  'feFuncR',\n  'feGaussianBlur',\n  'feImage',\n  'feMerge',\n  'feMergeNode',\n  'feMorphology',\n  'feOffset',\n  'fePointLight',\n  'feSpecularLighting',\n  'feSpotLight',\n  'feTile',\n  'feTurbulence',\n  'foreignObject',\n  'glyphRef',\n  'linearGradient',\n  'radialGradient',\n  'solidColor',\n  'textArea',\n  'textPath'\n]\n","/**\n * Map of web namespaces.\n *\n * @type {Record<string, string>}\n */\nexport const webNamespaces = {\n  html: 'http://www.w3.org/1999/xhtml',\n  mathml: 'http://www.w3.org/1998/Math/MathML',\n  svg: 'http://www.w3.org/2000/svg',\n  xlink: 'http://www.w3.org/1999/xlink',\n  xml: 'http://www.w3.org/XML/1998/namespace',\n  xmlns: 'http://www.w3.org/2000/xmlns/'\n}\n","/**\n * @typedef {import('vfile').VFile} VFile\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {import('hast').Parent} Parent\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n * @typedef {Parent['children'][number]} Child\n * @typedef {Element['children'][number]} ElementChild\n * @typedef {Child|Root} Node\n * @typedef {import('parse5').Document} P5Document\n * @typedef {import('parse5').DocumentType} P5Doctype\n * @typedef {import('parse5').CommentNode} P5Comment\n * @typedef {import('parse5').TextNode} P5Text\n * @typedef {import('parse5').Element} P5Element\n * @typedef {import('parse5').ElementLocation} P5ElementLocation\n * @typedef {import('parse5').Location} P5Location\n * @typedef {import('parse5').Attribute} P5Attribute\n * @typedef {import('parse5').Node} P5Node\n *\n * @typedef {'html'|'svg'} Space\n *\n * @callback Handler\n * @param {Context} ctx\n * @param {P5Node} node\n * @param {Array.<Child>} [children]\n * @returns {Node}\n *\n * @typedef Options\n * @property {Space} [space='html'] Whether the root of the tree is in the `'html'` or `'svg'` space. If an element in with the SVG namespace is found in `ast`, `fromParse5` automatically switches to the SVG space when entering the element, and switches back when leaving\n * @property {VFile} [file] `VFile`, used to add positional information to nodes. If given, the file should have the original HTML source as its contents\n * @property {boolean} [verbose=false] Whether to add extra positional information about starting tags, closing tags, and attributes to elements. Note: not used without `file`\n *\n * @typedef Context\n * @property {Schema} schema\n * @property {VFile|undefined} file\n * @property {boolean|undefined} verbose\n * @property {boolean} location\n */\n\nimport {h, s} from 'hastscript'\nimport {html, svg, find} from 'property-information'\nimport {location} from 'vfile-location'\nimport {webNamespaces} from 'web-namespaces'\n\nconst own = {}.hasOwnProperty\n\n// Handlers.\nconst map = {\n  '#document': root,\n  '#document-fragment': root,\n  '#text': text,\n  '#comment': comment,\n  '#documentType': doctype\n}\n\n/**\n * Transform Parse5’s AST to a hast tree.\n *\n * @param {P5Node} ast\n * @param {Options|VFile} [options]\n */\nexport function fromParse5(ast, options = {}) {\n  /** @type {Options} */\n  let settings\n  /** @type {VFile|undefined} */\n  let file\n\n  if (isFile(options)) {\n    file = options\n    settings = {}\n  } else {\n    file = options.file\n    settings = options\n  }\n\n  return transform(\n    {\n      schema: settings.space === 'svg' ? svg : html,\n      file,\n      verbose: settings.verbose,\n      location: false\n    },\n    ast\n  )\n}\n\n/**\n * Transform children.\n *\n * @param {Context} ctx\n * @param {P5Node} ast\n * @returns {Node}\n */\nfunction transform(ctx, ast) {\n  const schema = ctx.schema\n  /** @type {Handler} */\n  // @ts-expect-error: index is fine.\n  const fn = own.call(map, ast.nodeName) ? map[ast.nodeName] : element\n  /** @type {Array.<Child>|undefined} */\n  let children\n\n  // Element.\n  if ('tagName' in ast) {\n    ctx.schema = ast.namespaceURI === webNamespaces.svg ? svg : html\n  }\n\n  if ('childNodes' in ast) {\n    children = nodes(ctx, ast.childNodes)\n  }\n\n  const result = fn(ctx, ast, children)\n\n  if ('sourceCodeLocation' in ast && ast.sourceCodeLocation && ctx.file) {\n    // @ts-expect-error It’s fine.\n    const position = createLocation(ctx, result, ast.sourceCodeLocation)\n\n    if (position) {\n      ctx.location = true\n      result.position = position\n    }\n  }\n\n  ctx.schema = schema\n\n  return result\n}\n\n/**\n * Transform children.\n *\n * @param {Context} ctx\n * @param {Array.<P5Node>} children\n * @returns {Array.<Child>}\n */\nfunction nodes(ctx, children) {\n  let index = -1\n  /** @type {Array.<Child>} */\n  const result = []\n\n  while (++index < children.length) {\n    // @ts-expect-error Assume no roots in children.\n    result[index] = transform(ctx, children[index])\n  }\n\n  return result\n}\n\n/**\n * Transform a document.\n * Stores `ast.quirksMode` in `node.data.quirksMode`.\n *\n * @type {Handler}\n * @param {P5Document} ast\n * @param {Array.<Child>} children\n * @returns {Root}\n */\nfunction root(ctx, ast, children) {\n  /** @type {Root} */\n  const result = {\n    type: 'root',\n    children,\n    data: {quirksMode: ast.mode === 'quirks' || ast.mode === 'limited-quirks'}\n  }\n\n  if (ctx.file && ctx.location) {\n    const doc = String(ctx.file)\n    const loc = location(doc)\n    result.position = {\n      start: loc.toPoint(0),\n      end: loc.toPoint(doc.length)\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform a doctype.\n *\n * @type {Handler}\n * @returns {Doctype}\n */\nfunction doctype() {\n  // @ts-expect-error Types are out of date.\n  return {type: 'doctype'}\n}\n\n/**\n * Transform a text.\n *\n * @type {Handler}\n * @param {P5Text} ast\n * @returns {Text}\n */\nfunction text(_, ast) {\n  return {type: 'text', value: ast.value}\n}\n\n/**\n * Transform a comment.\n *\n * @type {Handler}\n * @param {P5Comment} ast\n * @returns {Comment}\n */\nfunction comment(_, ast) {\n  return {type: 'comment', value: ast.data}\n}\n\n/**\n * Transform an element.\n *\n * @type {Handler}\n * @param {P5Element} ast\n * @param {Array.<ElementChild>} children\n * @returns {Element}\n */\nfunction element(ctx, ast, children) {\n  const fn = ctx.schema.space === 'svg' ? s : h\n  let index = -1\n  /** @type {Object.<string, string>} */\n  const props = {}\n\n  while (++index < ast.attrs.length) {\n    const attribute = ast.attrs[index]\n    props[(attribute.prefix ? attribute.prefix + ':' : '') + attribute.name] =\n      attribute.value\n  }\n\n  const result = fn(ast.tagName, props, children)\n\n  if (result.tagName === 'template' && 'content' in ast) {\n    const pos = ast.sourceCodeLocation\n    const startTag = pos && pos.startTag && position(pos.startTag)\n    const endTag = pos && pos.endTag && position(pos.endTag)\n\n    /** @type {Root} */\n    // @ts-expect-error Types are wrong.\n    const content = transform(ctx, ast.content)\n\n    if (startTag && endTag && ctx.file) {\n      content.position = {start: startTag.end, end: endTag.start}\n    }\n\n    result.content = content\n  }\n\n  return result\n}\n\n/**\n * Create clean positional information.\n *\n * @param {Context} ctx\n * @param {Node} node\n * @param {P5ElementLocation} location\n * @returns {Position|null}\n */\nfunction createLocation(ctx, node, location) {\n  const result = position(location)\n\n  if (node.type === 'element') {\n    const tail = node.children[node.children.length - 1]\n\n    // Bug for unclosed with children.\n    // See: <https://github.com/inikulin/parse5/issues/109>.\n    if (\n      result &&\n      !location.endTag &&\n      tail &&\n      tail.position &&\n      tail.position.end\n    ) {\n      result.end = Object.assign({}, tail.position.end)\n    }\n\n    if (ctx.verbose) {\n      /** @type {Object.<string, Position|null>} */\n      const props = {}\n      /** @type {string} */\n      let key\n\n      for (key in location.attrs) {\n        if (own.call(location.attrs, key)) {\n          props[find(ctx.schema, key).property] = position(location.attrs[key])\n        }\n      }\n\n      node.data = {\n        position: {\n          opening: position(location.startTag),\n          closing: location.endTag ? position(location.endTag) : null,\n          properties: props\n        }\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * @param {P5Location} loc\n * @returns {Position|null}\n */\nfunction position(loc) {\n  const start = point({\n    line: loc.startLine,\n    column: loc.startCol,\n    offset: loc.startOffset\n  })\n  const end = point({\n    line: loc.endLine,\n    column: loc.endCol,\n    offset: loc.endOffset\n  })\n  // @ts-expect-error `null` is fine.\n  return start || end ? {start, end} : null\n}\n\n/**\n * @param {Point} point\n * @returns {Point|null}\n */\nfunction point(point) {\n  return point.line && point.column ? point : null\n}\n\n/**\n * @param {VFile|Options} value\n * @returns {value is VFile}\n */\nfunction isFile(value) {\n  return 'messages' in value\n}\n","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {Pick<Point, 'line'|'column'>} PositionalPoint\n * @typedef {Required<Point>} FullPoint\n * @typedef {NonNullable<Point['offset']>} Offset\n */\n\n/**\n * Get transform functions for the given `document`.\n *\n * @param {string|Uint8Array|VFile} file\n */\nexport function location(file) {\n  var value = String(file)\n  /** @type {Array.<number>} */\n  var indices = []\n  var search = /\\r?\\n|\\r/g\n\n  while (search.test(value)) {\n    indices.push(search.lastIndex)\n  }\n\n  indices.push(value.length + 1)\n\n  return {toPoint, toOffset}\n\n  /**\n   * Get the line and column-based `point` for `offset` in the bound indices.\n   * Returns a point with `undefined` values when given invalid or out of bounds\n   * input.\n   *\n   * @param {Offset} offset\n   * @returns {FullPoint}\n   */\n  function toPoint(offset) {\n    var index = -1\n\n    if (offset > -1 && offset < indices[indices.length - 1]) {\n      while (++index < indices.length) {\n        if (indices[index] > offset) {\n          return {\n            line: index + 1,\n            column: offset - (indices[index - 1] || 0) + 1,\n            offset\n          }\n        }\n      }\n    }\n\n    return {line: undefined, column: undefined, offset: undefined}\n  }\n\n  /**\n   * Get the `offset` for a line and column-based `point` in the bound indices.\n   * Returns `-1` when given invalid or out of bounds input.\n   *\n   * @param {PositionalPoint} point\n   * @returns {Offset}\n   */\n  function toOffset(point) {\n    var line = point && point.line\n    var column = point && point.column\n    /** @type {number} */\n    var offset\n\n    if (\n      typeof line === 'number' &&\n      typeof column === 'number' &&\n      !Number.isNaN(line) &&\n      !Number.isNaN(column) &&\n      line - 1 in indices\n    ) {\n      offset = (indices[line - 2] || 0) + column - 1 || 0\n    }\n\n    return offset > -1 && offset < indices[indices.length - 1] ? offset : -1\n  }\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n *\n * @typedef {import('unist-util-is').AssertPredicate<Element>} AssertElement\n * @typedef {import('unist-util-is').AssertPredicate<Text>} AssertText\n * @typedef {import('unist-util-is').AssertPredicate<Root>} AssertRoot\n *\n * @callback CreateElementLike\n * @param {string} name\n * @param {any} attributes\n * @param {Array.<string|any>} [children]\n * @returns {any}\n *\n * @typedef Context\n * @property {html|svg} schema\n * @property {string|null} prefix\n * @property {number} key\n * @property {boolean} react\n * @property {boolean} vue\n * @property {boolean} vdom\n * @property {boolean} hyperscript\n *\n * @typedef Options\n * @property {string|null} [prefix]\n * @property {'html'|'svg'} [space]\n */\n\nimport {html, svg, find, hastToReact} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {stringify as commas} from 'comma-separated-tokens'\nimport style from 'style-to-object'\nimport {webNamespaces} from 'web-namespaces'\nimport {convert} from 'unist-util-is'\n\nconst ns = /** @type {Record<string, string>} */ (webNamespaces)\nconst toReact = /** @type {Record<string, string>} */ (hastToReact)\n\nconst own = {}.hasOwnProperty\n\n/** @type {AssertRoot} */\n// @ts-expect-error it’s correct.\nconst root = convert('root')\n/** @type {AssertElement} */\n// @ts-expect-error it’s correct.\nconst element = convert('element')\n/** @type {AssertText} */\n// @ts-expect-error it’s correct.\nconst text = convert('text')\n\n/**\n * @template {CreateElementLike} H\n * @param {H} h\n * @param {Element|Root} tree\n * @param {string|boolean|Options} [options]\n * @returns {ReturnType<H>}\n */\nexport function toH(h, tree, options) {\n  if (typeof h !== 'function') {\n    throw new TypeError('h is not a function')\n  }\n\n  const r = react(h)\n  const v = vue(h)\n  const vd = vdom(h)\n  /** @type {string|boolean|null|undefined} */\n  let prefix\n  /** @type {Element} */\n  let node\n\n  if (typeof options === 'string' || typeof options === 'boolean') {\n    prefix = options\n    options = {}\n  } else {\n    if (!options) options = {}\n    prefix = options.prefix\n  }\n\n  if (root(tree)) {\n    // @ts-expect-error Allow `doctypes` in there, we’ll filter them out later.\n    node =\n      tree.children.length === 1 && element(tree.children[0])\n        ? tree.children[0]\n        : {\n            type: 'element',\n            tagName: 'div',\n            properties: {},\n            children: tree.children\n          }\n  } else if (element(tree)) {\n    node = tree\n  } else {\n    throw new Error(\n      // @ts-expect-error runtime.\n      'Expected root or element, not `' + ((tree && tree.type) || tree) + '`'\n    )\n  }\n\n  return transform(h, node, {\n    schema: options.space === 'svg' ? svg : html,\n    prefix:\n      prefix === undefined || prefix === null\n        ? r || v || vd\n          ? 'h-'\n          : null\n        : typeof prefix === 'string'\n        ? prefix\n        : prefix\n        ? 'h-'\n        : null,\n    key: 0,\n    react: r,\n    vue: v,\n    vdom: vd,\n    hyperscript: hyperscript(h)\n  })\n}\n\n/**\n * Transform a hast node through a hyperscript interface to *anything*!\n *\n * @template {CreateElementLike} H\n * @param {H} h\n * @param {Element} node\n * @param {Context} ctx\n */\nfunction transform(h, node, ctx) {\n  const parentSchema = ctx.schema\n  let schema = parentSchema\n  let name = node.tagName\n  /** @type {Record<string, unknown>} */\n  const attributes = {}\n  /** @type {Array.<ReturnType<H>|string>} */\n  const nodes = []\n  let index = -1\n  /** @type {string} */\n  let key\n\n  if (parentSchema.space === 'html' && name.toLowerCase() === 'svg') {\n    schema = svg\n    ctx.schema = schema\n  }\n\n  for (key in node.properties) {\n    if (node.properties && own.call(node.properties, key)) {\n      addAttribute(attributes, key, node.properties[key], ctx, name)\n    }\n  }\n\n  if (ctx.vdom) {\n    if (schema.space === 'html') {\n      name = name.toUpperCase()\n    } else if (schema.space) {\n      attributes.namespace = ns[schema.space]\n    }\n  }\n\n  if (ctx.prefix) {\n    ctx.key++\n    attributes.key = ctx.prefix + ctx.key\n  }\n\n  if (node.children) {\n    while (++index < node.children.length) {\n      const value = node.children[index]\n\n      if (element(value)) {\n        nodes.push(transform(h, value, ctx))\n      } else if (text(value)) {\n        nodes.push(value.value)\n      }\n    }\n  }\n\n  // Restore parent schema.\n  ctx.schema = parentSchema\n\n  // Ensure no React warnings are triggered for void elements having children\n  // passed in.\n  return nodes.length > 0\n    ? h.call(node, name, attributes, nodes)\n    : h.call(node, name, attributes)\n}\n\n/**\n * @param {Record<string, unknown>} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n * @param {string} name\n */\n// eslint-disable-next-line complexity, max-params\nfunction addAttribute(props, prop, value, ctx, name) {\n  const info = find(ctx.schema, prop)\n  /** @type {string|undefined} */\n  let subprop\n\n  // Ignore nullish and `NaN` values.\n  // Ignore `false` and falsey known booleans for hyperlike DSLs.\n  if (\n    value === undefined ||\n    value === null ||\n    (typeof value === 'number' && Number.isNaN(value)) ||\n    (value === false && (ctx.vue || ctx.vdom || ctx.hyperscript)) ||\n    (!value && info.boolean && (ctx.vue || ctx.vdom || ctx.hyperscript))\n  ) {\n    return\n  }\n\n  if (Array.isArray(value)) {\n    // Accept `array`.\n    // Most props are space-separated.\n    value = info.commaSeparated ? commas(value) : spaces(value)\n  }\n\n  // Treat `true` and truthy known booleans.\n  if (info.boolean && ctx.hyperscript) {\n    value = ''\n  }\n\n  // VDOM, Vue, and React accept `style` as object.\n  if (\n    info.property === 'style' &&\n    typeof value === 'string' &&\n    (ctx.react || ctx.vue || ctx.vdom)\n  ) {\n    value = parseStyle(value, name)\n  }\n\n  if (ctx.vue) {\n    if (info.property !== 'style') subprop = 'attrs'\n  } else if (!info.mustUseProperty) {\n    if (ctx.vdom) {\n      if (info.property !== 'style') subprop = 'attributes'\n    } else if (ctx.hyperscript) {\n      subprop = 'attrs'\n    }\n  }\n\n  if (subprop) {\n    props[subprop] = Object.assign(props[subprop] || {}, {\n      [info.attribute]: value\n    })\n  } else if (info.space && ctx.react) {\n    props[toReact[info.property] || info.property] = value\n  } else {\n    props[info.attribute] = value\n  }\n}\n\n/**\n * Check if `h` is `react.createElement`.\n *\n * @param {CreateElementLike} h\n * @returns {boolean}\n */\nfunction react(h) {\n  /** @type {unknown} */\n  const node = h('div', {})\n  return Boolean(\n    node &&\n      // @ts-expect-error Looks like a React node.\n      ('_owner' in node || '_store' in node) &&\n      // @ts-expect-error Looks like a React node.\n      (node.key === undefined || node.key === null)\n  )\n}\n\n/**\n * Check if `h` is `hyperscript`.\n *\n * @param {CreateElementLike} h\n * @returns {boolean}\n */\nfunction hyperscript(h) {\n  return 'context' in h && 'cleanup' in h\n}\n\n/**\n * Check if `h` is `virtual-dom/h`.\n *\n * @param {CreateElementLike} h\n * @returns {boolean}\n */\nfunction vdom(h) {\n  /** @type {unknown} */\n  const node = h('div', {})\n  // @ts-expect-error Looks like a vnode.\n  return node.type === 'VirtualNode'\n}\n\n/**\n * Check if `h` is Vue.\n *\n * @param {CreateElementLike} h\n * @returns {boolean}\n */\nfunction vue(h) {\n  /** @type {unknown} */\n  const node = h('div', {})\n  // @ts-expect-error Looks like a Vue node.\n  return Boolean(node && node.context && node.context._isVue)\n}\n\n/**\n * @param {string} value\n * @param {string} tagName\n * @returns {Record<string, string>}\n */\nfunction parseStyle(value, tagName) {\n  /** @type {Record<string, string>} */\n  const result = {}\n\n  try {\n    style(value, (name, value) => {\n      if (name.slice(0, 4) === '-ms-') name = 'ms-' + name.slice(4)\n\n      result[\n        name.replace(\n          /-([a-z])/g,\n          /**\n           * @param {string} _\n           * @param {string} $1\n           * @returns {string}\n           */ (_, $1) => $1.toUpperCase()\n        )\n      ] = value\n    })\n  } catch (error) {\n    error.message =\n      tagName + '[style]' + error.message.slice('undefined'.length)\n    throw error\n  }\n\n  return result\n}\n","var own = {}.hasOwnProperty\n\n/**\n * @callback Handler\n * @param {...unknown} value\n * @return {unknown}\n *\n * @typedef {Record<string, Handler>} Handlers\n *\n * @typedef {Object} Options\n * @property {Handler} [unknown]\n * @property {Handler} [invalid]\n * @property {Handlers} [handlers]\n */\n\n/**\n * Handle values based on a property.\n *\n * @param {string} key\n * @param {Options} [options]\n */\nexport function zwitch(key, options) {\n  var settings = options || {}\n\n  /**\n   * Handle one value.\n   * Based on the bound `key`, a respective handler will be called.\n   * If `value` is not an object, or doesn’t have a `key` property, the special\n   * “invalid” handler will be called.\n   * If `value` has an unknown `key`, the special “unknown” handler will be\n   * called.\n   *\n   * All arguments, and the context object, are passed through to the handler,\n   * and it’s result is returned.\n   *\n   * @param {...unknown} [value]\n   * @this {unknown}\n   * @returns {unknown}\n   * @property {Handler} invalid\n   * @property {Handler} unknown\n   * @property {Handlers} handlers\n   */\n  function one(value) {\n    var fn = one.invalid\n    var handlers = one.handlers\n\n    if (value && own.call(value, key)) {\n      fn = own.call(handlers, value[key]) ? handlers[value[key]] : one.unknown\n    }\n\n    if (fn) {\n      return fn.apply(this, arguments)\n    }\n  }\n\n  one.handlers = settings.handlers || {}\n  one.invalid = settings.invalid\n  one.unknown = settings.unknown\n\n  return one\n}\n","/**\n * @typedef {import('parse5').Node} P5Node\n * @typedef {import('parse5').Document} P5Document\n * @typedef {import('parse5').DocumentFragment} P5Fragment\n * @typedef {import('parse5').DocumentType} P5Doctype\n * @typedef {import('parse5').CommentNode} P5Comment\n * @typedef {import('parse5').TextNode} P5Text\n * @typedef {import('parse5').Element} P5Element\n * @typedef {import('parse5').Attribute} P5Attribute\n * @typedef {import('parse5').ParentNode} P5Parent\n * @typedef {Exclude<P5Node, P5Document|P5Fragment>} P5Child\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('property-information').Info} Info\n * @typedef {'html'|'svg'} Space\n * @typedef {import('hast').Parent} Parent\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {Parent['children'][number]} Child\n * @typedef {Child|Root} Node\n *\n * @callback Handle\n * @param {Node} node\n * @param {Schema} schema\n * @returns {P5Node}\n */\n\nimport {html, svg, find} from 'property-information'\nimport {toH} from 'hast-to-hyperscript'\nimport {webNamespaces} from 'web-namespaces'\nimport {zwitch} from 'zwitch'\n\nvar own = {}.hasOwnProperty\n\nvar one = zwitch('type', {handlers: {root, element, text, comment, doctype}})\n\n/**\n * Transform a tree from hast to Parse5’s AST.\n *\n * @param {Node} tree\n * @param {Space} [space='html']\n * @returns {P5Node}\n */\nexport function toParse5(tree, space) {\n  // @ts-ignore Types are wrong.\n  return one(tree, space === 'svg' ? svg : html)\n}\n\n/**\n * @type {Handle}\n * @param {Root} node\n * @returns {P5Document}\n */\nfunction root(node, schema) {\n  /** @type {P5Document} */\n  var p5 = {\n    nodeName: '#document',\n    mode: (node.data || {}).quirksMode ? 'quirks' : 'no-quirks',\n    childNodes: []\n  }\n  // @ts-ignore Assume correct children.\n  p5.childNodes = all(node.children, p5, schema)\n  return patch(node, p5)\n}\n\n/**\n * @type {Handle}\n * @param {Root} node\n * @returns {P5Fragment}\n */\nfunction fragment(node, schema) {\n  /** @type {P5Fragment} */\n  var p5 = {nodeName: '#document-fragment', childNodes: []}\n  // @ts-ignore Assume correct children.\n  p5.childNodes = all(node.children, p5, schema)\n  return patch(node, p5)\n}\n\n/**\n * @type {Handle}\n * @param {Doctype} node\n * @returns {P5Doctype}\n */\nfunction doctype(node) {\n  return patch(node, {\n    nodeName: '#documentType',\n    name: 'html',\n    publicId: '',\n    systemId: '',\n    parentNode: undefined\n  })\n}\n\n/**\n * @type {Handle}\n * @param {Text} node\n * @returns {P5Text}\n */\nfunction text(node) {\n  return patch(node, {\n    nodeName: '#text',\n    value: node.value,\n    parentNode: undefined\n  })\n}\n\n/**\n * @type {Handle}\n * @param {Comment} node\n * @returns {P5Comment}\n */\nfunction comment(node) {\n  return patch(node, {\n    nodeName: '#comment',\n    data: node.value,\n    parentNode: undefined\n  })\n}\n\n/**\n * @type {Handle}\n * @param {Element} node\n * @returns {P5Element}\n */\nfunction element(node, schema) {\n  /** @type {Space} */\n  // @ts-ignore Assume space.\n  var space = schema.space\n  return toH(h, Object.assign({}, node, {children: []}), {space})\n\n  /**\n   * @param {string} name\n   * @param {Object.<string, string|boolean|number>} attrs\n   */\n  function h(name, attrs) {\n    /** @type {Array.<P5Attribute>} */\n    var values = []\n    /** @type {Info} */\n    var info\n    /** @type {P5Attribute} */\n    var value\n    /** @type {string} */\n    var key\n    /** @type {number} */\n    var index\n    /** @type {P5Element} */\n    var p5\n\n    for (key in attrs) {\n      if (!own.call(attrs, key) || attrs[key] === false) {\n        continue\n      }\n\n      info = find(schema, key)\n\n      if (info.boolean && !attrs[key]) {\n        continue\n      }\n\n      value = {name: key, value: attrs[key] === true ? '' : String(attrs[key])}\n\n      if (info.space && info.space !== 'html' && info.space !== 'svg') {\n        index = key.indexOf(':')\n\n        if (index < 0) {\n          value.prefix = ''\n        } else {\n          value.name = key.slice(index + 1)\n          value.prefix = key.slice(0, index)\n        }\n\n        value.namespace = webNamespaces[info.space]\n      }\n\n      values.push(value)\n    }\n\n    if (schema.space === 'html' && node.tagName === 'svg') schema = svg\n\n    p5 = patch(node, {\n      nodeName: name,\n      tagName: name,\n      attrs: values,\n      namespaceURI: webNamespaces[schema.space],\n      childNodes: [],\n      parentNode: undefined\n    })\n\n    // @ts-ignore Assume correct children.\n    p5.childNodes = all(node.children, p5, schema)\n\n    // @ts-ignore Types are wrong.\n    if (name === 'template') p5.content = fragment(node.content, schema)\n\n    return p5\n  }\n}\n\n/**\n * @param {Array.<Child>} children\n * @param {P5Parent} p5\n * @param {Schema} schema\n * @returns {Array.<P5Child>}\n */\nfunction all(children, p5, schema) {\n  var index = -1\n  /** @type {Array.<P5Child>} */\n  var result = []\n  /** @type {P5Child} */\n  var child\n\n  if (children) {\n    while (++index < children.length) {\n      // @ts-ignore Assume child.\n      child = one(children[index], schema)\n\n      // @ts-ignore types are wrong.\n      child.parentNode = p5\n\n      result.push(child)\n    }\n  }\n\n  return result\n}\n\n/**\n * Patch specific properties.\n *\n * @template {P5Node} T\n * @param {Node} node\n * @param {T} p5\n * @returns {T}\n */\nfunction patch(node, p5) {\n  var position = node.position\n\n  if (position && position.start && position.end) {\n    // @ts-ignore Types are wrong.\n    p5.sourceCodeLocation = {\n      startLine: position.start.line,\n      startCol: position.start.column,\n      startOffset: position.start.offset,\n      endLine: position.end.line,\n      endCol: position.end.column,\n      endOffset: position.end.offset\n    }\n  }\n\n  return p5\n}\n","/**\n * List of HTML void tag names.\n *\n * @type {Array<string>}\n */\nexport const htmlVoidElements = [\n  'area',\n  'base',\n  'basefont',\n  'bgsound',\n  'br',\n  'col',\n  'command',\n  'embed',\n  'frame',\n  'hr',\n  'image',\n  'img',\n  'input',\n  'isindex',\n  'keygen',\n  'link',\n  'menuitem',\n  'meta',\n  'nextid',\n  'param',\n  'source',\n  'track',\n  'wbr'\n]\n","/**\n * @typedef {import('vfile').VFile} VFile\n * @typedef {import('parse5').Document} P5Document\n * @typedef {import('parse5').DocumentFragment} P5Fragment\n * @typedef {Omit<import('parse5').Element, 'parentNode'>} P5Element\n * @typedef {import('parse5').Attribute} P5Attribute\n * @typedef {Omit<import('parse5').Location, 'startOffset' | 'endOffset'> & {startOffset: number|undefined, endOffset: number|undefined}} P5Location\n * @typedef {import('parse5').ParserOptions} P5ParserOptions\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Content} Content\n * @typedef {Root|Content} Node\n * @typedef {import('../complex-types').Raw} Raw\n *\n * @typedef {Omit<Comment, 'value'> & {value: {stitch: Node}}} Stitch\n *\n * @typedef Options\n * @property {Array<string>} [passThrough]\n *   List of custom hast node types to pass through (keep) in hast.\n *   If the passed through nodes have children, those children are expected to\n *   be hast and will be handled.\n *\n * @typedef HiddenTokenizer\n * @property {Array<HiddenLocationTracker>} __mixins\n *   Way too simple, but works for us.\n * @property {HiddenPreprocessor} preprocessor\n * @property {(value: string) => void} write\n * @property {() => number} _consume\n * @property {Array<HiddenToken>} tokenQueue\n * @property {string} state\n * @property {string} returnState\n * @property {number} charRefCode\n * @property {Array<number>} tempBuff\n * @property {Function} _flushCodePointsConsumedAsCharacterReference\n * @property {string} lastStartTagName\n * @property {number} consumedAfterSnapshot\n * @property {boolean} active\n * @property {HiddenToken|undefined} currentCharacterToken\n * @property {HiddenToken|undefined} currentToken\n * @property {unknown} currentAttr\n * @property {Function} NAMED_CHARACTER_REFERENCE_STATE\n * @property {Function} NUMERIC_CHARACTER_REFERENCE_END_STATE\n *\n * @typedef {Record<string, unknown> & {location: P5Location}} HiddenToken\n *\n * @typedef HiddenPreprocessor\n * @property {string|undefined} html\n * @property {number} pos\n * @property {number} lastGapPos\n * @property {number} lastCharPos\n * @property {Array<number>} gapStack\n * @property {boolean} skipNextNewLine\n * @property {boolean} lastChunkWritten\n * @property {boolean} endOfChunkHit\n *\n * @typedef HiddenLocationTracker\n * @property {P5Location|undefined} currentAttrLocation\n * @property {P5Location} ctLoc\n * @property {HiddenPosTracker} posTracker\n *\n * @typedef HiddenPosTracker\n * @property {boolean} isEol\n * @property {number} lineStartPos\n * @property {number} droppedBufferSize\n * @property {number} offset\n * @property {number} col\n * @property {number} line\n */\n\n// @ts-expect-error: untyped.\nimport Parser from 'parse5/lib/parser/index.js'\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {visit} from 'unist-util-visit'\nimport {fromParse5} from 'hast-util-from-parse5'\nimport {toParse5} from 'hast-util-to-parse5'\nimport {htmlVoidElements} from 'html-void-elements'\nimport {webNamespaces} from 'web-namespaces'\nimport {zwitch} from 'zwitch'\n\nconst inTemplateMode = 'IN_TEMPLATE_MODE'\nconst dataState = 'DATA_STATE'\nconst characterToken = 'CHARACTER_TOKEN'\nconst startTagToken = 'START_TAG_TOKEN'\nconst endTagToken = 'END_TAG_TOKEN'\nconst commentToken = 'COMMENT_TOKEN'\nconst doctypeToken = 'DOCTYPE_TOKEN'\n\n/** @type {P5ParserOptions} */\nconst parseOptions = {sourceCodeLocationInfo: true, scriptingEnabled: false}\n\n/**\n * Given a hast tree and an optional vfile (for positional info), return a new\n * parsed-again hast tree.\n *\n * @param tree\n *   Original hast tree.\n * @param file\n *   Virtual file for positional info, optional.\n * @param options\n *   Configuration.\n */\nexport const raw =\n  /**\n   * @type {(\n   *   ((tree: Node, file: VFile|undefined, options?: Options) => Node) &\n   *   ((tree: Node, options?: Options) => Node)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {VFile} [file]\n     * @param {Options} [options]\n     */\n    function (tree, file, options) {\n      let index = -1\n      const parser = new Parser(parseOptions)\n      const one = zwitch('type', {\n        // @ts-expect-error: hush.\n        handlers: {root, element, text, comment, doctype, raw: handleRaw},\n        // @ts-expect-error: hush.\n        unknown\n      })\n      /** @type {boolean|undefined} */\n      let stitches\n      /** @type {HiddenTokenizer|undefined} */\n      let tokenizer\n      /** @type {HiddenPreprocessor|undefined} */\n      let preprocessor\n      /** @type {HiddenPosTracker|undefined} */\n      let posTracker\n      /** @type {HiddenLocationTracker|undefined} */\n      let locationTracker\n\n      if (isOptions(file)) {\n        options = file\n        file = undefined\n      }\n\n      if (options && options.passThrough) {\n        while (++index < options.passThrough.length) {\n          // @ts-expect-error: hush.\n          one.handlers[options.passThrough[index]] = stitch\n        }\n      }\n\n      const result = fromParse5(\n        documentMode(tree) ? document() : fragment(),\n        file\n      )\n\n      if (stitches) {\n        visit(result, 'comment', (node, index, parent) => {\n          const stitch = /** @type {Stitch} */ (/** @type {unknown} */ (node))\n          if (stitch.value.stitch && parent !== null && index !== null) {\n            // @ts-expect-error: assume the stitch is allowed.\n            parent.children[index] = stitch.value.stitch\n            return index\n          }\n        })\n      }\n\n      // Unpack if possible and when not given a `root`.\n      if (\n        tree.type !== 'root' &&\n        result.type === 'root' &&\n        result.children.length === 1\n      ) {\n        return result.children[0]\n      }\n\n      return result\n\n      /**\n       * @returns {P5Fragment}\n       */\n      function fragment() {\n        /** @type {P5Element} */\n        const context = {\n          nodeName: 'template',\n          tagName: 'template',\n          attrs: [],\n          namespaceURI: webNamespaces.html,\n          childNodes: []\n        }\n        /** @type {P5Element} */\n        const mock = {\n          nodeName: 'documentmock',\n          tagName: 'documentmock',\n          attrs: [],\n          namespaceURI: webNamespaces.html,\n          childNodes: []\n        }\n        /** @type {P5Fragment} */\n        const doc = {nodeName: '#document-fragment', childNodes: []}\n\n        parser._bootstrap(mock, context)\n        parser._pushTmplInsertionMode(inTemplateMode)\n        parser._initTokenizerForFragmentParsing()\n        parser._insertFakeRootElement()\n        parser._resetInsertionMode()\n        parser._findFormInFragmentContext()\n\n        tokenizer = parser.tokenizer\n        /* c8 ignore next */\n        if (!tokenizer) throw new Error('Expected `tokenizer`')\n        preprocessor = tokenizer.preprocessor\n        locationTracker = tokenizer.__mixins[0]\n        posTracker = locationTracker.posTracker\n\n        one(tree)\n\n        resetTokenizer()\n\n        parser._adoptNodes(mock.childNodes[0], doc)\n\n        return doc\n      }\n\n      /**\n       * @returns {P5Document}\n       */\n      function document() {\n        /** @type {P5Document} */\n        const doc = parser.treeAdapter.createDocument()\n\n        parser._bootstrap(doc, undefined)\n        tokenizer = parser.tokenizer\n        /* c8 ignore next */\n        if (!tokenizer) throw new Error('Expected `tokenizer`')\n        preprocessor = tokenizer.preprocessor\n        locationTracker = tokenizer.__mixins[0]\n        posTracker = locationTracker.posTracker\n\n        one(tree)\n\n        resetTokenizer()\n\n        return doc\n      }\n\n      /**\n       * @param {Array<Content>} nodes\n       * @returns {void}\n       */\n      function all(nodes) {\n        let index = -1\n\n        /* istanbul ignore else - invalid nodes, see rehypejs/rehype-raw#7. */\n        if (nodes) {\n          while (++index < nodes.length) {\n            one(nodes[index])\n          }\n        }\n      }\n\n      /**\n       * @param {Root} node\n       * @returns {void}\n       */\n      function root(node) {\n        all(node.children)\n      }\n\n      /**\n       * @param {Element} node\n       * @returns {void}\n       */\n      function element(node) {\n        resetTokenizer()\n        parser._processToken(startTag(node), webNamespaces.html)\n\n        all(node.children)\n\n        if (!htmlVoidElements.includes(node.tagName)) {\n          resetTokenizer()\n          parser._processToken(endTag(node))\n        }\n      }\n\n      /**\n       * @param {Text} node\n       * @returns {void}\n       */\n      function text(node) {\n        resetTokenizer()\n        parser._processToken({\n          type: characterToken,\n          chars: node.value,\n          location: createParse5Location(node)\n        })\n      }\n\n      /**\n       * @param {Doctype} node\n       * @returns {void}\n       */\n      function doctype(node) {\n        resetTokenizer()\n        parser._processToken({\n          type: doctypeToken,\n          name: 'html',\n          forceQuirks: false,\n          publicId: '',\n          systemId: '',\n          location: createParse5Location(node)\n        })\n      }\n\n      /**\n       * @param {Comment|Stitch} node\n       * @returns {void}\n       */\n      function comment(node) {\n        resetTokenizer()\n        parser._processToken({\n          type: commentToken,\n          data: node.value,\n          location: createParse5Location(node)\n        })\n      }\n\n      /**\n       * @param {Raw} node\n       * @returns {void}\n       */\n      function handleRaw(node) {\n        const start = pointStart(node)\n        const line = start.line || 1\n        const column = start.column || 1\n        const offset = start.offset || 0\n\n        /* c8 ignore next 4 */\n        if (!preprocessor) throw new Error('Expected `preprocessor`')\n        if (!tokenizer) throw new Error('Expected `tokenizer`')\n        if (!posTracker) throw new Error('Expected `posTracker`')\n        if (!locationTracker) throw new Error('Expected `locationTracker`')\n\n        // Reset preprocessor:\n        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/tokenizer/preprocessor.js#L17>.\n        preprocessor.html = undefined\n        preprocessor.pos = -1\n        preprocessor.lastGapPos = -1\n        preprocessor.lastCharPos = -1\n        preprocessor.gapStack = []\n        preprocessor.skipNextNewLine = false\n        preprocessor.lastChunkWritten = false\n        preprocessor.endOfChunkHit = false\n\n        // Reset preprocessor mixin:\n        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/extensions/position-tracking/preprocessor-mixin.js>.\n        posTracker.isEol = false\n        posTracker.lineStartPos = -column + 1 // Looks weird, but ensures we get correct positional info.\n        posTracker.droppedBufferSize = offset\n        posTracker.offset = 0\n        posTracker.col = 1\n        posTracker.line = line\n\n        // Reset location tracker:\n        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/extensions/location-info/tokenizer-mixin.js>.\n        locationTracker.currentAttrLocation = undefined\n        locationTracker.ctLoc = createParse5Location(node)\n\n        // See the code for `parse` and `parseFragment`:\n        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/parser/index.js#L371>.\n        tokenizer.write(node.value)\n        parser._runParsingLoop(null)\n\n        // Character references hang, so if we ended there, we need to flush\n        // those too.\n        // We reset the preprocessor as if the document ends here.\n        // Then one single call to the relevant state does the trick, parse5\n        // consumes the whole token.\n        if (\n          tokenizer.state === 'NAMED_CHARACTER_REFERENCE_STATE' ||\n          tokenizer.state === 'NUMERIC_CHARACTER_REFERENCE_END_STATE'\n        ) {\n          preprocessor.lastChunkWritten = true\n          tokenizer[tokenizer.state](tokenizer._consume())\n        }\n      }\n\n      /**\n       * @param {Node} node\n       */\n      function stitch(node) {\n        stitches = true\n\n        /** @type {Node} */\n        let clone\n\n        // Recurse, because to somewhat handle `[<x>]</x>` (where `[]` denotes the\n        // passed through node).\n        if ('children' in node) {\n          clone = {\n            ...node,\n            children: raw(\n              {type: 'root', children: node.children},\n              file,\n              options\n              // @ts-expect-error Assume a given parent yields a parent.\n            ).children\n          }\n        } else {\n          clone = {...node}\n        }\n\n        // Hack: `value` is supposed to be a string, but as none of the tools\n        // (`parse5` or `hast-util-from-parse5`) looks at it, we can pass nodes\n        // through.\n        comment({type: 'comment', value: {stitch: clone}})\n      }\n\n      function resetTokenizer() {\n        /* c8 ignore next 2 */\n        if (!tokenizer) throw new Error('Expected `tokenizer`')\n        if (!posTracker) throw new Error('Expected `posTracker`')\n\n        // Process final characters if they’re still there after hibernating.\n        // Similar to:\n        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/extensions/location-info/tokenizer-mixin.js#L95>.\n        const token = tokenizer.currentCharacterToken\n\n        if (token) {\n          token.location.endLine = posTracker.line\n          token.location.endCol = posTracker.col + 1\n          token.location.endOffset = posTracker.offset + 1\n          parser._processToken(token)\n        }\n\n        // Reset tokenizer:\n        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/tokenizer/index.js#L218-L234>.\n        // Especially putting it back in the `data` state is useful: some elements,\n        // like textareas and iframes, change the state.\n        // See GH-7.\n        // But also if broken HTML is in `raw`, and then a correct element is given.\n        // See GH-11.\n        tokenizer.tokenQueue = []\n        tokenizer.state = dataState\n        tokenizer.returnState = ''\n        tokenizer.charRefCode = -1\n        tokenizer.tempBuff = []\n        tokenizer.lastStartTagName = ''\n        tokenizer.consumedAfterSnapshot = -1\n        tokenizer.active = false\n        tokenizer.currentCharacterToken = undefined\n        tokenizer.currentToken = undefined\n        tokenizer.currentAttr = undefined\n      }\n    }\n  )\n/**\n * @param {Element} node\n * @returns {HiddenToken}\n */\nfunction startTag(node) {\n  /** @type {P5Location} */\n  const location = Object.assign(createParse5Location(node))\n  // @ts-expect-error extra positional info.\n  location.startTag = Object.assign({}, location)\n\n  // Untyped token.\n  return {\n    type: startTagToken,\n    tagName: node.tagName,\n    selfClosing: false,\n    attrs: attributes(node),\n    location\n  }\n}\n\n/**\n * @param {Element} node\n * @returns {Array<P5Attribute>}\n */\nfunction attributes(node) {\n  return toParse5({\n    tagName: node.tagName,\n    type: 'element',\n    properties: node.properties,\n    children: []\n    // @ts-expect-error Assume element.\n  }).attrs\n}\n\n/**\n * @param {Element} node\n * @returns {HiddenToken}\n */\nfunction endTag(node) {\n  /** @type {P5Location} */\n  const location = Object.assign(createParse5Location(node))\n  // @ts-expect-error extra positional info.\n  location.startTag = Object.assign({}, location)\n\n  // Untyped token.\n  return {\n    type: endTagToken,\n    tagName: node.tagName,\n    attrs: [],\n    location\n  }\n}\n\n/**\n * @param {Node} node\n */\nfunction unknown(node) {\n  throw new Error('Cannot compile `' + node.type + '` node')\n}\n\n/**\n * @param {Node} node\n * @returns {boolean}\n */\nfunction documentMode(node) {\n  const head = node.type === 'root' ? node.children[0] : node\n  return Boolean(\n    head &&\n      (head.type === 'doctype' ||\n        (head.type === 'element' && head.tagName === 'html'))\n  )\n}\n\n/**\n * @param {Node|Stitch} node\n * @returns {P5Location}\n */\nfunction createParse5Location(node) {\n  const start = pointStart(node)\n  const end = pointEnd(node)\n\n  return {\n    startLine: start.line,\n    startCol: start.column,\n    startOffset: start.offset,\n    endLine: end.line,\n    endCol: end.column,\n    endOffset: end.offset\n  }\n}\n\n/**\n * @param {VFile|Options|undefined} value\n * @return {value is Options}\n */\nfunction isOptions(value) {\n  return Boolean(value && !('message' in value && 'messages' in value))\n}\n","/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast-util-raw').Options} Options\n * @typedef {import('hast-util-raw')} DoNotTouchAsThisImportIncludesRawInTree\n */\n\nimport {raw} from 'hast-util-raw'\n\n/**\n * Plugin to parse the tree again (and raw nodes).\n * Keeping positional info OK.  🙌\n *\n * @type {import('unified').Plugin<[Options?] | Array<void>, Root>}\n */\nexport default function rehypeRaw(options = {}) {\n  return (tree, file) => {\n    // Assume that when a root was given, it’s also returned.\n    const result = /** @type {Root} */ (raw(tree, file, options))\n    return result\n  }\n}\n","var own = {}.hasOwnProperty\n\n/**\n * Check if `node` has a set `name` property.\n *\n * @param {unknown} node\n * @param {string} name\n * @returns {boolean}\n */\nexport function hasProperty(node, name) {\n  /** @type {unknown} */\n  var value =\n    name &&\n    node &&\n    typeof node === 'object' &&\n    // @ts-ignore Looks like a node.\n    node.type === 'element' &&\n    // @ts-ignore Looks like an element.\n    node.properties &&\n    // @ts-ignore Looks like an element.\n    own.call(node.properties, name) &&\n    // @ts-ignore Looks like an element.\n    node.properties[name]\n\n  return value !== null && value !== undefined && value !== false\n}\n","/**\n * @typedef {import('hast').Parent} Parent\n * @typedef {import('hast').Root} Root\n * @typedef {Root|Parent['children'][number]} Node\n */\n\n/**\n * Rank of a heading: H1 -> 1, H2 -> 2, etc.\n *\n * @param {Node} node\n * @returns {number|null}\n */\nexport function headingRank(node) {\n  var name =\n    (node && node.type === 'element' && node.tagName.toLowerCase()) || ''\n  var code =\n    name.length === 2 && name.charCodeAt(0) === 104 /* `h` */\n      ? name.charCodeAt(1)\n      : 0\n  return code > 48 /* `0` */ && code < 55 /* `7` */ ? code - 48 /* `0` */ : null\n}\n","/**\n * @fileoverview\n *   Get the plain-text value of a hast node.\n * @longdescription\n *   ## Use\n *\n *   ```js\n *   import {h} from 'hastscript'\n *   import {toString} from 'hast-util-to-string'\n *\n *   toString(h('p', 'Alpha'))\n *   //=> 'Alpha'\n *   toString(h('div', [h('b', 'Bold'), ' and ', h('i', 'italic'), '.']))\n *   //=> 'Bold and italic.'\n *   ```\n *\n *   ## API\n *\n *   ### `toString(node)`\n *\n *   Transform a node to a string.\n */\n\n/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n * @typedef {Root|Root['children'][number]} Node\n */\n\n/**\n * Get the plain-text value of a hast node.\n *\n * @param {Node} node\n * @returns {string}\n */\nexport function toString(node) {\n  // “The concatenation of data of all the Text node descendants of the context\n  // object, in tree order.”\n  if ('children' in node) {\n    return all(node)\n  }\n\n  // “Context object’s data.”\n  return 'value' in node ? node.value : ''\n}\n\n/**\n * @param {Node} node\n * @returns {string}\n */\nfunction one(node) {\n  if (node.type === 'text') {\n    return node.value\n  }\n\n  return 'children' in node ? all(node) : ''\n}\n\n/**\n * @param {Root|Element} node\n * @returns {string}\n */\nfunction all(node) {\n  let index = -1\n  /** @type {string[]} */\n  const result = []\n\n  while (++index < node.children.length) {\n    result[index] = one(node.children[index])\n  }\n\n  return result.join('')\n}\n","/**\n * @typedef {import('hast').Root} Root\n */\n\nimport Slugger from 'github-slugger'\nimport {hasProperty} from 'hast-util-has-property'\nimport {headingRank} from 'hast-util-heading-rank'\nimport {toString} from 'hast-util-to-string'\nimport {visit} from 'unist-util-visit'\n\nconst slugs = new Slugger()\n\n/**\n * Plugin to add `id`s to headings.\n *\n * @type {import('unified').Plugin<Array<void>, Root>}\n */\nexport default function rehypeSlug() {\n  return (tree) => {\n    slugs.reset()\n\n    visit(tree, 'element', (node) => {\n      if (headingRank(node) && node.properties && !hasProperty(node, 'id')) {\n        node.properties.id = slugs.slug(toString(node))\n      }\n    })\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('hast').Element} Element\n *\n * @typedef {string} TagName\n * @typedef {null|undefined|TagName|TestFunctionAnything|Array.<TagName|TestFunctionAnything>} Test\n */\n\n/**\n * @template {Element} T\n * @typedef {null|undefined|T['tagName']|TestFunctionPredicate<T>|Array.<T['tagName']|TestFunctionPredicate<T>>} PredicateTest\n */\n\n/**\n * Check if an element passes a test\n *\n * @callback TestFunctionAnything\n * @param {Element} element\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean|void}\n */\n\n/**\n * Check if an element passes a certain node test\n *\n * @template {Element} X\n * @callback TestFunctionPredicate\n * @param {Element} element\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {element is X}\n */\n\n/**\n * Check if a node is an element and passes a certain node test\n *\n * @callback AssertAnything\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean}\n */\n\n/**\n * Check if a node is an element and passes a certain node test\n *\n * @template {Element} Y\n * @callback AssertPredicate\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is Y}\n */\n\n// Check if `node` is an `element` and whether it passes the given test.\nexport const isElement =\n  /**\n   * Check if a node is an element and passes a test.\n   * When a `parent` node is known the `index` of node should also be given.\n   *\n   * @type {(\n   *   (() => false) &\n   *   (<T extends Element = Element>(node: unknown, test?: PredicateTest<T>, index?: number, parent?: Parent, context?: unknown) => node is T) &\n   *   ((node: unknown, test: Test, index?: number, parent?: Parent, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * Check if a node passes a test.\n     * When a `parent` node is known the `index` of node should also be given.\n     *\n     * @param {unknown} [node] Node to check\n     * @param {Test} [test] When nullish, checks if `node` is a `Node`.\n     * When `string`, works like passing `function (node) {return node.type === test}`.\n     * When `function` checks if function passed the node is true.\n     * When `array`, checks any one of the subtests pass.\n     * @param {number} [index] Position of `node` in `parent`\n     * @param {Parent} [parent] Parent of `node`\n     * @param {unknown} [context] Context object to invoke `test` with\n     * @returns {boolean} Whether test passed and `node` is an `Element` (object with `type` set to `element` and `tagName` set to a non-empty string).\n     */\n    // eslint-disable-next-line max-params\n    function (node, test, index, parent, context) {\n      const check = convertElement(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index for child node')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!parent.type || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      // @ts-expect-error Looks like a node.\n      if (!node || !node.type || typeof node.type !== 'string') {\n        return false\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      return check.call(context, node, index, parent)\n    }\n  )\n\nexport const convertElement =\n  /**\n   * @type {(\n   *   (<T extends Element>(test: T['tagName']|TestFunctionPredicate<T>) => AssertPredicate<T>) &\n   *   ((test?: Test) => AssertAnything)\n   * )}\n   */\n  (\n    /**\n     * Generate an assertion from a check.\n     * @param {Test} [test]\n     * When nullish, checks if `node` is a `Node`.\n     * When `string`, works like passing `function (node) {return node.type === test}`.\n     * When `function` checks if function passed the node is true.\n     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n     * When `array`, checks any one of the subtests pass.\n     * @returns {AssertAnything}\n     */\n    function (test) {\n      if (test === undefined || test === null) {\n        return element\n      }\n\n      if (typeof test === 'string') {\n        return tagNameFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return anyFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or array as test')\n    }\n  )\n\n/**\n * @param {Array.<TagName|TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n  /** @type {Array.<AssertAnything>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convertElement(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @param {unknown[]} parameters\n   * @returns {boolean}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].call(this, ...parameters)) {\n        return true\n      }\n    }\n\n    return false\n  }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s tag\n * name for said string.\n *\n * @param {TagName} check\n * @returns {AssertAnything}\n */\nfunction tagNameFactory(check) {\n  return tagName\n\n  /**\n   * @param {unknown} node\n   * @returns {boolean}\n   */\n  function tagName(node) {\n    return element(node) && node.tagName === check\n  }\n}\n\n/**\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n  return assertion\n\n  /**\n   * @this {unknown}\n   * @param {unknown} node\n   * @param {Array.<unknown>} parameters\n   * @returns {boolean}\n   */\n  function assertion(node, ...parameters) {\n    // @ts-expect-error: fine.\n    return element(node) && Boolean(check.call(this, node, ...parameters))\n  }\n}\n\n/**\n * Utility to return true if this is an element.\n * @param {unknown} node\n * @returns {node is Element}\n */\nfunction element(node) {\n  return Boolean(\n    node &&\n      typeof node === 'object' &&\n      // @ts-expect-error Looks like a node.\n      node.type === 'element' &&\n      // @ts-expect-error Looks like an element.\n      typeof node.tagName === 'string'\n  )\n}\n","/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Parent} Parent\n * @typedef {import('hast').Element} Element\n * @typedef {Element['children'][number]} ElementChild\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast-util-is-element').Test} Test\n *\n * @typedef {'prepend'|'append'|'wrap'|'before'|'after'} Behavior\n *\n * @callback Build\n * @param {Element} node\n * @returns {ElementChild|ElementChild[]}\n *\n * @typedef Options\n *   Configuration.\n * @property {Behavior} [behavior='prepend']\n *   How to create links.\n * @property {Behavior} [behaviour]\n *   Please use `behavior` instead\n * @property {Properties} [properties]\n *   Extra properties to set on the link when injecting.\n *   Defaults to `{ariaHidden: true, tabIndex: -1}` when `'prepend'` or\n *   `'append'`.\n * @property {ElementChild|ElementChild[]|Build} [content={type: 'element', tagName: 'span', properties: {className: ['icon', 'icon-link']}, children: []}]\n *   hast nodes to insert in the link.\n * @property {ElementChild|ElementChild[]|Build} [group]\n *   hast node to wrap the heading and link with, if `behavior` is `'before'` or\n *   `'after'`.\n *   There is no default.\n * @property {Test} [test]\n *   Test to define which heading elements are linked.\n *   Any test that can be given to `hast-util-is-element` is supported.\n *   The default (no test) is to link all headings.\n *   Can be used to link only h1-h3, or for example all except h1.\n */\n\nimport extend from 'extend'\nimport {hasProperty} from 'hast-util-has-property'\nimport {headingRank} from 'hast-util-heading-rank'\nimport {convertElement} from 'hast-util-is-element'\nimport {visit, SKIP} from 'unist-util-visit'\n\n/** @type {Element} */\nconst contentDefaults = {\n  type: 'element',\n  tagName: 'span',\n  properties: {className: ['icon', 'icon-link']},\n  children: []\n}\n\n/**\n * Plugin to automatically add links to headings (h1-h6).\n *\n * @type {import('unified').Plugin<[Options?]|void[], Root>}\n */\nexport default function rehypeAutolinkHeadings(options = {}) {\n  let props = options.properties\n  const behavior = options.behaviour || options.behavior || 'prepend'\n  const content = options.content || contentDefaults\n  const group = options.group\n  const is = convertElement(options.test)\n\n  /** @type {import('unist-util-visit/complex-types').Visitor<Element>} */\n  let method\n\n  if (behavior === 'wrap') {\n    method = wrap\n  } else if (behavior === 'before' || behavior === 'after') {\n    method = around\n  } else {\n    if (!props) {\n      props = {ariaHidden: 'true', tabIndex: -1}\n    }\n\n    method = inject\n  }\n\n  return (tree) => {\n    visit(tree, 'element', (node, index, parent) => {\n      if (\n        headingRank(node) &&\n        hasProperty(node, 'id') &&\n        is(node, index, parent)\n      ) {\n        return method(node, index, parent)\n      }\n    })\n  }\n\n  /** @type {import('unist-util-visit/complex-types').Visitor<Element>} */\n  function inject(node) {\n    node.children[behavior === 'prepend' ? 'unshift' : 'push'](\n      create(node, extend(true, {}, props), toChildren(content, node))\n    )\n\n    return [SKIP]\n  }\n\n  /** @type {import('unist-util-visit/complex-types').Visitor<Element>} */\n  function around(node, index, parent) {\n    // Uncommon.\n    /* c8 ignore next */\n    if (typeof index !== 'number' || !parent) return\n\n    const link = create(\n      node,\n      extend(true, {}, props),\n      toChildren(content, node)\n    )\n    let nodes = behavior === 'before' ? [link, node] : [node, link]\n\n    if (group) {\n      const grouping = toNode(group, node)\n\n      if (grouping && !Array.isArray(grouping) && grouping.type === 'element') {\n        grouping.children = nodes\n        nodes = [grouping]\n      }\n    }\n\n    parent.children.splice(index, 1, ...nodes)\n\n    return [SKIP, index + nodes.length]\n  }\n\n  /** @type {import('unist-util-visit/complex-types').Visitor<Element>} */\n  function wrap(node) {\n    node.children = [create(node, extend(true, {}, props), node.children)]\n    return [SKIP]\n  }\n\n  /**\n   * @param {ElementChild|ElementChild[]|Build} value\n   * @param {Element} node\n   * @returns {ElementChild[]}\n   */\n  function toChildren(value, node) {\n    const result = toNode(value, node)\n    return Array.isArray(result) ? result : [result]\n  }\n\n  /**\n   * @param {ElementChild|ElementChild[]|Build} value\n   * @param {Element} node\n   * @returns {ElementChild|ElementChild[]}\n   */\n  function toNode(value, node) {\n    if (typeof value === 'function') return value(node)\n    return extend(true, Array.isArray(value) ? [] : {}, value)\n  }\n\n  /**\n   * @param {Element} node\n   * @param {Properties} props\n   * @param {ElementChild[]} children\n   * @returns {Element}\n   */\n  function create(node, props, children) {\n    return {\n      type: 'element',\n      tagName: 'a',\n      properties: Object.assign({}, props, {\n        // Fix hast types and make them required.\n        /* c8 ignore next */\n        href: '#' + (node.properties || {}).id\n      }),\n      children\n    }\n  }\n}\n","import { Element, Comment, Literal, ElementContent, RootContent, Properties } from 'hast';\nimport { RehypeAttrsOptions } from './';\n\nexport const getURLParameters = (url: string): Record<string, string | number | boolean> =>\n(url.match(/([^?=&]+)(=([^&]*))/g) || []).reduce(\n  (a: Record<string, string | number>, v: string) => (\n    (a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') + 1)), a\n  ),\n  {},\n);\n\nexport const prevChild = (data: Literal[] = [], index: number): Comment | undefined => {\n  let i = index;\n  while (i > -1) {\n    i--;\n    if (!data[i]) return\n    if ((data[i] && data[i].value && (data[i].value as string).replace(/(\\n|\\s)/g, '') !== '') || data[i].type !== 'text') {\n      if (!/^rehype:/.test(data[i].value as string) || (data[i].type as string) !== 'comment') return;\n      return data[i] as unknown as Comment;\n    }\n  }\n  return;\n}\n\nexport const nextChild = (data: RootContent[] | ElementContent[] = [], index: number, tagName?: string): ElementContent | undefined => {\n  let i = index;\n  while (i < data.length) {\n    i++;\n    if (tagName) {\n      const element = data[i] as Literal & Element;\n      if (element && element.value && (element.value as string).replace(/(\\n|\\s)/g, '') !== '' || data[i] && (data[i].type as string) === 'element') {\n        return element.tagName === tagName ? element : undefined\n      }\n    } else {\n      const element = data[i] as ElementContent & Literal;\n      if (!element || (element.type !== 'text' && (element.type as string) !== 'comment') || (element.type === 'text' && (element.value as string).replace(/(\\n|\\s)/g, '') !== '')) return;\n      if ((element.type as string) === 'comment') {\n        if (!/^rehype:/.test(element.value as string)) return;\n        const nextNode = nextChild(data, i, 'pre')\n        if (nextNode) return;\n        return element;\n      }\n    }\n  }\n  return\n}\n\n/**\n * 获取代码注视的位置\n * @param data 数据\n * @param index 当前数据所在的位置\n * @returns 返回 当前参数数据 Object，`{}`\n */\nexport const getCommentObject = ({ value = '' }: Comment): Properties => {\n  const param = getURLParameters(value.replace(/^rehype:/, ''));\n  Object.keys(param).forEach((keyName: string) => {\n    if (param[keyName] === 'true') {\n      param[keyName] = true;\n    }\n    if (param[keyName] === 'false') {\n      param[keyName] = false;\n    }\n    if (typeof param[keyName] === 'string' && !/^0/.test(param[keyName] as string) && !isNaN(+param[keyName])) {\n      param[keyName] = +param[keyName];\n    }\n  })\n  return param;\n}\n\nexport type DataConfig = {\n  'data-config': Properties\n}\n\nexport const propertiesHandle = (defaultAttrs?: Properties | null, attrs?: Properties, type?: RehypeAttrsOptions['properties']): Properties | DataConfig => {\n  if (type === 'string') {\n    return { ...defaultAttrs, 'data-config': JSON.stringify({ ...attrs, rehyp: true })}\n  } else if (type === 'attr') {\n    return { ...defaultAttrs, ...attrs}\n  }\n  return { ...defaultAttrs, 'data-config': { ...attrs, rehyp: true }}\n}","import { Plugin } from 'unified';\nimport { Root, Element, Comment, Properties, Literal } from 'hast';\nimport { visit } from 'unist-util-visit';\nimport { propertiesHandle, nextChild, prevChild, getCommentObject } from './utils';\n\nexport type RehypeAttrsOptions = {\n  /**\n   * ## `data`\n   * \n   * ```markdown\n   * text\n   * <!--rehype:title=Rehype Attrs&abc=2-->\n   * ```\n   * \n   * ⇣⇣⇣⇣⇣⇣\n   * \n   * ```html\n   * <p data-config=\"data-config='[object Object]'\">text</p>\n   * ```\n   * \n   * ## `string`\n   * \n   * ```markdown\n   * text\n   * <!--rehype:title=Rehype Attrs-->\n   * ```\n   * \n   * ⇣⇣⇣⇣⇣⇣\n   * \n   * ```html\n   * <p data-config=\"{&#x22;title&#x22;:&#x22;Rehype Attrs&#x22;,&#x22;rehyp&#x22;:true}\">text</p>\n   * ```\n   * \n   * ## attr\n   * \n   * ```markdown\n   * text\n   * <!--rehype:title=Rehype Attrs-->\n   * ```\n   * ⇣⇣⇣⇣⇣⇣\n   * ```html\n   * <p title=\"Rehype Attrs\">text</p>\n   * ```\n   */\n  properties: 'data' | 'string' | 'attr';\n}\n\nconst defaultOptions: RehypeAttrsOptions = {\n  properties: 'data',\n}\n\nconst rehypeAttrs: Plugin<[RehypeAttrsOptions?], Root> = (options) => {\n  const opts = { ...defaultOptions, ...options }\n  return (tree) => {\n    visit(tree, 'element', (node, index, parent) => {\n      if (node.tagName === 'pre' && node && Array.isArray(node.children) && parent && Array.isArray(parent.children) && parent.children.length > 1) {\n        const firstChild = node.children[0] as Element;\n        if (firstChild && firstChild.tagName === 'code' && typeof index === 'number') {\n          const child = prevChild(parent.children as Literal[], index);\n          if (child) {\n            const attr = getCommentObject(child);\n            if (Object.keys(attr).length > 0) {\n              node.properties = { ...node.properties, ...{ 'data-type': 'rehyp' } }\n              firstChild.properties = propertiesHandle(firstChild.properties, attr, opts.properties) as Properties\n            }\n          }\n        }\n      }\n\n      if (/^(em|strong|b|a|i|p|pre|kbd|blockquote|h(1|2|3|4|5|6)|code|table|img|del|ul|ol)$/.test(node.tagName) && parent && Array.isArray(parent.children) && typeof index === 'number') {\n        const child = nextChild(parent.children, index)\n        if (child) {\n          const attr = getCommentObject(child as Comment)\n          if (Object.keys(attr).length > 0) {\n            node.properties = propertiesHandle(node.properties, attr, opts.properties) as Properties\n          }\n        }\n      }\n    });\n  }\n}\n\n\nexport default rehypeAttrs\n","import { Plugin } from 'unified';\nimport { Root, RootContent } from 'hast';\nimport { visit } from 'unist-util-visit';\n\nexport type RehypeIgnoreOptions = {\n  /**\n   *  Character to use for opening delimiter, by default `rehype:ignore:start`\n   */\n  openDelimiter?: string;\n  /**\n   * Character to use for closing delimiter, by default `rehype:ignore:end`\n   */\n  closeDelimiter?: string;\n}\n\nconst rehypeIgnore: Plugin<[RehypeIgnoreOptions?], Root> = (options = {}) => {\n  const { openDelimiter = 'rehype:ignore:start', closeDelimiter = 'rehype:ignore:end' } = options;\n  return (tree) => {\n    visit(tree, (node: Root | RootContent, index, parent) => {\n      if (node.type === 'element' || node.type === 'root') {\n        // const start = node.children.findIndex((item) => item.type === 'comment' && item.value === openDelimiter);\n        // const end = node.children.findIndex((item) => item.type === 'comment' && item.value === closeDelimiter);\n        // if (start > -1 && end > -1) {\n        //   node.children = node.children.filter((_, idx) => idx < start || idx > end);\n        // }\n        let start = false;\n        node.children = node.children.filter((item) => {\n          if (item.type === 'comment' && item.value.trim() === openDelimiter) {\n            start = true;\n            return false\n          }\n          if (item.type === 'comment' && item.value.trim() === closeDelimiter) {\n            start = false;\n            return false\n          }\n          \n          return !start;\n        })\n      }\n    });\n  }\n}\n\nexport default rehypeIgnore;\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n */\n\n/**\n * Options for unist util filter\n *\n * @typedef {Object} FilterOptions\n * @property {boolean} [cascade=true] Whether to drop parent nodes if they had children, but all their children were filtered out.\n */\n\nimport {convert} from 'unist-util-is'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Create a new tree consisting of copies of all nodes that pass test.\n * The tree is walked in preorder (NLR), visiting the node itself, then its head, etc.\n *\n * @param tree Tree to filter.\n * @param options Configuration (optional).\n * @param test is-compatible test (such as a type).\n * @returns Given `tree` or `null` if it didn’t pass `test`.\n */\nexport const filter =\n  /**\n   * @type {(\n   *  (<Tree extends Node, Check extends Test>(node: Tree, options: FilterOptions, test: Check) => import('./complex-types').Matches<Tree, Check>) &\n   *  (<Tree extends Node, Check extends Test>(node: Tree, test: Check) => import('./complex-types').Matches<Tree, Check>) &\n   *  (<Tree extends Node>(node: Tree, options?: FilterOptions) => Tree)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {FilterOptions} options\n     * @param {Test} test\n     * @returns {Node|null}\n     */\n    function (tree, options, test) {\n      const is = convert(test || options)\n      const cascade =\n        options.cascade === undefined || options.cascade === null\n          ? true\n          : options.cascade\n\n      return preorder(tree)\n\n      /**\n       * @param {Node} node\n       * @param {number|undefined} [index]\n       * @param {Parent|undefined} [parent]\n       * @returns {Node|null}\n       */\n      function preorder(node, index, parent) {\n        /** @type {Array.<Node>} */\n        const children = []\n        /** @type {number} */\n        let childIndex\n        /** @type {Node} */\n        let result\n        /** @type {string} */\n        let key\n\n        if (!is(node, index, parent)) return null\n\n        // @ts-expect-error: Looks like a parent.\n        if (node.children) {\n          childIndex = -1\n\n          // @ts-expect-error Looks like a parent.\n          while (++childIndex < node.children.length) {\n            // @ts-expect-error Looks like a parent.\n            result = preorder(node.children[childIndex], childIndex, node)\n\n            if (result) {\n              children.push(result)\n            }\n          }\n\n          // @ts-expect-error Looks like a parent.\n          if (cascade && node.children.length > 0 && children.length === 0)\n            return null\n        }\n\n        // Create a shallow clone, using the new children.\n        /** @type {typeof node} */\n        // @ts-expect-error all the fields will be copied over.\n        const next = {}\n\n        for (key in node) {\n          if (own.call(node, key)) {\n            // @ts-expect-error: Looks like a record.\n            next[key] = key === 'children' ? children : node[key]\n          }\n        }\n\n        return next\n      }\n    }\n  )\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef Options options\n *   Configuration.\n * @property {boolean} [showLineNumbers]\n *   Set `showLineNumbers` to `true` to always display line number\n * @property {boolean} [ignoreMissing]\n *   Set `ignoreMissing` to `true` to ignore unsupported languages and line highlighting when no language is specified\n */\n\nimport { visit } from 'unist-util-visit'\nimport { toString } from 'hast-util-to-string'\nimport { filter } from 'unist-util-filter'\nimport rangeParser from 'parse-numeric-range'\n\n/**\n * @param {Element} node\n * @return {string|null}\n */\nconst getLanguage = (node) => {\n  const className = node.properties.className\n  //@ts-ignore\n  for (const classListItem of className) {\n    if (classListItem.slice(0, 9) === 'language-') {\n      return classListItem.slice(9).toLowerCase()\n    }\n  }\n  return null\n}\n\n/**\n * Create a closure that determines if we have to highlight the given index\n *\n * @param {string} meta\n * @return { (index:number) => boolean }\n */\nconst calculateLinesToHighlight = (meta) => {\n  const RE = /{([\\d,-]+)}/\n  // Remove space between {} e.g. {1, 3}\n  const parsedMeta = meta\n    .split(',')\n    .map((str) => str.trim())\n    .join()\n  if (RE.test(parsedMeta)) {\n    const strlineNumbers = RE.exec(parsedMeta)[1]\n    const lineNumbers = rangeParser(strlineNumbers)\n    return (index) => lineNumbers.includes(index + 1)\n  } else {\n    return () => false\n  }\n}\n\n/**\n * Check if we want to start the line numbering from a given number or 1\n * showLineNumbers=5, will start the numbering from 5\n * @param {string} meta\n * @returns {number}\n */\nconst calculateStartingLine = (meta) => {\n  const RE = /showLineNumbers=(?<lines>\\d+)/i\n  // pick the line number after = using a named capturing group\n  if (RE.test(meta)) {\n    const {\n      groups: { lines },\n    } = RE.exec(meta)\n    return Number(lines)\n  }\n  return 1\n}\n\n/**\n * Create container AST for node lines\n *\n * @param {number} number\n * @return {Element[]}\n */\nconst createLineNodes = (number) => {\n  const a = new Array(number)\n  for (let i = 0; i < number; i++) {\n    a[i] = {\n      type: 'element',\n      tagName: 'span',\n      properties: { className: [] },\n      children: [],\n    }\n  }\n  return a\n}\n\n/**\n * Split multiline text nodes into individual nodes with positioning\n * Add a node start and end line position information for each text node\n *\n * @return { (ast:Element['children']) => Element['children'] }\n *\n */\nconst addNodePositionClosure = () => {\n  let startLineNum = 1\n  /**\n   * @param {Element['children']} ast\n   * @return {Element['children']}\n   */\n  const addNodePosition = (ast) => {\n    return ast.reduce((result, node) => {\n      if (node.type === 'text') {\n        const value = /** @type {string} */ (node.value)\n        const numLines = (value.match(/\\n/g) || '').length\n        if (numLines === 0) {\n          node.position = {\n            // column: 1 is needed to avoid error with @next/mdx\n            // https://github.com/timlrx/rehype-prism-plus/issues/44\n            start: { line: startLineNum, column: 1 },\n            end: { line: startLineNum, column: 1 },\n          }\n          result.push(node)\n        } else {\n          const lines = value.split('\\n')\n          for (const [i, line] of lines.entries()) {\n            result.push({\n              type: 'text',\n              value: i === lines.length - 1 ? line : line + '\\n',\n              position: {\n                start: { line: startLineNum + i, column: 1 },\n                end: { line: startLineNum + i, column: 1 },\n              },\n            })\n          }\n        }\n        startLineNum = startLineNum + numLines\n\n        return result\n      }\n\n      if (Object.prototype.hasOwnProperty.call(node, 'children')) {\n        const initialLineNum = startLineNum\n        // @ts-ignore\n        node.children = addNodePosition(node.children, startLineNum)\n        result.push(node)\n        node.position = {\n          start: { line: initialLineNum, column: 1 },\n          end: { line: startLineNum, column: 1 },\n        }\n        return result\n      }\n\n      result.push(node)\n      return result\n    }, [])\n  }\n  return addNodePosition\n}\n\n/**\n * Rehype prism plugin generator that highlights code blocks with refractor (prismjs)\n *\n * Pass in your own refractor object with the required languages registered:\n * https://github.com/wooorm/refractor#refractorregistersyntax\n *\n * @param {import('refractor/lib/core').Refractor} refractor\n * @return {import('unified').Plugin<[Options?], Root>}\n */\nconst rehypePrismGenerator = (refractor) => {\n  return (options = {}) => {\n    return (tree) => {\n      visit(tree, 'element', visitor)\n    }\n\n    /**\n     * @param {Element} node\n     * @param {number} index\n     * @param {Element} parent\n     */\n    function visitor(node, index, parent) {\n      if (!parent || parent.tagName !== 'pre' || node.tagName !== 'code') {\n        return\n      }\n\n      let meta = node.data && node.data.meta ? /** @type {string} */ (node.data.meta) : ''\n      // Coerce className to array\n      if (node.properties.className) {\n        if (typeof node.properties.className === 'boolean') {\n          node.properties.className = []\n        } else if (!Array.isArray(node.properties.className)) {\n          node.properties.className = [node.properties.className]\n        }\n      } else {\n        node.properties.className = []\n      }\n      node.properties.className.push('code-highlight')\n      const lang = getLanguage(node)\n\n      /** @type {Element} */\n      let refractorRoot\n\n      // Syntax highlight\n      if (lang) {\n        try {\n          let rootLang\n          if (lang?.includes('diff-')){\n            rootLang=lang.split('-')[1]\n          } else{\n            rootLang=lang\n          }\n          // @ts-ignore\n          refractorRoot = refractor.highlight(toString(node), rootLang)\n          // @ts-ignore className is already an array\n          parent.properties.className = (parent.properties.className || []).concat(\n            'language-' + rootLang\n          )\n        } catch (err) {\n          if (options.ignoreMissing && /Unknown language/.test(err.message)) {\n            refractorRoot = node\n          } else {\n            throw err\n          }\n        }\n      } else {\n        refractorRoot = node\n      }\n\n      refractorRoot.children = addNodePositionClosure()(refractorRoot.children)\n\n      // Add position info to root\n      if (refractorRoot.children.length > 0) {\n        refractorRoot.position = {\n          start: { line: refractorRoot.children[0].position.start.line, column: 0 },\n          end: {\n            line: refractorRoot.children[refractorRoot.children.length - 1].position.end.line,\n            column: 0,\n          },\n        }\n      } else {\n        refractorRoot.position = {\n          start: { line: 0, column: 0 },\n          end: { line: 0, column: 0 },\n        }\n      }\n\n      const shouldHighlightLine = calculateLinesToHighlight(meta)\n      const startingLineNumber = calculateStartingLine(meta)\n      const codeLineArray = createLineNodes(refractorRoot.position.end.line)\n\n      const falseShowLineNumbersStr = [\n        'showlinenumbers=false',\n        'showlinenumbers=\"false\"',\n        'showlinenumbers={false}',\n      ]\n      for (const [i, line] of codeLineArray.entries()) {\n        // Default class name for each line\n        line.properties.className = ['code-line']\n\n        // Syntax highlight\n        const treeExtract = filter(\n          refractorRoot,\n          (node) => node.position.start.line <= i + 1 && node.position.end.line >= i + 1\n        )\n        line.children = treeExtract.children\n\n        // Line number\n        if (\n          (meta.toLowerCase().includes('showLineNumbers'.toLowerCase()) ||\n            options.showLineNumbers) &&\n          !falseShowLineNumbersStr.some((str) => meta.toLowerCase().includes(str))\n        ) {\n          line.properties.line = [(i + startingLineNumber).toString()]\n          line.properties.className.push('line-number')\n        }\n\n        // Line highlight\n        if (shouldHighlightLine(i)) {\n          line.properties.className.push('highlight-line')\n        }\n\n        // Diff classes\n        if ((lang === 'diff' || lang?.includes('diff-')) && toString(line).substring(0, 1) === '-') {\n          line.properties.className.push('deleted')\n        } else if ((lang === 'diff' || lang?.includes('diff-')) && toString(line).substring(0, 1) === '+') {\n          line.properties.className.push('inserted')\n        }\n      }\n\n      // Remove possible trailing line when splitting by \\n which results in empty array\n      if (\n        codeLineArray.length > 0 &&\n        toString(codeLineArray[codeLineArray.length - 1]).trim() === ''\n      ) {\n        codeLineArray.pop()\n      }\n\n      node.children = codeLineArray\n    }\n  }\n}\n\nexport default rehypePrismGenerator\n","import { refractor as refractorAll } from 'refractor/lib/all.js'\nimport rehypePrismGenerator from './generator.js'\n\n/**\n * Rehype prism plugin that highlights code blocks with refractor (prismjs)\n * This supports all the languages and should be used on the server side.\n *\n * Consider using rehypePrismCommon or rehypePrismGenerator to generate a plugin\n * that supports your required languages.\n */\nconst rehypePrismAll = rehypePrismGenerator(refractorAll)\n\nexport default rehypePrismAll\n","import { refractor as refractorCommon } from 'refractor/lib/common.js'\nimport rehypePrismGenerator from './generator.js'\n\n/**\n * Rehype prism plugin that highlights code blocks with refractor (prismjs)\n * Supported languages: https://github.com/wooorm/refractor#data\n *\n * Consider using rehypePrismGenerator to generate a plugin\n * that supports your required languages.\n */\nconst rehypePrismCommon = rehypePrismGenerator(refractorCommon)\n\nexport default rehypePrismCommon\n","const rtlRange = '\\u0591-\\u07FF\\uFB1D-\\uFDFD\\uFE70-\\uFEFC'\nconst ltrRange =\n  'A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6' +\n  '\\u00F8-\\u02B8\\u0300-\\u0590\\u0800-\\u1FFF\\u200E\\u2C00-\\uFB1C' +\n  '\\uFE00-\\uFE6F\\uFEFD-\\uFFFF'\n\n/* eslint-disable no-misleading-character-class */\nconst rtl = new RegExp('^[^' + ltrRange + ']*[' + rtlRange + ']')\nconst ltr = new RegExp('^[^' + rtlRange + ']*[' + ltrRange + ']')\n/* eslint-enable no-misleading-character-class */\n\n/**\n * Detect the direction of text: left-to-right, right-to-left, or neutral\n *\n * @param {string} value\n * @returns {'rtl'|'ltr'|'neutral'}\n */\nexport function direction(value) {\n  const source = String(value || '')\n  return rtl.test(source) ? 'rtl' : ltr.test(source) ? 'ltr' : 'neutral'\n}\n","/**\n * @typedef {import('./types.js').Node} Node\n * @typedef {import('./types.js').Element} Element\n * @typedef {import('./types.js').Parent} Parent\n * @typedef {import('hast-util-is-element').AssertPredicate<Element>} IsElement\n */\n\nimport {convertElement} from 'hast-util-is-element'\n\n/**\n * @param {Node} node\n * @returns {node is Parent}\n */\nexport function parent(node) {\n  // @ts-expect-error: hush.\n  return Array.isArray(node.children)\n}\n\n/** @type {IsElement} */\n// @ts-expect-error it works.\nexport const element = convertElement()\n","/**\n * @typedef {import('./types.js').SelectState} SelectState\n * @typedef {import('./types.js').HastNode} HastNode\n * @typedef {import('./types.js').ElementChild} ElementChild\n * @typedef {import('./types.js').Direction} Direction\n * @typedef {import('unist-util-visit/complex-types').Visitor<ElementChild>} Visitor\n */\n\nimport {direction} from 'direction'\nimport {isElement} from 'hast-util-is-element'\nimport {toString} from 'hast-util-to-string'\nimport {svg} from 'property-information'\nimport {visit, EXIT, SKIP} from 'unist-util-visit'\nimport {element} from './util.js'\n\n/**\n * @param {SelectState} state\n * @param {HastNode} node\n * @returns {() => void}\n */\n// eslint-disable-next-line complexity\nexport function enterState(state, node) {\n  const schema = state.schema\n  const language = state.language\n  const currentDirection = state.direction\n  const editableOrEditingHost = state.editableOrEditingHost\n  /** @type {Direction|undefined} */\n  let dirInferred\n  /** @type {boolean|undefined} */\n  let found\n\n  if (element(node) && node.properties) {\n    const lang = node.properties.xmlLang || node.properties.lang\n    const type = node.properties.type || 'text'\n    const dir = dirProperty(node)\n\n    if (lang !== undefined && lang !== null) {\n      state.language = String(lang)\n      found = true\n    }\n\n    if (schema && schema.space === 'html') {\n      if (node.properties.contentEditable === 'true') {\n        state.editableOrEditingHost = true\n        found = true\n      }\n\n      if (isElement(node, 'svg')) {\n        state.schema = svg\n        found = true\n      }\n\n      // See: <https://html.spec.whatwg.org/#the-directionality>.\n      // Explicit `[dir=rtl]`.\n      if (dir === 'rtl') {\n        dirInferred = dir\n      } else if (\n        // Explicit `[dir=ltr]`.\n        dir === 'ltr' ||\n        // HTML with an invalid or no `[dir]`.\n        (dir !== 'auto' && isElement(node, 'html')) ||\n        // `input[type=tel]` with an invalid or no `[dir]`.\n        (dir !== 'auto' && isElement(node, 'input') && type === 'tel')\n      ) {\n        dirInferred = 'ltr'\n        // `[dir=auto]` or `bdi` with an invalid or no `[dir]`.\n      } else if (dir === 'auto' || isElement(node, 'bdi')) {\n        if (isElement(node, 'textarea')) {\n          // Check contents of `<textarea>`.\n          dirInferred = dirBidi(toString(node))\n        } else if (\n          isElement(node, 'input') &&\n          (type === 'email' ||\n            type === 'search' ||\n            type === 'tel' ||\n            type === 'text')\n        ) {\n          // Check value of `<input>`.\n          // @ts-expect-error something is `never` in types but this is needed.\n          dirInferred = node.properties.value\n            ? // @ts-expect-error Assume string\n              dirBidi(node.properties.value)\n            : 'ltr'\n        } else {\n          // Check text nodes in `node`.\n          visit(node, inferDirectionality)\n        }\n      }\n\n      if (dirInferred) {\n        state.direction = dirInferred\n        found = true\n      }\n    }\n    // Turn off editing mode in non-HTML spaces.\n    else if (state.editableOrEditingHost) {\n      state.editableOrEditingHost = false\n      found = true\n    }\n  }\n\n  return found ? reset : noop\n\n  function reset() {\n    state.schema = schema\n    state.language = language\n    state.direction = currentDirection\n    state.editableOrEditingHost = editableOrEditingHost\n  }\n\n  /** @type {Visitor} */\n  function inferDirectionality(child) {\n    if (child.type === 'text') {\n      dirInferred = dirBidi(child.value)\n      return dirInferred ? EXIT : null\n    }\n\n    if (\n      child !== node &&\n      (isElement(child, ['bdi', 'script', 'style', 'textare']) ||\n        dirProperty(child))\n    ) {\n      return SKIP\n    }\n  }\n}\n\n/**\n * @param {string} value\n * @returns {Direction|undefined}\n */\nfunction dirBidi(value) {\n  const result = direction(value)\n  return result === 'neutral' ? undefined : result\n}\n\n/**\n * @param {ElementChild} node\n * @returns {Direction|undefined}\n */\nfunction dirProperty(node) {\n  const value =\n    element(node) && node.properties && typeof node.properties.dir === 'string'\n      ? node.properties.dir.toLowerCase()\n      : undefined\n\n  return value === 'auto' || value === 'ltr' || value === 'rtl'\n    ? value\n    : undefined\n}\n\nfunction noop() {}\n","/**\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').Node} Node\n * @typedef {import('./types.js').Element} Element\n * @typedef {import('./types.js').Parent} Parent\n * @typedef {import('./types.js').SelectState} SelectState\n * @typedef {import('./types.js').SelectIterator} SelectIterator\n * @typedef {import('./types.js').Handler} Handler\n */\n\nimport {zwitch} from 'zwitch'\nimport {enterState} from './enter-state.js'\nimport {parent, element} from './util.js'\n\nconst own = {}.hasOwnProperty\n\nconst handle = zwitch('nestingOperator', {\n  // @ts-expect-error: hush.\n  unknown: unknownNesting,\n  // @ts-expect-error: hush.\n  invalid: topScan, // `undefined` is the top query selector.\n  handlers: {\n    // @ts-expect-error: hush.\n    null: descendant, // `null` is the descendant combinator.\n    // @ts-expect-error: hush.\n    '>': child,\n    // @ts-expect-error: hush.\n    '+': adjacentSibling,\n    // @ts-expect-error: hush.\n    '~': generalSibling\n  }\n})\n\n/** @type {Handler} */\nexport function nest(query, node, index, parent, state) {\n  handle(query, node, index, parent, state)\n}\n\n// Shouldn’t be called, parser gives correct data.\n/* c8 ignore next 6 */\n/**\n * @param {{[x: string]: unknown, type: string}} query\n */\nfunction unknownNesting(query) {\n  throw new Error('Unexpected nesting `' + query.nestingOperator + '`')\n}\n\n/** @type {Handler} */\nfunction topScan(query, node, index, parent, state) {\n  // Shouldn’t happen.\n  /* c8 ignore next 3 */\n  if (parent || index === null) {\n    throw new Error('topScan is supposed to be called from the root node')\n  }\n\n  // Shouldn’t happen.\n  /* c8 ignore next 3 */\n  if (!state.iterator) {\n    throw new Error('Expected `iterator`')\n  }\n\n  state.iterator(query, node, index, parent, state)\n  if (!state.shallow) descendant(query, node, index, parent, state)\n}\n\n/** @type {Handler} */\nfunction descendant(query, node, index, parent, state) {\n  const previous = state.iterator\n\n  state.iterator = iterator\n  child(query, node, index, parent, state)\n\n  /** @type {SelectIterator} */\n  function iterator(query, node, index, parent, state) {\n    // Shouldn’t happen.\n    /* c8 ignore next 3 */\n    if (!previous) {\n      throw new Error('Expected `iterator`')\n    }\n\n    state.iterator = previous\n    previous(query, node, index, parent, state)\n    state.iterator = iterator\n\n    if (state.one && state.found) return\n\n    child(query, node, index, parent, state)\n  }\n}\n\n/** @type {Handler} */\nfunction child(query, node, _1, _2, state) {\n  if (!parent(node)) return\n  if (node.children.length === 0) return\n  indexedSearch(query, node, state)\n}\n\n/** @type {Handler} */\nfunction adjacentSibling(query, _, index, parent, state) {\n  // Shouldn’t happen.\n  /* c8 ignore next */\n  if (!parent || index === null) return\n  indexedSearch(query, parent, state, index + 1, true)\n}\n\n/** @type {Handler} */\nfunction generalSibling(query, _, index, parent, state) {\n  // Shouldn’t happen.\n  /* c8 ignore next */\n  if (!parent || index === null) return\n  indexedSearch(query, parent, state, index + 1)\n}\n\n/**\n * Handles `typeIndex` and `typeCount` properties for every walker.\n *\n * @param {Rule} query\n * @param {Parent} parent\n * @param {SelectState} state\n * @param {number} [from=0]\n * @param {boolean} [firstElementOnly=false]\n */\nfunction indexedSearch(query, parent, state, from, firstElementOnly) {\n  const handle = state.index ? delay : add\n  const children = parent.children\n  let elements = 0\n  let index = -1\n  /** @type {Record<string, number>} */\n  const types = {}\n  /** @type {Array<Function>} */\n  const delayed = []\n\n  // Start looking at `from`\n  if (from === undefined || from === null) from = 0\n\n  // Exit if there are no further nodes.\n  if (from >= children.length) return\n\n  // If we need to index for types, do so for all elements before `from`.\n  if (state.index) {\n    while (++index < from) {\n      const child = children[index]\n      if (element(child)) count(child.tagName)\n    }\n  }\n\n  index = from - 1\n\n  while (++index < children.length) {\n    const child = children[index]\n    // Only check elements.\n    // Check either all elements, or only check the first sibling\n    if (element(child)) {\n      handle(child, index)\n\n      // Stop if we’re looking for one node and it’s already found.\n      if (state.one && state.found) return\n      if (firstElementOnly) break\n    }\n  }\n\n  if (state.index) {\n    index = -1\n\n    while (++index < delayed.length) {\n      delayed[index]()\n      if (state.one && state.found) return\n    }\n  }\n\n  /**\n   * @param {Element} node\n   * @param {number} childIndex\n   */\n  function delay(node, childIndex) {\n    const elementsBefore = elements\n    const elementsByTypeBefore = own.call(types, node.tagName)\n      ? types[node.tagName]\n      : 0\n\n    count(node.tagName)\n\n    delayed.push(fn)\n\n    function fn() {\n      // Before counting further elements:\n      state.elementIndex = elementsBefore\n      state.typeIndex = elementsByTypeBefore\n\n      // After counting all elements.\n      state.elementCount = elements\n      state.typeCount = types[node.tagName]\n\n      add(node, childIndex)\n    }\n  }\n\n  /**\n   * @param {Element} node\n   * @param {number} childIndex\n   */\n  function add(node, childIndex) {\n    const exit = enterState(state, node)\n\n    // Shouldn’t happen.\n    /* c8 ignore next 3 */\n    if (!state.iterator) {\n      throw new Error('Expected `iterator`')\n    }\n\n    state.iterator(query, node, childIndex, parent, state)\n    exit()\n  }\n\n  /**\n   * @param {string} name\n   */\n  function count(name) {\n    if (!own.call(types, name)) types[name] = 0\n    elements++\n    types[name]++\n  }\n}\n","/**\n * See <https://tools.ietf.org/html/rfc4647#section-3.1>\n * for more information on the algorithms.\n */\n\n/**\n * @typedef {string} Tag\n * @typedef {Array<Tag>} Tags\n * @typedef {string} Range\n * @typedef {Array<Range>} Ranges\n *\n * @callback Check\n * @param {Tag} tag\n * @param {Range} range\n * @returns {boolean}\n *\n * @typedef {FilterOrLookup<true>} Filter\n * @typedef {FilterOrLookup<false>} Lookup\n */\n\n/**\n * @template {boolean} IsFilter\n * @callback FilterOrLookup\n * @param {Tag|Tags} tags\n * @param {Range|Ranges} [ranges='*']\n * @returns {IsFilter extends true ? Tags : Tag|undefined}\n */\n\n/**\n * Factory to perform a filter or a lookup.\n * This factory creates a function that accepts a list of tags and a list of\n * ranges, and contains logic to exit early for lookups.\n * `check` just has to deal with one tag and one range.\n * This match function iterates over ranges, and for each range,\n * iterates over tags.  That way, earlier ranges matching any tag have\n * precedence over later ranges.\n *\n * @template {boolean} IsFilter\n * @param {Check} check\n * @param {IsFilter} filter\n * @returns {FilterOrLookup<IsFilter>}\n */\nfunction factory(check, filter) {\n  return function (tags, ranges) {\n    let left = cast(tags, 'tag')\n    const right = cast(\n      ranges === null || ranges === undefined ? '*' : ranges,\n      'range'\n    )\n    /** @type {Tags} */\n    const matches = []\n    let rightIndex = -1\n\n    while (++rightIndex < right.length) {\n      const range = right[rightIndex].toLowerCase()\n\n      // Ignore wildcards in lookup mode.\n      if (!filter && range === '*') continue\n\n      let leftIndex = -1\n      /** @type {Tags} */\n      const next = []\n\n      while (++leftIndex < left.length) {\n        if (check(left[leftIndex].toLowerCase(), range)) {\n          // Exit if this is a lookup and we have a match.\n          if (!filter) {\n            return /** @type {IsFilter extends true ? Tags : Tag|undefined} */ (\n              left[leftIndex]\n            )\n          }\n\n          matches.push(left[leftIndex])\n        } else {\n          next.push(left[leftIndex])\n        }\n      }\n\n      left = next\n    }\n\n    // If this is a filter, return the list.  If it’s a lookup, we didn’t find\n    // a match, so return `undefined`.\n    return /** @type {IsFilter extends true ? Tags : Tag|undefined} */ (\n      filter ? matches : undefined\n    )\n  }\n}\n\n/**\n * Basic Filtering (Section 3.3.1) matches a language priority list consisting\n * of basic language ranges (Section 2.1) to sets of language tags.\n */\nexport const basicFilter = factory(function (tag, range) {\n  return range === '*' || tag === range || tag.includes(range + '-')\n}, true)\n\n/**\n * Extended Filtering (Section 3.3.2) matches a language priority list\n * consisting of extended language ranges (Section 2.2) to sets of language\n * tags.\n */\nexport const extendedFilter = factory(function (tag, range) {\n  // 3.3.2.1\n  const left = tag.split('-')\n  const right = range.split('-')\n  let leftIndex = 0\n  let rightIndex = 0\n\n  // 3.3.2.2\n  if (right[rightIndex] !== '*' && left[leftIndex] !== right[rightIndex]) {\n    return false\n  }\n\n  leftIndex++\n  rightIndex++\n\n  // 3.3.2.3\n  while (rightIndex < right.length) {\n    // 3.3.2.3.A\n    if (right[rightIndex] === '*') {\n      rightIndex++\n      continue\n    }\n\n    // 3.3.2.3.B\n    if (!left[leftIndex]) return false\n\n    // 3.3.2.3.C\n    if (left[leftIndex] === right[rightIndex]) {\n      leftIndex++\n      rightIndex++\n      continue\n    }\n\n    // 3.3.2.3.D\n    if (left[leftIndex].length === 1) return false\n\n    // 3.3.2.3.E\n    leftIndex++\n  }\n\n  // 3.3.2.4\n  return true\n}, true)\n\n/**\n * Lookup (Section 3.4) matches a language priority list consisting of basic\n * language ranges to sets of language tags to find the one exact language tag\n * that best matches the range.\n */\nexport const lookup = factory(function (tag, range) {\n  let right = range\n\n  /* eslint-disable-next-line no-constant-condition */\n  while (true) {\n    if (right === '*' || tag === right) return true\n\n    let index = right.lastIndexOf('-')\n\n    if (index < 0) return false\n\n    if (right.charAt(index - 2) === '-') index -= 2\n\n    right = right.slice(0, index)\n  }\n}, false)\n\n/**\n * Validate tags or ranges, and cast them to arrays.\n *\n * @param {string|Array<string>} values\n * @param {string} name\n * @returns {Array<string>}\n */\nfunction cast(values, name) {\n  const value = values && typeof values === 'string' ? [values] : values\n\n  if (!value || typeof value !== 'object' || !('length' in value)) {\n    throw new Error(\n      'Invalid ' + name + ' `' + value + '`, expected non-empty string'\n    )\n  }\n\n  return value\n}\n","/**\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').RulePseudo} RulePseudo\n * @typedef {import('./types.js').RulePseudoNth} RulePseudoNth\n * @typedef {import('./types.js').RulePseudoSelector} RulePseudoSelector\n * @typedef {import('./types.js').Parent} Parent\n * @typedef {import('./types.js').Selector} Selector\n * @typedef {import('./types.js').Selectors} Selectors\n * @typedef {import('./types.js').SelectState} SelectState\n * @typedef {import('./types.js').Element} Element\n * @typedef {import('./types.js').ElementChild} ElementChild\n */\n\nimport {extendedFilter} from 'bcp-47-match'\nimport {parse as commas} from 'comma-separated-tokens'\nimport {hasProperty} from 'hast-util-has-property'\nimport {isElement} from 'hast-util-is-element'\nimport {whitespace} from 'hast-util-whitespace'\nimport {zwitch} from 'zwitch'\nimport {any} from './any.js'\n\nconst handle = zwitch('name', {\n  // @ts-expect-error: hush.\n  unknown: unknownPseudo,\n  invalid: invalidPseudo,\n  handlers: {\n    // @ts-expect-error: hush.\n    any: matches,\n    // @ts-expect-error: hush.\n    'any-link': anyLink,\n    // @ts-expect-error: hush.\n    blank,\n    // @ts-expect-error: hush.\n    checked,\n    // @ts-expect-error: hush.\n    dir,\n    // @ts-expect-error: hush.\n    disabled,\n    // @ts-expect-error: hush.\n    empty,\n    // @ts-expect-error: hush.\n    enabled,\n    // @ts-expect-error: hush.\n    'first-child': firstChild,\n    // @ts-expect-error: hush.\n    'first-of-type': firstOfType,\n    // @ts-expect-error: hush.\n    has,\n    // @ts-expect-error: hush.\n    lang,\n    // @ts-expect-error: hush.\n    'last-child': lastChild,\n    // @ts-expect-error: hush.\n    'last-of-type': lastOfType,\n    // @ts-expect-error: hush.\n    matches,\n    // @ts-expect-error: hush.\n    not,\n    // @ts-expect-error: hush.\n    'nth-child': nthChild,\n    // @ts-expect-error: hush.\n    'nth-last-child': nthLastChild,\n    // @ts-expect-error: hush.\n    'nth-of-type': nthOfType,\n    // @ts-expect-error: hush.\n    'nth-last-of-type': nthLastOfType,\n    // @ts-expect-error: hush.\n    'only-child': onlyChild,\n    // @ts-expect-error: hush.\n    'only-of-type': onlyOfType,\n    // @ts-expect-error: hush.\n    optional,\n    // @ts-expect-error: hush.\n    'read-only': readOnly,\n    // @ts-expect-error: hush.\n    'read-write': readWrite,\n    // @ts-expect-error: hush.\n    required,\n    // @ts-expect-error: hush.\n    root,\n    // @ts-expect-error: hush.\n    scope\n  }\n})\n\npseudo.needsIndex = [\n  'first-child',\n  'first-of-type',\n  'last-child',\n  'last-of-type',\n  'nth-child',\n  'nth-last-child',\n  'nth-of-type',\n  'nth-last-of-type',\n  'only-child',\n  'only-of-type'\n]\n\n/**\n * @param {Rule} query\n * @param {Element} element\n * @param {number|null} index\n * @param {Parent|null} parent\n * @param {SelectState} state\n * @returns {boolean}\n */\nexport function pseudo(query, element, index, parent, state) {\n  const pseudos = query.pseudos\n  let offset = -1\n\n  while (++offset < pseudos.length) {\n    if (!handle(pseudos[offset], element, index, parent, state)) return false\n  }\n\n  return true\n}\n\n/**\n * @param {RulePseudoSelector} query\n * @param {Element} element\n * @param {number|null} _1\n * @param {Parent|null} _2\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction matches(query, element, _1, _2, state) {\n  const shallow = state.shallow\n  const one = state.one\n\n  state.shallow = true\n  state.one = true\n\n  const result = any(query.value, element, state)[0] === element\n\n  state.shallow = shallow\n  state.one = one\n\n  return result\n}\n\n/**\n * @param {RulePseudoSelector} query\n * @param {Element} element\n * @param {number|null} index\n * @param {Parent|null} parent\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction not(query, element, index, parent, state) {\n  return !matches(query, element, index, parent, state)\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @returns {boolean}\n */\nfunction anyLink(_, element) {\n  return (\n    isElement(element, ['a', 'area', 'link']) && hasProperty(element, 'href')\n  )\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @returns {boolean}\n */\nfunction checked(_, element) {\n  if (isElement(element, ['input', 'menuitem'])) {\n    return Boolean(\n      element.properties &&\n        (element.properties.type === 'checkbox' ||\n          element.properties.type === 'radio') &&\n        hasProperty(element, 'checked')\n    )\n  }\n\n  if (isElement(element, 'option')) {\n    return hasProperty(element, 'selected')\n  }\n\n  return false\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction dir(query, _1, _2, _3, state) {\n  return state.direction === query.value\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @returns {boolean}\n */\nfunction disabled(_, element) {\n  return (\n    isElement(element, [\n      'button',\n      'input',\n      'select',\n      'textarea',\n      'optgroup',\n      'option',\n      'menuitem',\n      'fieldset'\n    ]) && hasProperty(element, 'disabled')\n  )\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} element\n * @returns {boolean}\n */\nfunction enabled(query, element) {\n  return !disabled(query, element)\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @returns {boolean}\n */\nfunction required(_, element) {\n  return (\n    isElement(element, ['input', 'textarea', 'select']) &&\n    hasProperty(element, 'required')\n  )\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} element\n * @returns {boolean}\n */\nfunction optional(query, element) {\n  return !required(query, element)\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @param {number|null} _1\n * @param {Parent|null} _2\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction readWrite(_, element, _1, _2, state) {\n  return isElement(element, ['input', 'textarea'])\n    ? !hasProperty(element, 'readOnly') && !hasProperty(element, 'disabled')\n    : Boolean(state.editableOrEditingHost)\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} element\n * @param {number|null} index\n * @param {Parent|null} parent\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction readOnly(query, element, index, parent, state) {\n  return !readWrite(query, element, index, parent, state)\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @param {number|null} _1\n * @param {Parent|null} parent\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction root(_, element, _1, parent, state) {\n  return Boolean(\n    (!parent || parent.type === 'root') &&\n      state.schema &&\n      (state.schema.space === 'html' || state.schema.space === 'svg') &&\n      isElement(element, ['html', 'svg'])\n  )\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @param {number|null} _1\n * @param {Parent|null} _2\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction scope(_, element, _1, _2, state) {\n  return Boolean(\n    isElement(element) &&\n      state.scopeElements &&\n      state.scopeElements.includes(element)\n  )\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @returns {boolean}\n */\nfunction empty(_, element) {\n  return !someChildren(element, check)\n\n  /**\n   * @param {ElementChild} child\n   * @returns {boolean}\n   */\n  function check(child) {\n    return child.type === 'element' || child.type === 'text'\n  }\n}\n\n/**\n * @param {RulePseudo} _\n * @param {Element} element\n * @returns {boolean}\n */\nfunction blank(_, element) {\n  return !someChildren(element, check)\n\n  /**\n   * @param {ElementChild} child\n   * @returns {boolean}\n   */\n  function check(child) {\n    return (\n      child.type === 'element' || (child.type === 'text' && !whitespace(child))\n    )\n  }\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction firstChild(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return state.elementIndex === 0\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction lang(query, _1, _2, _3, state) {\n  return (\n    state.language !== '' &&\n    state.language !== undefined &&\n    state.language !== null &&\n    // @ts-expect-error never `selectors`.\n    extendedFilter(state.language, commas(query.value)).length > 0\n  )\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction lastChild(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return Boolean(\n    state.elementCount && state.elementIndex === state.elementCount - 1\n  )\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction onlyChild(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return state.elementCount === 1\n}\n\n/**\n * @param {RulePseudoNth} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction nthChild(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return (\n    typeof state.elementIndex === 'number' && query.value(state.elementIndex)\n  )\n}\n\n/**\n * @param {RulePseudoNth} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction nthLastChild(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return Boolean(\n    typeof state.elementCount === 'number' &&\n      typeof state.elementIndex === 'number' &&\n      query.value(state.elementCount - state.elementIndex - 1)\n  )\n}\n\n/**\n * @param {RulePseudoNth} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction nthOfType(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return typeof state.typeIndex === 'number' && query.value(state.typeIndex)\n}\n\n/**\n * @param {RulePseudoNth} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction nthLastOfType(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return (\n    typeof state.typeCount === 'number' &&\n    typeof state.typeIndex === 'number' &&\n    query.value(state.typeCount - 1 - state.typeIndex)\n  )\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction firstOfType(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return state.typeIndex === 0\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction lastOfType(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return (\n    typeof state.typeIndex === 'number' &&\n    typeof state.typeCount === 'number' &&\n    state.typeIndex === state.typeCount - 1\n  )\n}\n\n/**\n * @param {RulePseudo} query\n * @param {Element} _1\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction onlyOfType(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return state.typeCount === 1\n}\n\n/**\n * @param {Element} element\n * @param {(child: ElementChild) => boolean} check\n * @returns {boolean}\n */\nfunction someChildren(element, check) {\n  const children = element.children\n  let index = -1\n\n  while (++index < children.length) {\n    if (check(children[index])) return true\n  }\n\n  return false\n}\n\n// Shouldn’t be called, parser gives correct data.\n/* c8 ignore next 3 */\nfunction invalidPseudo() {\n  throw new Error('Invalid pseudo-selector')\n}\n\n/**\n * @param {RulePseudo} query\n */\nfunction unknownPseudo(query) {\n  if (query.name) {\n    throw new Error('Unknown pseudo-selector `' + query.name + '`')\n  }\n\n  throw new Error('Unexpected pseudo-element or empty pseudo-class')\n}\n\n/**\n * @param {SelectState} state\n * @param {RulePseudo|RulePseudoNth} query\n */\nfunction assertDeep(state, query) {\n  if (state.shallow) {\n    throw new Error('Cannot use `:' + query.name + '` without parent')\n  }\n}\n\n/**\n * @param {RulePseudoSelector} query\n * @param {Element} element\n * @param {number|null} _2\n * @param {Parent|null} _3\n * @param {SelectState} state\n * @returns {boolean}\n */\nfunction has(query, element, _2, _3, state) {\n  const shallow = state.shallow\n  const one = state.one\n  const scopeElements = state.scopeElements\n  const value = appendScope(query.value)\n\n  state.shallow = false\n  state.one = true\n  state.scopeElements = [element]\n\n  const result = any(value, element, state).length > 0\n\n  state.shallow = shallow\n  state.one = one\n  state.scopeElements = scopeElements\n\n  return result\n}\n\n/**\n * @param {Selector} value\n * @returns {Selectors}\n */\nfunction appendScope(value) {\n  /** @type {Selectors} */\n  const selector =\n    value.type === 'ruleSet' ? {type: 'selectors', selectors: [value]} : value\n  let index = -1\n\n  while (++index < selector.selectors.length) {\n    const rule = selector.selectors[index].rule\n    rule.nestingOperator = null\n\n    if (\n      !rule.pseudos ||\n      rule.pseudos.length !== 1 ||\n      rule.pseudos[0].name !== 'scope'\n    ) {\n      selector.selectors[index] = {\n        type: 'ruleSet',\n        // @ts-expect-error pseudos are fine w/ just a name!\n        rule: {type: 'rule', rule, pseudos: [{name: 'scope'}]}\n      }\n    }\n  }\n\n  return selector\n}\n","/**\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').RuleAttr} RuleAttr\n * @typedef {import('./types.js').Element} Element\n * @typedef {import('./types.js').Schema} Schema\n * @typedef {import('./types.js').Info} Info\n * @typedef {import('./types.js').PropertyValue} PropertyValue\n */\n\nimport {stringify as commas} from 'comma-separated-tokens'\nimport {hasProperty} from 'hast-util-has-property'\nimport {find} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {zwitch} from 'zwitch'\n\nconst handle = zwitch('operator', {\n  // @ts-expect-error: hush.\n  unknown: unknownOperator,\n  // @ts-expect-error: hush.\n  invalid: exists,\n  handlers: {\n    // @ts-expect-error: hush.\n    '=': exact,\n    // @ts-expect-error: hush.\n    '~=': spaceSeparatedList,\n    // @ts-expect-error: hush.\n    '|=': exactOrPrefix,\n    // @ts-expect-error: hush.\n    '^=': begins,\n    // @ts-expect-error: hush.\n    '$=': ends,\n    // @ts-expect-error: hush.\n    '*=': contains\n  }\n})\n\n/**\n * @param {Rule} query\n * @param {Element} element\n * @param {Schema} schema\n * @returns {boolean}\n */\nexport function attribute(query, element, schema) {\n  const attrs = query.attrs\n  let index = -1\n\n  while (++index < attrs.length) {\n    if (!handle(attrs[index], element, find(schema, attrs[index].name))) {\n      return false\n    }\n  }\n\n  return true\n}\n\n/**\n * `[attr]`\n *\n * @param {RuleAttr} _\n * @param {Element} element\n * @param {Info} info\n * @returns {boolean}\n */\nfunction exists(_, element, info) {\n  return hasProperty(element, info.property)\n}\n\n/**\n * `[attr=value]`\n *\n * @param {RuleAttr} query\n * @param {Element} element\n * @param {Info} info\n * @returns {boolean}\n */\nfunction exact(query, element, info) {\n  return Boolean(\n    hasProperty(element, info.property) &&\n      element.properties &&\n      normalizeValue(element.properties[info.property], info) === query.value\n  )\n}\n\n/**\n * `[attr~=value]`\n *\n * @param {RuleAttr} query\n * @param {Element} element\n * @param {Info} info\n * @returns {boolean}\n */\nfunction spaceSeparatedList(query, element, info) {\n  const value = element.properties && element.properties[info.property]\n\n  return (\n    // If this is a comma-separated list, and the query is contained in it, return\n    // true.\n    (!info.commaSeparated &&\n      value &&\n      typeof value === 'object' &&\n      query.value &&\n      value.includes(query.value)) ||\n    // For all other values (including comma-separated lists), return whether this\n    // is an exact match.\n    (hasProperty(element, info.property) &&\n      normalizeValue(value, info) === query.value)\n  )\n}\n\n/**\n * `[attr|=value]`\n *\n * @param {RuleAttr} query\n * @param {Element} element\n * @param {Info} info\n * @returns {boolean}\n */\nfunction exactOrPrefix(query, element, info) {\n  const value = normalizeValue(\n    element.properties && element.properties[info.property],\n    info\n  )\n\n  return Boolean(\n    hasProperty(element, info.property) &&\n      query.value &&\n      (value === query.value ||\n        (value.slice(0, query.value.length) === query.value &&\n          value.charAt(query.value.length) === '-'))\n  )\n}\n\n/**\n * `[attr^=value]`\n *\n * @param {RuleAttr} query\n * @param {Element} element\n * @param {Info} info\n * @returns {boolean}\n */\nfunction begins(query, element, info) {\n  return Boolean(\n    hasProperty(element, info.property) &&\n      element.properties &&\n      query.value &&\n      normalizeValue(element.properties[info.property], info).slice(\n        0,\n        query.value.length\n      ) === query.value\n  )\n}\n\n/**\n * `[attr$=value]`\n *\n * @param {RuleAttr} query\n * @param {Element} element\n * @param {Info} info\n * @returns {boolean}\n */\nfunction ends(query, element, info) {\n  return Boolean(\n    hasProperty(element, info.property) &&\n      element.properties &&\n      query.value &&\n      normalizeValue(element.properties[info.property], info).slice(\n        -query.value.length\n      ) === query.value\n  )\n}\n\n/**\n * `[attr*=value]`\n *\n * @param {RuleAttr} query\n * @param {Element} element\n * @param {Info} info\n * @returns {boolean}\n */\nfunction contains(query, element, info) {\n  return Boolean(\n    hasProperty(element, info.property) &&\n      element.properties &&\n      query.value &&\n      normalizeValue(element.properties[info.property], info).includes(\n        query.value\n      )\n  )\n}\n\n// Shouldn’t be called, Parser throws an error instead.\n/**\n * @param {RuleAttr} query\n * @returns {boolean}\n */\n/* c8 ignore next 3 */\nfunction unknownOperator(query) {\n  throw new Error('Unknown operator `' + query.operator + '`')\n}\n\n/**\n * Stringify a hast value back to its HTML form.\n *\n * @param {PropertyValue} value\n * @param {Info} info\n * @returns {string}\n */\nfunction normalizeValue(value, info) {\n  if (typeof value === 'boolean') {\n    return info.attribute\n  }\n\n  if (Array.isArray(value)) {\n    return (info.commaSeparated ? commas : spaces)(value)\n  }\n\n  return String(value)\n}\n","/**\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').HastNode} HastNode\n * @typedef {import('./types.js').Element} Element\n * @typedef {import('./types.js').Parent} Parent\n * @typedef {import('./types.js').SelectState} SelectState\n * @typedef {import('hast-util-is-element').AssertPredicate<Element>} IsElement\n */\n\nimport {attribute} from './attribute.js'\nimport {className} from './class-name.js'\nimport {id} from './id.js'\nimport {name} from './name.js'\nimport {pseudo} from './pseudo.js'\nimport {element} from './util.js'\n\n/**\n * @param {Rule} query\n * @param {HastNode} node\n * @param {number|null} index\n * @param {Parent|null} parent\n * @param {SelectState} state\n * @returns {boolean}\n */\nexport function test(query, node, index, parent, state) {\n  return Boolean(\n    element(node) &&\n      state.schema &&\n      (!query.tagName || name(query, node)) &&\n      (!query.classNames || className(query, node)) &&\n      (!query.id || id(query, node)) &&\n      (!query.attrs || attribute(query, node, state.schema)) &&\n      (!query.pseudos || pseudo(query, node, index, parent, state))\n  )\n}\n","/**\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').Element} Element\n */\n\n/**\n * @param {Rule} query\n * @param {Element} element\n * @returns {boolean}\n */\nexport function name(query, element) {\n  return query.tagName === '*' || query.tagName === element.tagName\n}\n","/**\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').Element} Element\n */\n\n/**\n * @param {Rule} query\n * @param {Element} element\n * @returns {boolean}\n */\nexport function className(query, element) {\n  /** @type {Array<string>} */\n  // @ts-expect-error Assume array.\n  const value = element.properties.className || []\n  let index = -1\n\n  if (query.classNames) {\n    while (++index < query.classNames.length) {\n      if (!value.includes(query.classNames[index])) return false\n    }\n  }\n\n  return true\n}\n","/**\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').Element} Element\n */\n\n/**\n * @param {Rule} query\n * @param {Element} element\n * @returns {boolean}\n */\nexport function id(query, element) {\n  return Boolean(element.properties && element.properties.id === query.id)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('./types.js').Selectors} Selectors\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').RuleSet} RuleSet\n * @typedef {import('./types.js').HastNode} HastNode\n * @typedef {import('./types.js').SelectIterator} SelectIterator\n * @typedef {import('./types.js').SelectState} SelectState\n */\n\nimport {html, svg} from 'property-information'\nimport {zwitch} from 'zwitch'\nimport {enterState} from './enter-state.js'\nimport {nest} from './nest.js'\nimport {pseudo} from './pseudo.js'\nimport {test} from './test.js'\n\nconst type = zwitch('type', {\n  // @ts-expect-error: hush.\n  unknown: unknownType,\n  invalid: invalidType,\n  // @ts-expect-error: hush.\n  handlers: {selectors, ruleSet, rule}\n})\n\n/**\n * @param {Selectors|RuleSet|Rule} query\n * @param {HastNode|undefined} node\n * @param {SelectState} state\n * @returns {Array<Element>}\n */\nexport function any(query, node, state) {\n  // @ts-expect-error zwitch types are off.\n  return query && node ? type(query, node, state) : []\n}\n\n/**\n * @param {Selectors} query\n * @param {HastNode} node\n * @param {SelectState} state\n * @returns {Array<Element>}\n */\nfunction selectors(query, node, state) {\n  const collector = new Collector(state.one)\n  let index = -1\n\n  while (++index < query.selectors.length) {\n    collector.collectAll(ruleSet(query.selectors[index], node, state))\n  }\n\n  return collector.result\n}\n\n/**\n * @param {RuleSet} query\n * @param {HastNode} node\n * @param {SelectState} state\n * @returns {Array<Element>}\n */\nfunction ruleSet(query, node, state) {\n  return rule(query.rule, node, state)\n}\n\n/**\n * @param {Rule} query\n * @param {HastNode} tree\n * @param {SelectState} state\n * @returns {Array<Element>}\n */\nfunction rule(query, tree, state) {\n  const collector = new Collector(state.one)\n\n  if (state.shallow && query.rule) {\n    throw new Error('Expected selector without nesting')\n  }\n\n  nest(\n    query,\n    tree,\n    0,\n    null,\n    configure(query, {\n      schema: state.space === 'svg' ? svg : html,\n      language: undefined,\n      direction: 'ltr',\n      editableOrEditingHost: false,\n      // @ts-expect-error assume elements.\n      scopeElements: tree.type === 'root' ? tree.children : [tree],\n      iterator,\n      one: state.one,\n      shallow: state.shallow\n    })\n  )\n\n  return collector.result\n\n  /** @type {SelectIterator} */\n  function iterator(query, node, index, parent, state) {\n    const exit = enterState(state, node)\n\n    if (test(query, node, index, parent, state)) {\n      if (query.rule) {\n        nest(query.rule, node, index, parent, configure(query.rule, state))\n      } else {\n        // @ts-expect-error `test` also asserts `node is Element`\n        collector.collect(node)\n        state.found = true\n      }\n    }\n\n    exit()\n  }\n\n  /**\n   * @template {SelectState} S\n   * @param {Rule} query\n   * @param {S} state\n   * @returns {S}\n   */\n  function configure(query, state) {\n    const pseudos = query.pseudos || []\n    let index = -1\n\n    while (++index < pseudos.length) {\n      if (pseudo.needsIndex.includes(pseudos[index].name)) {\n        state.index = true\n        break\n      }\n    }\n\n    return state\n  }\n}\n\n// Shouldn’t be called, all data is handled.\n/* c8 ignore next 6 */\n/**\n * @param {{[x: string]: unknown, type: string}} query\n */\nfunction unknownType(query) {\n  throw new Error('Unknown type `' + query.type + '`')\n}\n\n// Shouldn’t be called, parser gives correct data.\n/* c8 ignore next 3 */\nfunction invalidType() {\n  throw new Error('Invalid type')\n}\n\nclass Collector {\n  /**\n   * @param {boolean|undefined} [one]\n   */\n  constructor(one) {\n    /** @type {Array<Element>} */\n    this.result = []\n    /** @type {boolean|undefined} */\n    this.one = one\n    /** @type {boolean} */\n    this.found = false\n  }\n\n  /**\n   * Append nodes to array, filtering out duplicates.\n   *\n   * @param {Array<Element>} elements\n   */\n  collectAll(elements) {\n    let index = -1\n\n    while (++index < elements.length) {\n      this.collect(elements[index])\n    }\n  }\n\n  /**\n   * Append one node.\n   *\n   * @param {Element} element\n   */\n  collect(element) {\n    if (this.one) {\n      // Shouldn’t happen, safeguards performance problems.\n      /* c8 ignore next */\n      if (this.found) return\n      this.found = true\n    }\n\n    if (!this.result.includes(element)) this.result.push(element)\n  }\n}\n",null,null,null,"/**\n * @typedef {import('./types.js').Selector} Selector\n * @typedef {import('./types.js').Selectors} Selectors\n * @typedef {import('./types.js').RuleSet} RuleSet\n * @typedef {import('./types.js').Rule} Rule\n * @typedef {import('./types.js').RulePseudo} RulePseudo\n * @typedef {import('./types.js').RulePseudoNth} RulePseudoNth\n */\n\nimport {CssSelectorParser} from 'css-selector-parser'\nimport fauxEsmNthCheck from 'nth-check'\nimport {zwitch} from 'zwitch'\n\n/** @type {import('nth-check').default} */\n// @ts-expect-error\nconst nthCheck = fauxEsmNthCheck.default || fauxEsmNthCheck\n\nconst nth = new Set([\n  'nth-child',\n  'nth-last-child',\n  'nth-of-type',\n  'nth-last-of-type'\n])\n\nconst parser = new CssSelectorParser()\n\n// @ts-expect-error: hush.\nconst compile = zwitch('type', {handlers: {selectors, ruleSet, rule}})\n\nparser.registerAttrEqualityMods('~', '|', '^', '$', '*')\nparser.registerSelectorPseudos('any', 'matches', 'not', 'has')\nparser.registerNestingOperators('>', '+', '~')\n\n/**\n * @param {string} selector\n * @returns {Selector}\n */\nexport function parse(selector) {\n  if (typeof selector !== 'string') {\n    throw new TypeError('Expected `string` as selector, not `' + selector + '`')\n  }\n\n  // @ts-expect-error types are wrong.\n  return compile(parser.parse(selector))\n}\n\n/**\n * @param {Selectors} query\n * @returns {Selectors}\n */\nfunction selectors(query) {\n  let index = -1\n\n  while (++index < query.selectors.length) {\n    compile(query.selectors[index])\n  }\n\n  return query\n}\n\n/**\n * @param {RuleSet} query\n * @returns {Rule}\n */\nfunction ruleSet(query) {\n  return rule(query.rule)\n}\n\n/**\n * @param {Rule} query\n * @returns {Rule}\n */\nfunction rule(query) {\n  const pseudos = query.pseudos || []\n  let index = -1\n\n  while (++index < pseudos.length) {\n    const pseudo = pseudos[index]\n\n    if (nth.has(pseudo.name)) {\n      // @ts-expect-error Patch a non-primitive type.\n      pseudo.value = nthCheck(pseudo.value)\n      // @ts-expect-error Patch a non-primitive type.\n      pseudo.valueType = 'function'\n    }\n  }\n\n  compile(query.rule)\n\n  return query\n}\n","/**\n * @typedef {import('./lib/types.js').Element} Element\n * @typedef {import('./lib/types.js').HastNode} HastNode\n * @typedef {import('./lib/types.js').Space} Space\n */\n\nimport {any} from './lib/any.js'\nimport {parse} from './lib/parse.js'\n\n/**\n * @param {string} selector\n * @param {HastNode} [node]\n * @param {Space} [space]\n * @returns {boolean}\n */\nexport function matches(selector, node, space) {\n  return Boolean(\n    any(parse(selector), node, {space, one: true, shallow: true})[0]\n  )\n}\n\n/**\n * @param {string} selector\n * @param {HastNode} [node]\n * @param {Space} [space]\n * @returns {Element|null}\n */\nexport function select(selector, node, space) {\n  return any(parse(selector), node, {space, one: true})[0] || null\n}\n\n/**\n * @param {string} selector\n * @param {HastNode} [node]\n * @param {Space} [space]\n * @returns {Array<Element>}\n */\nexport function selectAll(selector, node, space) {\n  return any(parse(selector), node, {space})\n}\n","import { Plugin } from 'unified';\nimport { Root, Element, ElementContent, RootContent } from 'hast';\nimport { visit } from 'unist-util-visit';\nimport { selectAll } from 'hast-util-select';\nimport { Test } from 'unist-util-is';\n\n/** Get the node tree source code string */\nexport const getCodeString = (data: ElementContent[] = [], code: string = '') => {\n  data.forEach((node) => {\n    if (node.type === 'text') {\n      code += node.value;\n    } else if (node.type === 'element' && node.children && Array.isArray(node.children)) {\n      code += getCodeString(node.children);\n    }\n  });\n  return code;\n};\n\nexport type RehypeRewriteOptions = {\n  /**\n   * Select an element to be wrapped. Expects a string selector that can be passed to hast-util-select ([supported selectors](https://github.com/syntax-tree/hast-util-select/blob/master/readme.md#support)).\n   * If `selector` is not set then wrap will check for a body all elements.\n   */\n  selector?: string;\n  /** Rewrite Element. */\n  rewrite(node: Root | RootContent, index: number | null, parent: Root | Element | null): void;\n}\n\nconst remarkRewrite: Plugin<[RehypeRewriteOptions?], Root> = (options) => {\n  const { selector, rewrite } = options || {};\n  return (tree) => {\n    if (!rewrite || typeof rewrite !== 'function') return;\n    if (selector && typeof selector === 'string') {\n      const selected = selectAll(selector, tree);\n      if (selected && selected.length > 0) {\n        visit(tree, selected as unknown as Test, (node: Element, index, parent) => {\n          rewrite(node, index, parent);\n        });\n      }\n      return;\n    }\n\n    visit(tree, (node: Root | RootContent, index, parent) => {\n      rewrite(node, index, parent);\n    });\n  }\n}\n\nexport default remarkRewrite;\n","import { Element } from 'hast';\n\nexport const octiconLink: Element = {\n  type: 'element',\n  tagName: 'svg',\n  properties: {\n    className: 'octicon octicon-link',\n    viewBox: '0 0 16 16',\n    version: '1.1',\n    width: '16',\n    height: '16',\n    ariaHidden: 'true',\n  },\n  children: [\n    {\n      type: 'element',\n      tagName: 'path',\n      children: [],\n      properties: {\n        fillRule: 'evenodd',\n        d: 'M7.775 3.275a.75.75 0 001.06 1.06l1.25-1.25a2 2 0 112.83 2.83l-2.5 2.5a2 2 0 01-2.83 0 .75.75 0 00-1.06 1.06 3.5 3.5 0 004.95 0l2.5-2.5a3.5 3.5 0 00-4.95-4.95l-1.25 1.25zm-4.69 9.64a2 2 0 010-2.83l2.5-2.5a2 2 0 012.83 0 .75.75 0 001.06-1.06 3.5 3.5 0 00-4.95 0l-2.5 2.5a3.5 3.5 0 004.95 4.95l1.25-1.25a.75.75 0 00-1.06-1.06l-1.25 1.25a2 2 0 01-2.83 0z',\n      },\n    },\n  ],\n};\n","import { Plugin } from 'unified';\nimport { Root, RootContent } from 'hast';\nimport { visit } from 'unist-util-visit';\n\nexport interface ReservedMetaOptions {}\n\nexport const reservedMeta: Plugin<[ReservedMetaOptions?], Root> = (options = {}) => {\n  return (tree) => {\n    visit(tree, (node: Root | RootContent) => {\n      if (node.type === 'element' && node.tagName === 'code' && node.data && node.data.meta) {\n        node.properties = { ...node.properties, 'data-meta': String(node.data.meta) };\n      }\n    });\n  };\n};\n","import React, { useImperativeHandle } from 'react';\nimport ReactMarkdown, { Options } from 'react-markdown';\nimport { Element } from 'hast';\nimport { PluggableList } from 'unified';\nimport gfm from 'remark-gfm';\nimport raw from 'rehype-raw';\nimport slug from 'rehype-slug';\nimport headings from 'rehype-autolink-headings';\nimport rehypeAttrs from 'rehype-attr';\nimport rehypeIgnore from 'rehype-ignore';\nimport rehypePrism from 'rehype-prism-plus';\nimport rehypeRewrite, { getCodeString, RehypeRewriteOptions } from 'rehype-rewrite';\nimport { octiconLink } from './nodes/octiconLink';\nimport { copyElement } from './nodes/copy';\nimport { useCopied } from './plugins/useCopied';\nimport './styles/markdown.less';\n\nimport { reservedMeta } from './plugins/reservedMeta';\n\nexport interface MarkdownPreviewProps extends Omit<Options, 'children'> {\n  prefixCls?: string;\n  className?: string;\n  source?: string;\n  disableCopy?: boolean;\n  style?: React.CSSProperties;\n  pluginsFilter?: (type: 'rehype' | 'remark', plugin: PluggableList) => PluggableList;\n  warpperElement?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement> & {\n    'data-color-mode'?: 'light' | 'dark';\n  };\n  onScroll?: (e: React.UIEvent<HTMLDivElement>) => void;\n  onMouseOver?: (e: React.MouseEvent<HTMLDivElement>) => void;\n  rehypeRewrite?: RehypeRewriteOptions['rewrite'];\n}\n\nexport interface MarkdownPreviewRef extends MarkdownPreviewProps {\n  mdp: React.RefObject<HTMLDivElement>;\n}\n\nexport default React.forwardRef<MarkdownPreviewRef, MarkdownPreviewProps>((props, ref) => {\n  const {\n    prefixCls = 'wmde-markdown wmde-markdown-color',\n    className,\n    source,\n    style,\n    disableCopy = false,\n    skipHtml = true,\n    onScroll,\n    onMouseOver,\n    pluginsFilter,\n    rehypeRewrite: rewrite,\n    warpperElement = {},\n    ...other\n  } = props;\n  const mdp = React.useRef<HTMLDivElement>(null);\n  useImperativeHandle(ref, () => ({ ...props, mdp }), [mdp, props]);\n  const cls = `${prefixCls || ''} ${className || ''}`;\n  useCopied(mdp);\n\n  const rehypeRewriteHandle: RehypeRewriteOptions['rewrite'] = (node, index, parent) => {\n    if (node.type === 'element' && parent && parent.type === 'root' && /h(1|2|3|4|5|6)/.test(node.tagName)) {\n      const child = node.children && (node.children[0] as Element);\n      if (child && child.properties && child.properties.ariaHidden === 'true') {\n        child.properties = { class: 'anchor', ...child.properties };\n        child.children = [octiconLink];\n      }\n    }\n    if (node.type === 'element' && node.tagName === 'pre' && !disableCopy) {\n      const code = getCodeString(node.children);\n      node.children.push(copyElement(code));\n    }\n    rewrite && rewrite(node, index, parent);\n  };\n\n  const rehypePlugins: PluggableList = [\n    reservedMeta,\n    [rehypePrism, { ignoreMissing: true }],\n    slug,\n    headings,\n    rehypeIgnore,\n    [rehypeRewrite, { rewrite: rehypeRewriteHandle }],\n    [rehypeAttrs, { properties: 'attr' }],\n    ...(other.rehypePlugins || []),\n  ];\n  const customProps: MarkdownPreviewProps = {\n    allowElement: (element, index, parent) => {\n      if (other.allowElement) {\n        return other.allowElement(element, index, parent);\n      }\n      return /^[A-Za-z0-9]+$/.test(element.tagName);\n    },\n  };\n  if (skipHtml) {\n    rehypePlugins.push(raw);\n  }\n  const remarkPlugins = [...(other.remarkPlugins || []), gfm];\n  return (\n    <div ref={mdp} onScroll={onScroll} onMouseOver={onMouseOver} {...warpperElement} className={cls} style={style}>\n      <ReactMarkdown\n        {...customProps}\n        {...other}\n        skipHtml={skipHtml}\n        rehypePlugins={pluginsFilter ? pluginsFilter('rehype', rehypePlugins) : rehypePlugins}\n        remarkPlugins={pluginsFilter ? pluginsFilter('remark', remarkPlugins) : remarkPlugins}\n        children={source || ''}\n      />\n    </div>\n  );\n});\n","import copyTextToClipboard from '@uiw/copy-to-clipboard';\nimport { useCallback, useEffect } from 'react';\n\nexport function useCopied(container: React.RefObject<HTMLDivElement>) {\n  const handle = useCallback((event: Event) => {\n    const target = (event.currentTarget || event.target) as HTMLDivElement;\n    target.classList.add('active');\n    copyTextToClipboard(target.dataset.code as string, function () {\n      setTimeout(() => {\n        target.classList.remove('active');\n      }, 2000);\n    });\n  }, []);\n  useEffect(() => {\n    const btns = container.current?.querySelectorAll('pre code + div.copied');\n    btns && Array.from(btns).forEach((elm) => elm.addEventListener('click', handle, false));\n    return () => {\n      btns && Array.from(btns).forEach((elm) => elm.removeEventListener('click', handle, false));\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [container]);\n}\n","import { Element } from 'hast';\n\nexport function copyElement(str: string = ''): Element {\n  return {\n    type: 'element',\n    tagName: 'div',\n    properties: {\n      class: 'copied',\n      'data-code': str,\n    },\n    children: [\n      {\n        type: 'element',\n        tagName: 'svg',\n        properties: {\n          className: 'octicon-copy',\n          ariaHidden: 'true',\n          viewBox: '0 0 16 16',\n          fill: 'currentColor',\n          height: 12,\n          width: 12,\n        },\n        children: [\n          {\n            type: 'element',\n            tagName: 'path',\n            properties: {\n              fillRule: 'evenodd',\n              d: 'M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 010 1.5h-1.5a.25.25 0 00-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 00.25-.25v-1.5a.75.75 0 011.5 0v1.5A1.75 1.75 0 019.25 16h-7.5A1.75 1.75 0 010 14.25v-7.5z',\n            },\n            children: [],\n          },\n          {\n            type: 'element',\n            tagName: 'path',\n            properties: {\n              fillRule: 'evenodd',\n              d: 'M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0114.25 11h-7.5A1.75 1.75 0 015 9.25v-7.5zm1.75-.25a.25.25 0 00-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 00.25-.25v-7.5a.25.25 0 00-.25-.25h-7.5z',\n            },\n            children: [],\n          },\n        ],\n      },\n      {\n        type: 'element',\n        tagName: 'svg',\n        properties: {\n          className: 'octicon-check',\n          ariaHidden: 'true',\n          viewBox: '0 0 16 16',\n          fill: 'currentColor',\n          height: 12,\n          width: 12,\n        },\n        children: [\n          {\n            type: 'element',\n            tagName: 'path',\n            properties: {\n              fillRule: 'evenodd',\n              d: 'M13.78 4.22a.75.75 0 010 1.06l-7.25 7.25a.75.75 0 01-1.06 0L2.22 9.28a.75.75 0 011.06-1.06L6 10.94l6.72-6.72a.75.75 0 011.06 0z',\n            },\n            children: [],\n          },\n        ],\n      },\n    ],\n  };\n}\n","import { useState } from 'react';\nimport GitHubCorners from '@uiw/react-github-corners';\nimport Github from '@uiw/react-shields/esm/github';\nimport Npm from '@uiw/react-shields/esm/npm';\nimport BackToUp from '@uiw/react-back-to-top';\nimport '@wcj/dark-mode';\nimport logo from './logo.svg';\nimport './App.css';\nimport MarkdownPreview from '../';\nimport MDStr from '../README.md';\n\nlet val = 1;\n\nconst App = () => {\n  const [value, setValue] = useState('');\n  return (\n    <div className=\"App\">\n      <BackToUp>Top</BackToUp>\n      <dark-mode permanent light=\"Light\" dark=\"Dark\"></dark-mode>\n      <GitHubCorners zIndex={9999} fixed target=\"__blank\" href=\"https://github.com/uiwjs/react-markdown-preview\" />\n      <header className=\"App-header\">\n        <img style={{}} src={logo} className=\"App-logo\" alt=\"logo\" />\n        <a href=\"https://github.com/uiwjs/react-markdown-preview\" target=\"_blank\" rel=\"noopener noreferrer\">\n          React Markdown Preview\n        </a>\n        <p>\n          React component preview markdown text in web browser. The minimal amount of CSS to replicate the GitHub\n          Markdown style.\n        </p>\n      </header>\n      <div className=\"App-editor\">\n        <button onClick={() => setValue('# Markdown ' + val++)}>set value</button>\n\n        <textarea\n          placeholder=\"Please enter the Markdown code!\"\n          value={value}\n          spellCheck=\"false\"\n          onChange={(e) => setValue(e.target.value)}\n        />\n        <MarkdownPreview className=\"App-editor-preview\" source={value} />\n      </div>\n      <MarkdownPreview className=\"App-markdown\" source={MDStr.replace(/([\\s\\S]*)<!--dividing-->/, '')} />\n      <div className=\"App-footer\">\n        <Github user=\"uiwjs\" repo=\"react-markdown-preview\">\n          <Github.Social type=\"forks\" href=\"https://github.com/uiwjs/react-markdown-preview\" />\n          <Github.Social type=\"stars\" href=\"https://github.com/uiwjs/react-markdown-preview/stargazers\" />\n          <Github.Social type=\"watchers\" href=\"https://github.com/uiwjs/react-markdown-preview/watchers\" />\n        </Github>\n        <Npm.Version\n          scope=\"@uiw\"\n          packageName=\"react-markdown-preview\"\n          href=\"https://www.npmjs.com/package/@uiw/react-markdown-preview\"\n        />\n      </div>\n    </div>\n  );\n};\n\nexport default App;\n","export default \"React Markdown Preview\\n===\\n<!--dividing-->\\n\\n[![Build and Deploy](https://github.com/uiwjs/react-markdown-preview/actions/workflows/ci.marster.yml/badge.svg)](https://github.com/uiwjs/react-markdown-preview/actions/workflows/ci.marster.yml)\\n[![jsDelivr CDN](https://data.jsdelivr.com/v1/package/npm/@uiw/react-markdown-preview/badge?style=rounded)](https://www.jsdelivr.com/package/npm/@uiw/react-markdown-preview)\\n[![Downloads](https://img.shields.io/npm/dm/@uiw/react-markdown-preview.svg?style=flat)](https://www.npmjs.com/package/@uiw/react-markdown-preview)\\n[![Coverage Status](https://uiwjs.github.io/react-markdown-preview/badge.svg)](https://uiwjs.github.io/react-markdown-preview/coverage/lcov-report/)\\n[![npm version](https://img.shields.io/npm/v/@uiw/react-markdown-preview.svg)](https://www.npmjs.com/package/@uiw/react-markdown-preview)\\n[![npm unpkg](https://img.shields.io/badge/Open%20in-unpkg-blue)](https://uiwjs.github.io/npm-unpkg/#/pkg/@uiw/react-markdown-preview/file/README.md)\\n[![Repo Dependents](https://badgen.net/github/dependents-repo/uiwjs/react-markdown-preview)](https://github.com/uiwjs/react-markdown-preview/network/dependents)\\n\\nReact component preview markdown text in web browser. The minimal amount of CSS to replicate the GitHub Markdown style. The current [document website](https://uiwjs.github.io/react-markdown-preview/) is converted using this react component.\\n\\n## Features\\n\\n- 🌒 Support dark-mode/night-mode. `@v4`\\n- 🙆🏼‍♂️ GitHub style: The markdown content is rendered as close to the way it's rendered on GitHub as possible.\\n- 🏋🏾‍♂️ Support [GFM](https://github.github.com/gfm/) (autolink literals, footnotes, strikethrough, tables, tasklists).\\n- 🍭 Support automatic code block highlight.\\n- 🐝 Support for defining styles via comment.\\n- ⛳️ Support for [GFM footnotes](https://github.blog/changelog/2021-09-30-footnotes-now-supported-in-markdown-fields/)\\n\\n## Quick Start\\n\\n```bash\\n$ npm install @uiw/react-markdown-preview --save\\n```\\n\\n## Usage Example\\n\\n[![Open in CodeSandbox](https://img.shields.io/badge/Open%20in-CodeSandbox-blue?logo=codesandbox)](https://codesandbox.io/embed/react-markdown-preview-co1mj?fontsize=14&hidenavigation=1&theme=dark)\\n\\n```js test:meta\\nimport MarkdownPreview from '@uiw/react-markdown-preview';\\n\\nconst source = `\\n## MarkdownPreview\\n\\n> todo: React component preview markdown text.\\n`;\\n\\nfunction Demo() {\\n  return (\\n    <MarkdownPreview source={source} />\\n  )\\n}\\n```\\n\\n## Disable Header links\\n\\n```js test:meta\\nimport MarkdownPreview from '@uiw/react-markdown-preview';\\n\\nconst source = `\\n## MarkdownPreview\\n\\n## Header 2\\n\\n### Header 3\\n`;\\n\\nfunction Demo() {\\n  return (\\n    <MarkdownPreview\\n      source={source}\\n      rehypeRewrite={(node, index, parent) => {\\n        if (node.tagName === \\\"a\\\" && parent && /^h(1|2|3|4|5|6)/.test(parent.tagName)) {\\n          parent.children = parent.children.slice(1)\\n        }\\n      }}\\n    />\\n  );\\n}\\n```\\n\\n### Options Props\\n\\n```typescript\\nimport { ReactMarkdownProps } from 'react-markdown';\\nimport { RehypeRewriteOptions } from 'rehype-rewrite';\\n\\ntype MarkdownPreviewProps = {\\n  prefixCls?: string;\\n  className?: string;\\n  source?: string;\\n  disableCopy?: boolean;\\n  style?: React.CSSProperties;\\n  pluginsFilter?: (type: 'rehype' | 'remark', plugin: PluggableList) => PluggableList;\\n  warpperElement?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement> & {\\n    'data-color-mode'?: 'light' | 'dark';\\n  };\\n  onScroll?: (e: React.UIEvent<HTMLDivElement>) => void;\\n  onMouseOver?: (e: React.MouseEvent<HTMLDivElement>) => void;\\n  rehypeRewrite?: RehypeRewriteOptions['rewrite'];\\n} & ReactMarkdownProps;\\n```\\n\\n- `source` (`string`, default: `''`)\\\\\\n    Markdown to parse\\n- `className` (`string?`)\\\\\\n    Wrap the markdown in a `div` with this class name\\n\\nThis [`ReactMarkdownProps`](https://github.com/remarkjs/react-markdown/tree/02bac837bf141cdb8face360fb88be6fa33ab194#props) details. [Upgrade `react-markdown` v6](https://github.com/remarkjs/react-markdown/blob/15b4757082cf3f32a25eba0b8ea30baf751a8b40/changelog.md#600---2021-04-15)\\n\\n- `children` (`string`, default: `''`)\\\\\\n    Markdown to parse\\n- `className` (`string?`)\\\\\\n    Wrap the markdown in a `div` with this class name\\n- `skipHtml` (`boolean`, default: ~~`false`~~ -> [`true`](https://github.com/uiwjs/react-markdown-preview/issues/205) )\\\\\\n    Ignore HTML in Markdown completely\\n- `sourcePos` (`boolean`, default: `false`)\\\\\\n    Pass a prop to all components with a serialized position\\n    (`data-sourcepos=\\\"3:1-3:13\\\"`)\\n- `rawSourcePos` (`boolean`, default: `false`)\\\\\\n    Pass a prop to all components with their [position][]\\n    (`sourcePosition: {start: {line: 3, column: 1}, end:…}`)\\n- `includeElementIndex` (`boolean`, default: `false`)\\\\\\n    Pass the `index` (number of elements before it) and `siblingCount` (number\\n    of elements in parent) as props to all components\\n- `allowedElements` (`Array.<string>`, default: `undefined`)\\\\\\n    Tag names to allow (can’t combine w/ `disallowedElements`).\\n    By default all elements are allowed\\n- `disallowedElements` (`Array.<string>`, default: `undefined`)\\\\\\n    Tag names to disallow (can’t combine w/ `allowedElements`).\\n    By default no elements are disallowed\\n- `allowElement` (`(element, index, parent) => boolean?`, optional)\\\\\\n    Function called to check if an element is allowed (when truthy) or not.\\n    `allowedElements` / `disallowedElements` is used first!\\n- `unwrapDisallowed` (`boolean`, default: `false`)\\\\\\n    Extract (unwrap) the children of not allowed elements.\\n    By default, when `strong` is not allowed, it and it’s children is dropped,\\n    but with `unwrapDisallowed` the element itself is dropped but the children\\n    used\\n- `linkTarget` (`string` or `(href, children, title) => string`, optional)\\\\\\n    Target to use on links (such as `_blank` for `<a target=\\\"_blank\\\"…`)\\n- `transformLinkUri` (`(href, children, title) => string`, default:\\n    [`./uri-transformer.js`](https://github.com/remarkjs/react-markdown/blob/02bac837bf141cdb8face360fb88be6fa33ab194/lib/uri-transformer.js), optional)\\\\\\n    URL to use for links.\\n    The default allows only `http`, `https`, `mailto`, and `tel`, and is\\n    exported from this module as `uriTransformer`.\\n    Pass `null` to allow all URLs.\\n    See [security][]\\n- `transformImageUri` (`(src, alt, title) => string`, default:\\n    [`./uri-transformer.js`](https://github.com/remarkjs/react-markdown/blob/02bac837bf141cdb8face360fb88be6fa33ab194/lib/uri-transformer.js), optional)\\\\\\n    Same as `transformLinkUri` but for images\\n- `components` (`Object.<string, Component>`, default: `{}`)\\\\\\n    Object mapping tag names to React components\\n- `remarkPlugins`<!--rehype:style=color: red;background-color: #ffeb3b;--> (`Array.<Plugin>`, default: `[]`)\\\\\\n    List of [remark plugins](https://github.com/remarkjs/remark/blob/main/doc/plugins.md#list-of-plugins) to use.\\n    See the next section for examples on how to pass options\\n- `rehypePlugins`<!--rehype:style=color: red;background-color: #ffeb3b;--> (`Array.<Plugin>`, default: `[]`)\\\\\\n    List of [rehype plugins](https://github.com/rehypejs/rehype/blob/main/doc/plugins.md#list-of-plugins) to use.\\n    See the next section for examples on how to pass options\\n\\n## Markdown Features\\n\\n### Supports for CSS Style\\n\\nUse HTML comments [`<!--rehype:xxx-->`](https://github.com/jaywcjlove/rehype-attr)<!--rehype:style=color: red;--> to let Markdown support style customization.\\n\\n```markdown\\n## Title\\n<!--rehype:style=display: flex; height: 230px; align-items: center; justify-content: center; font-size: 38px;-->\\n\\nMarkdown Supports **Style**<!--rehype:style=color: red;-->\\n```\\n\\n### Support for [GFM footnotes](https://github.blog/changelog/2021-09-30-footnotes-now-supported-in-markdown-fields/)\\n\\n```markdown\\nHere is a simple footnote[^1]. With some additional text after it.\\n\\n[^1]: My reference.\\n```\\n\\n## Support dark-mode/night-mode\\n\\nBy default, the [`dark-mode`](https://github.com/jaywcjlove/dark-mode/) is automatically switched according to the system. If you need to switch manually, just set the `data-color-mode=\\\"dark\\\"` parameter for body. \\n\\n```html\\n<html data-color-mode=\\\"dark\\\">\\n```\\n\\n```js\\ndocument.documentElement.setAttribute('data-color-mode', 'dark')\\ndocument.documentElement.setAttribute('data-color-mode', 'light')\\n```\\n\\nInherit custom color variables by adding [`.wmde-markdown-var`](https://github.com/uiwjs/react-markdown-preview/blob/a53be1e93fb1c2327649c4a6b084adb80679affa/src/styles/markdown.less#L1-L193) selector.\\n\\n```jsx\\nconst Demo = () => {\\n  return (\\n    <div>\\n      <div className=\\\"wmde-markdown-var\\\"> </div>\\n      <MarkdownPreview source=\\\"Hello World!\\\" />\\n    </div>\\n  )\\n}\\n```\\n\\n## Development\\n\\nRuns the project in development mode.  \\n\\n```bash\\n# Step 1, run first,\\n# listen to the component compile and output the .js file\\n# listen for compilation output type .d.ts file\\n# listen to the component compile and output the .css file\\nnpm run watch\\n# Step 2, development mode, listen to compile preview website instance\\nnpm start\\n```\\n\\nBuilds the app for production to the build folder.\\n\\n```bash\\nnpm run build\\n```\\n\\nThe build is minified and the filenames include the hashes.\\nYour app is ready to be deployed!\\n\\n### Alternatives\\n\\nIf you need more features-rich Markdown Editor, you can use [@uiwjs/react-markdown-editor](https://github.com/uiwjs/react-markdown-editor)\\n\\n- [@uiw/react-markdown-editor](https://github.com/uiwjs/react-markdown-editor): A markdown editor with preview, implemented with React.js and TypeScript.\\n- [@uiw/react-md-editor](https://github.com/uiwjs/react-md-editor): A simple markdown editor with preview, implemented with React.js and TypeScript.\\n- [@uiw/react-textarea-code-editor](https://github.com/uiwjs/react-textarea-code-editor): A simple code editor with syntax highlighting.\\n- [@uiw/react-codemirror](https://github.com/uiwjs/react-codemirror): CodeMirror component for React. @codemirror\\n- [@uiw/react-monacoeditor](https://github.com/jaywcjlove/react-monacoeditor): Monaco Editor component for React.\\n\\n## Contributors\\n\\nAs always, thanks to our amazing contributors!\\n\\n<a href=\\\"https://github.com/uiwjs/react-markdown-preview/graphs/contributors\\\">\\n  <img src=\\\"https://uiwjs.github.io/react-markdown-preview/CONTRIBUTORS.svg\\\" />\\n</a>\\n\\nMade with [action-contributors](https://github.com/jaywcjlove/github-action-contributors).\\n\\n## License\\n\\nLicensed under the MIT License.\\n\";","import App from './App';\nimport { createRoot } from 'react-dom/client';\n\nconst container = document.getElementById('root');\nconst root = createRoot(container!);\nroot.render(<App />);\n","/**\n * *** This styling is an extra step which is likely not required. ***\n * https://github.com/w3c/clipboard-apis/blob/master/explainer.adoc#writing-to-the-clipboard\n * \n * Why is it here? To ensure:\n * \n * 1. the element is able to have focus and selection.\n * 2. if element was to flash render it has minimal visual impact.\n * 3. less flakyness with selection and copying which **might** occur if\n *     the textarea element is not visible.\n *\n *   The likelihood is the element won't even render, not even a flash,\n *   so some of these are just precautions. However in IE the element\n *   is visible whilst the popup box asking the user for permission for\n *   the web page to copy to the clipboard.\n *  \n *   Place in top-left corner of screen regardless of scroll position.\n *\n * @typedef CopyTextToClipboard\n * @property {(text: string, method?: (isCopy: boolean) => void) => void} void\n * @returns {void}\n * \n * @param {string} text \n * @param {CopyTextToClipboard} cb \n */\nexport default function copyTextToClipboard(text, cb) {\n  const el = document.createElement('textarea');\n  el.value = text;\n  el.setAttribute('readonly', '');\n  el.style = {\n    position: 'absolute',\n    left: '-9999px',\n  }\n  document.body.appendChild(el);\n  const selected = document.getSelection().rangeCount > 0 ? document.getSelection().getRangeAt(0) : false;\n  el.select();\n  let isCopy = false;\n  try {\n    const successful = document.execCommand('copy');\n    isCopy = !!successful;\n  } catch (err) {\n    isCopy = false;\n  }\n  document.body.removeChild(el);\n  if (selected && document.getSelection) {\n    document.getSelection().removeAllRanges();\n    document.getSelection().addRange(selected);\n  }\n  cb && cb(isCopy);\n};\n","/**\n * @package @wcj/dark-mode\n * Web Component that toggles dark mode 🌒\n * Github: https://github.com/jaywcjlove/dark-mode.git\n * Website: https://jaywcjlove.github.io/dark-mode\n * \n * Licensed under the MIT license.\n * @license Copyright © 2022. Licensed under the MIT License\n * @author kenny wong <wowohoo@qq.com>\n */\nconst t=document;const e=\"_dark_mode_theme_\";const s=\"permanent\";const o=\"colorschemechange\";const i=\"permanentcolorscheme\";const h=\"light\";const r=\"dark\";const n=(t,e,s=e)=>{Object.defineProperty(t,s,{enumerable:true,get(){const t=this.getAttribute(e);return t===null?\"\":t},set(t){this.setAttribute(e,t)}})};const c=(t,e,s=e)=>{Object.defineProperty(t,s,{enumerable:true,get(){return this.hasAttribute(e)},set(t){if(t){this.setAttribute(e,\"\")}else{this.removeAttribute(e)}}})};class a extends HTMLElement{static get observedAttributes(){return[\"mode\",h,r,s]}LOCAL_NANE=e;constructor(){super();this.t()}connectedCallback(){n(this,\"mode\");n(this,r);n(this,h);c(this,s);const a=localStorage.getItem(e);if(a&&[h,r].includes(a)){this.mode=a;this.permanent=true}if(this.permanent&&!a){localStorage.setItem(e,this.mode)}const l=[h,r].includes(a);if(this.permanent&&a){this.o()}else{if(window.matchMedia&&window.matchMedia(\"(prefers-color-scheme: dark)\").matches){this.mode=r;this.o()}if(window.matchMedia&&window.matchMedia(\"(prefers-color-scheme: light)\").matches){this.mode=h;this.o()}}if(!this.permanent&&!l){window.matchMedia(\"(prefers-color-scheme: light)\").onchange=t=>{this.mode=t.matches?h:r;this.o()};window.matchMedia(\"(prefers-color-scheme: dark)\").onchange=t=>{this.mode=t.matches?r:h;this.o()}}const d=new MutationObserver(((s,h)=>{this.mode=t.documentElement.dataset.colorMode;if(this.permanent&&l){localStorage.setItem(e,this.mode);this.i(i,{permanent:this.permanent})}this.h();this.i(o,{colorScheme:this.mode})}));d.observe(t.documentElement,{attributes:true});this.i(o,{colorScheme:this.mode});this.h()}attributeChangedCallback(t,s,o){if(t===\"mode\"&&s!==o&&[h,r].includes(o)){const t=localStorage.getItem(e);if(this.mode===t){this.mode=o;this.h();this.o()}else if(this.mode&&this.mode!==t){this.h();this.o()}}else if((t===h||t===r)&&s!==o){this.h()}if(t===\"permanent\"&&typeof this.permanent===\"boolean\"){this.permanent?localStorage.setItem(e,this.mode):localStorage.removeItem(e)}}o(){t.documentElement.setAttribute(\"data-color-mode\",this.mode)}h(){this.icon.textContent=this.mode===h?\"🌒\":\"🌞\";this.text.textContent=this.mode===h?this.getAttribute(r):this.getAttribute(h);if(!this.text.textContent&&this.text.parentElement&&this.text){this.text.parentElement.removeChild(this.text)}}t(){var s=this.attachShadow({mode:\"open\"});this.label=t.createElement(\"span\");this.label.setAttribute(\"class\",\"wrapper\");this.label.onclick=()=>{this.mode=this.mode===h?r:h;if(this.permanent){localStorage.setItem(e,this.mode)}this.o();this.h()};s.appendChild(this.label);this.icon=t.createElement(\"span\");this.label.appendChild(this.icon);this.text=t.createElement(\"span\");this.label.appendChild(this.text);const o=`\\n[data-color-mode*='dark'], [data-color-mode*='dark'] body {\\n  color-scheme: dark;\\n  --color-theme-bg: #0d1117;\\n  --color-theme-text: #c9d1d9;\\n  background-color: var(--color-theme-bg);\\n  color: var(--color-theme-text);\\n}\\n\\n[data-color-mode*='light'], [data-color-mode*='light'] body {\\n  color-scheme: light;\\n  --color-theme-bg: #fff;\\n  --color-theme-text: #24292f;\\n  background-color: var(--color-theme-bg);\\n  color: var(--color-theme-text);\\n}`;const i=\"_dark_mode_style_\";const n=t.getElementById(i);if(!n){var c=t.createElement(\"style\");c.id=i;c.textContent=o;t.head.appendChild(c)}var a=t.createElement(\"style\");a.textContent=`\\n    .wrapper { cursor: pointer; user-select: none; position: relative; }\\n    .wrapper > span + span { margin-left: .4rem; }\\n    `;s.appendChild(a)}i(t,e){this.dispatchEvent(new CustomEvent(t,{bubbles:true,composed:true,detail:e}))}}customElements.define(\"dark-mode\",a);","module.exports = {\n\ttrueFunc: function trueFunc(){\n\t\treturn true;\n\t},\n\tfalseFunc: function falseFunc(){\n\t\treturn false;\n\t}\n};","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar parser_context_1 = require(\"./parser-context\");\nvar render_1 = require(\"./render\");\nvar CssSelectorParser = /** @class */ (function () {\n    function CssSelectorParser() {\n        this.pseudos = {};\n        this.attrEqualityMods = {};\n        this.ruleNestingOperators = {};\n        this.substitutesEnabled = false;\n    }\n    CssSelectorParser.prototype.registerSelectorPseudos = function () {\n        var pseudos = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            pseudos[_i] = arguments[_i];\n        }\n        for (var _a = 0, pseudos_1 = pseudos; _a < pseudos_1.length; _a++) {\n            var pseudo = pseudos_1[_a];\n            this.pseudos[pseudo] = 'selector';\n        }\n        return this;\n    };\n    CssSelectorParser.prototype.unregisterSelectorPseudos = function () {\n        var pseudos = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            pseudos[_i] = arguments[_i];\n        }\n        for (var _a = 0, pseudos_2 = pseudos; _a < pseudos_2.length; _a++) {\n            var pseudo = pseudos_2[_a];\n            delete this.pseudos[pseudo];\n        }\n        return this;\n    };\n    CssSelectorParser.prototype.registerNumericPseudos = function () {\n        var pseudos = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            pseudos[_i] = arguments[_i];\n        }\n        for (var _a = 0, pseudos_3 = pseudos; _a < pseudos_3.length; _a++) {\n            var pseudo = pseudos_3[_a];\n            this.pseudos[pseudo] = 'numeric';\n        }\n        return this;\n    };\n    CssSelectorParser.prototype.unregisterNumericPseudos = function () {\n        var pseudos = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            pseudos[_i] = arguments[_i];\n        }\n        for (var _a = 0, pseudos_4 = pseudos; _a < pseudos_4.length; _a++) {\n            var pseudo = pseudos_4[_a];\n            delete this.pseudos[pseudo];\n        }\n        return this;\n    };\n    CssSelectorParser.prototype.registerNestingOperators = function () {\n        var operators = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            operators[_i] = arguments[_i];\n        }\n        for (var _a = 0, operators_1 = operators; _a < operators_1.length; _a++) {\n            var operator = operators_1[_a];\n            this.ruleNestingOperators[operator] = true;\n        }\n        return this;\n    };\n    CssSelectorParser.prototype.unregisterNestingOperators = function () {\n        var operators = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            operators[_i] = arguments[_i];\n        }\n        for (var _a = 0, operators_2 = operators; _a < operators_2.length; _a++) {\n            var operator = operators_2[_a];\n            delete this.ruleNestingOperators[operator];\n        }\n        return this;\n    };\n    CssSelectorParser.prototype.registerAttrEqualityMods = function () {\n        var mods = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            mods[_i] = arguments[_i];\n        }\n        for (var _a = 0, mods_1 = mods; _a < mods_1.length; _a++) {\n            var mod = mods_1[_a];\n            this.attrEqualityMods[mod] = true;\n        }\n        return this;\n    };\n    CssSelectorParser.prototype.unregisterAttrEqualityMods = function () {\n        var mods = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            mods[_i] = arguments[_i];\n        }\n        for (var _a = 0, mods_2 = mods; _a < mods_2.length; _a++) {\n            var mod = mods_2[_a];\n            delete this.attrEqualityMods[mod];\n        }\n        return this;\n    };\n    CssSelectorParser.prototype.enableSubstitutes = function () {\n        this.substitutesEnabled = true;\n        return this;\n    };\n    CssSelectorParser.prototype.disableSubstitutes = function () {\n        this.substitutesEnabled = false;\n        return this;\n    };\n    CssSelectorParser.prototype.parse = function (str) {\n        return parser_context_1.parseCssSelector(str, 0, this.pseudos, this.attrEqualityMods, this.ruleNestingOperators, this.substitutesEnabled);\n    };\n    CssSelectorParser.prototype.render = function (path) {\n        return render_1.renderEntity(path).trim();\n    };\n    return CssSelectorParser;\n}());\nexports.CssSelectorParser = CssSelectorParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar utils_1 = require(\"./utils\");\nfunction parseCssSelector(str, pos, pseudos, attrEqualityMods, ruleNestingOperators, substitutesEnabled) {\n    var l = str.length;\n    var chr = '';\n    function getStr(quote, escapeTable) {\n        var result = '';\n        pos++;\n        chr = str.charAt(pos);\n        while (pos < l) {\n            if (chr === quote) {\n                pos++;\n                return result;\n            }\n            else if (chr === '\\\\') {\n                pos++;\n                chr = str.charAt(pos);\n                var esc = void 0;\n                if (chr === quote) {\n                    result += quote;\n                }\n                else if ((esc = escapeTable[chr]) !== undefined) {\n                    result += esc;\n                }\n                else if (utils_1.isHex(chr)) {\n                    var hex = chr;\n                    pos++;\n                    chr = str.charAt(pos);\n                    while (utils_1.isHex(chr)) {\n                        hex += chr;\n                        pos++;\n                        chr = str.charAt(pos);\n                    }\n                    if (chr === ' ') {\n                        pos++;\n                        chr = str.charAt(pos);\n                    }\n                    result += String.fromCharCode(parseInt(hex, 16));\n                    continue;\n                }\n                else {\n                    result += chr;\n                }\n            }\n            else {\n                result += chr;\n            }\n            pos++;\n            chr = str.charAt(pos);\n        }\n        return result;\n    }\n    function getIdent() {\n        var result = '';\n        chr = str.charAt(pos);\n        while (pos < l) {\n            if (utils_1.isIdent(chr)) {\n                result += chr;\n            }\n            else if (chr === '\\\\') {\n                pos++;\n                if (pos >= l) {\n                    throw Error('Expected symbol but end of file reached.');\n                }\n                chr = str.charAt(pos);\n                if (utils_1.identSpecialChars[chr]) {\n                    result += chr;\n                }\n                else if (utils_1.isHex(chr)) {\n                    var hex = chr;\n                    pos++;\n                    chr = str.charAt(pos);\n                    while (utils_1.isHex(chr)) {\n                        hex += chr;\n                        pos++;\n                        chr = str.charAt(pos);\n                    }\n                    if (chr === ' ') {\n                        pos++;\n                        chr = str.charAt(pos);\n                    }\n                    result += String.fromCharCode(parseInt(hex, 16));\n                    continue;\n                }\n                else {\n                    result += chr;\n                }\n            }\n            else {\n                return result;\n            }\n            pos++;\n            chr = str.charAt(pos);\n        }\n        return result;\n    }\n    function skipWhitespace() {\n        chr = str.charAt(pos);\n        var result = false;\n        while (chr === ' ' || chr === \"\\t\" || chr === \"\\n\" || chr === \"\\r\" || chr === \"\\f\") {\n            result = true;\n            pos++;\n            chr = str.charAt(pos);\n        }\n        return result;\n    }\n    function parse() {\n        var res = parseSelector();\n        if (pos < l) {\n            throw Error('Rule expected but \"' + str.charAt(pos) + '\" found.');\n        }\n        return res;\n    }\n    function parseSelector() {\n        var selector = parseSingleSelector();\n        if (!selector) {\n            return null;\n        }\n        var res = selector;\n        chr = str.charAt(pos);\n        while (chr === ',') {\n            pos++;\n            skipWhitespace();\n            if (res.type !== 'selectors') {\n                res = {\n                    type: 'selectors',\n                    selectors: [selector]\n                };\n            }\n            selector = parseSingleSelector();\n            if (!selector) {\n                throw Error('Rule expected after \",\".');\n            }\n            res.selectors.push(selector);\n        }\n        return res;\n    }\n    function parseSingleSelector() {\n        skipWhitespace();\n        var selector = {\n            type: 'ruleSet'\n        };\n        var rule = parseRule();\n        if (!rule) {\n            return null;\n        }\n        var currentRule = selector;\n        while (rule) {\n            rule.type = 'rule';\n            currentRule.rule = rule;\n            currentRule = rule;\n            skipWhitespace();\n            chr = str.charAt(pos);\n            if (pos >= l || chr === ',' || chr === ')') {\n                break;\n            }\n            if (ruleNestingOperators[chr]) {\n                var op = chr;\n                pos++;\n                skipWhitespace();\n                rule = parseRule();\n                if (!rule) {\n                    throw Error('Rule expected after \"' + op + '\".');\n                }\n                rule.nestingOperator = op;\n            }\n            else {\n                rule = parseRule();\n                if (rule) {\n                    rule.nestingOperator = null;\n                }\n            }\n        }\n        return selector;\n    }\n    // @ts-ignore no-overlap\n    function parseRule() {\n        var rule = null;\n        while (pos < l) {\n            chr = str.charAt(pos);\n            if (chr === '*') {\n                pos++;\n                (rule = rule || {}).tagName = '*';\n            }\n            else if (utils_1.isIdentStart(chr) || chr === '\\\\') {\n                (rule = rule || {}).tagName = getIdent();\n            }\n            else if (chr === '.') {\n                pos++;\n                rule = rule || {};\n                (rule.classNames = rule.classNames || []).push(getIdent());\n            }\n            else if (chr === '#') {\n                pos++;\n                (rule = rule || {}).id = getIdent();\n            }\n            else if (chr === '[') {\n                pos++;\n                skipWhitespace();\n                var attr = {\n                    name: getIdent()\n                };\n                skipWhitespace();\n                // @ts-ignore\n                if (chr === ']') {\n                    pos++;\n                }\n                else {\n                    var operator = '';\n                    if (attrEqualityMods[chr]) {\n                        operator = chr;\n                        pos++;\n                        chr = str.charAt(pos);\n                    }\n                    if (pos >= l) {\n                        throw Error('Expected \"=\" but end of file reached.');\n                    }\n                    if (chr !== '=') {\n                        throw Error('Expected \"=\" but \"' + chr + '\" found.');\n                    }\n                    attr.operator = operator + '=';\n                    pos++;\n                    skipWhitespace();\n                    var attrValue = '';\n                    attr.valueType = 'string';\n                    // @ts-ignore\n                    if (chr === '\"') {\n                        attrValue = getStr('\"', utils_1.doubleQuotesEscapeChars);\n                        // @ts-ignore\n                    }\n                    else if (chr === '\\'') {\n                        attrValue = getStr('\\'', utils_1.singleQuoteEscapeChars);\n                        // @ts-ignore\n                    }\n                    else if (substitutesEnabled && chr === '$') {\n                        pos++;\n                        attrValue = getIdent();\n                        attr.valueType = 'substitute';\n                    }\n                    else {\n                        while (pos < l) {\n                            if (chr === ']') {\n                                break;\n                            }\n                            attrValue += chr;\n                            pos++;\n                            chr = str.charAt(pos);\n                        }\n                        attrValue = attrValue.trim();\n                    }\n                    skipWhitespace();\n                    if (pos >= l) {\n                        throw Error('Expected \"]\" but end of file reached.');\n                    }\n                    if (chr !== ']') {\n                        throw Error('Expected \"]\" but \"' + chr + '\" found.');\n                    }\n                    pos++;\n                    attr.value = attrValue;\n                }\n                rule = rule || {};\n                (rule.attrs = rule.attrs || []).push(attr);\n            }\n            else if (chr === ':') {\n                pos++;\n                var pseudoName = getIdent();\n                var pseudo = {\n                    name: pseudoName\n                };\n                // @ts-ignore\n                if (chr === '(') {\n                    pos++;\n                    var value = '';\n                    skipWhitespace();\n                    if (pseudos[pseudoName] === 'selector') {\n                        pseudo.valueType = 'selector';\n                        value = parseSelector();\n                    }\n                    else {\n                        pseudo.valueType = pseudos[pseudoName] || 'string';\n                        // @ts-ignore\n                        if (chr === '\"') {\n                            value = getStr('\"', utils_1.doubleQuotesEscapeChars);\n                            // @ts-ignore\n                        }\n                        else if (chr === '\\'') {\n                            value = getStr('\\'', utils_1.singleQuoteEscapeChars);\n                            // @ts-ignore\n                        }\n                        else if (substitutesEnabled && chr === '$') {\n                            pos++;\n                            value = getIdent();\n                            pseudo.valueType = 'substitute';\n                        }\n                        else {\n                            while (pos < l) {\n                                if (chr === ')') {\n                                    break;\n                                }\n                                value += chr;\n                                pos++;\n                                chr = str.charAt(pos);\n                            }\n                            value = value.trim();\n                        }\n                        skipWhitespace();\n                    }\n                    if (pos >= l) {\n                        throw Error('Expected \")\" but end of file reached.');\n                    }\n                    if (chr !== ')') {\n                        throw Error('Expected \")\" but \"' + chr + '\" found.');\n                    }\n                    pos++;\n                    pseudo.value = value;\n                }\n                rule = rule || {};\n                (rule.pseudos = rule.pseudos || []).push(pseudo);\n            }\n            else {\n                break;\n            }\n        }\n        return rule;\n    }\n    return parse();\n}\nexports.parseCssSelector = parseCssSelector;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar utils_1 = require(\"./utils\");\nfunction renderEntity(entity) {\n    var res = '';\n    switch (entity.type) {\n        case 'ruleSet':\n            var currentEntity = entity.rule;\n            var parts = [];\n            while (currentEntity) {\n                if (currentEntity.nestingOperator) {\n                    parts.push(currentEntity.nestingOperator);\n                }\n                parts.push(renderEntity(currentEntity));\n                currentEntity = currentEntity.rule;\n            }\n            res = parts.join(' ');\n            break;\n        case 'selectors':\n            res = entity.selectors.map(renderEntity).join(', ');\n            break;\n        case 'rule':\n            if (entity.tagName) {\n                if (entity.tagName === '*') {\n                    res = '*';\n                }\n                else {\n                    res = utils_1.escapeIdentifier(entity.tagName);\n                }\n            }\n            if (entity.id) {\n                res += \"#\" + utils_1.escapeIdentifier(entity.id);\n            }\n            if (entity.classNames) {\n                res += entity.classNames.map(function (cn) {\n                    return \".\" + (utils_1.escapeIdentifier(cn));\n                }).join('');\n            }\n            if (entity.attrs) {\n                res += entity.attrs.map(function (attr) {\n                    if ('operator' in attr) {\n                        if (attr.valueType === 'substitute') {\n                            return \"[\" + utils_1.escapeIdentifier(attr.name) + attr.operator + \"$\" + attr.value + \"]\";\n                        }\n                        else {\n                            return \"[\" + utils_1.escapeIdentifier(attr.name) + attr.operator + utils_1.escapeStr(attr.value) + \"]\";\n                        }\n                    }\n                    else {\n                        return \"[\" + utils_1.escapeIdentifier(attr.name) + \"]\";\n                    }\n                }).join('');\n            }\n            if (entity.pseudos) {\n                res += entity.pseudos.map(function (pseudo) {\n                    if (pseudo.valueType) {\n                        if (pseudo.valueType === 'selector') {\n                            return \":\" + utils_1.escapeIdentifier(pseudo.name) + \"(\" + renderEntity(pseudo.value) + \")\";\n                        }\n                        else if (pseudo.valueType === 'substitute') {\n                            return \":\" + utils_1.escapeIdentifier(pseudo.name) + \"($\" + pseudo.value + \")\";\n                        }\n                        else if (pseudo.valueType === 'numeric') {\n                            return \":\" + utils_1.escapeIdentifier(pseudo.name) + \"(\" + pseudo.value + \")\";\n                        }\n                        else {\n                            return (\":\" + utils_1.escapeIdentifier(pseudo.name) +\n                                \"(\" + utils_1.escapeIdentifier(pseudo.value) + \")\");\n                        }\n                    }\n                    else {\n                        return \":\" + utils_1.escapeIdentifier(pseudo.name);\n                    }\n                }).join('');\n            }\n            break;\n        default:\n            throw Error('Unknown entity type: \"' + entity.type + '\".');\n    }\n    return res;\n}\nexports.renderEntity = renderEntity;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction isIdentStart(c) {\n    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c === '-') || (c === '_');\n}\nexports.isIdentStart = isIdentStart;\nfunction isIdent(c) {\n    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '-' || c === '_';\n}\nexports.isIdent = isIdent;\nfunction isHex(c) {\n    return (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') || (c >= '0' && c <= '9');\n}\nexports.isHex = isHex;\nfunction escapeIdentifier(s) {\n    var len = s.length;\n    var result = '';\n    var i = 0;\n    while (i < len) {\n        var chr = s.charAt(i);\n        if (exports.identSpecialChars[chr]) {\n            result += '\\\\' + chr;\n        }\n        else {\n            if (!(chr === '_' || chr === '-' ||\n                (chr >= 'A' && chr <= 'Z') ||\n                (chr >= 'a' && chr <= 'z') ||\n                (i !== 0 && chr >= '0' && chr <= '9'))) {\n                var charCode = chr.charCodeAt(0);\n                if ((charCode & 0xF800) === 0xD800) {\n                    var extraCharCode = s.charCodeAt(i++);\n                    if ((charCode & 0xFC00) !== 0xD800 || (extraCharCode & 0xFC00) !== 0xDC00) {\n                        throw Error('UCS-2(decode): illegal sequence');\n                    }\n                    charCode = ((charCode & 0x3FF) << 10) + (extraCharCode & 0x3FF) + 0x10000;\n                }\n                result += '\\\\' + charCode.toString(16) + ' ';\n            }\n            else {\n                result += chr;\n            }\n        }\n        i++;\n    }\n    return result;\n}\nexports.escapeIdentifier = escapeIdentifier;\nfunction escapeStr(s) {\n    var len = s.length;\n    var result = '';\n    var i = 0;\n    var replacement;\n    while (i < len) {\n        var chr = s.charAt(i);\n        if (chr === '\"') {\n            chr = '\\\\\"';\n        }\n        else if (chr === '\\\\') {\n            chr = '\\\\\\\\';\n        }\n        else if ((replacement = exports.strReplacementsRev[chr]) !== undefined) {\n            chr = replacement;\n        }\n        result += chr;\n        i++;\n    }\n    return \"\\\"\" + result + \"\\\"\";\n}\nexports.escapeStr = escapeStr;\nexports.identSpecialChars = {\n    '!': true,\n    '\"': true,\n    '#': true,\n    '$': true,\n    '%': true,\n    '&': true,\n    '\\'': true,\n    '(': true,\n    ')': true,\n    '*': true,\n    '+': true,\n    ',': true,\n    '.': true,\n    '/': true,\n    ';': true,\n    '<': true,\n    '=': true,\n    '>': true,\n    '?': true,\n    '@': true,\n    '[': true,\n    '\\\\': true,\n    ']': true,\n    '^': true,\n    '`': true,\n    '{': true,\n    '|': true,\n    '}': true,\n    '~': true\n};\nexports.strReplacementsRev = {\n    '\\n': '\\\\n',\n    '\\r': '\\\\r',\n    '\\t': '\\\\t',\n    '\\f': '\\\\f',\n    '\\v': '\\\\v'\n};\nexports.singleQuoteEscapeChars = {\n    n: '\\n',\n    r: '\\r',\n    t: '\\t',\n    f: '\\f',\n    '\\\\': '\\\\',\n    '\\'': '\\''\n};\nexports.doubleQuotesEscapeChars = {\n    n: '\\n',\n    r: '\\r',\n    t: '\\t',\n    f: '\\f',\n    '\\\\': '\\\\',\n    '\"': '\"'\n};\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","const regex = require('./regex.js')\n\nmodule.exports = BananaSlug\n\nconst own = Object.hasOwnProperty\n\nfunction BananaSlug () {\n  const self = this\n\n  if (!(self instanceof BananaSlug)) return new BananaSlug()\n\n  self.reset()\n}\n\n/**\n * Generate a unique slug.\n * @param  {string} value String of text to slugify\n * @param  {boolean} [false] Keep the current case, otherwise make all lowercase\n * @return {string}       A unique slug string\n */\nBananaSlug.prototype.slug = function (value, maintainCase) {\n  const self = this\n  let slug = slugger(value, maintainCase === true)\n  const originalSlug = slug\n\n  while (own.call(self.occurrences, slug)) {\n    self.occurrences[originalSlug]++\n    slug = originalSlug + '-' + self.occurrences[originalSlug]\n  }\n\n  self.occurrences[slug] = 0\n\n  return slug\n}\n\n/**\n * Reset - Forget all previous slugs\n * @return void\n */\nBananaSlug.prototype.reset = function () {\n  this.occurrences = Object.create(null)\n}\n\nfunction slugger (string, maintainCase) {\n  if (typeof string !== 'string') return ''\n  if (!maintainCase) string = string.toLowerCase()\n  return string.replace(regex, '').replace(/ /g, '-')\n}\n\nBananaSlug.slug = slugger\n","// This module is generated by `script/`.\n/* eslint-disable no-control-regex, no-misleading-character-class, no-useless-escape */\nmodule.exports = /[\\0-\\x1F!-,\\.\\/:-@\\[-\\^`\\{-\\xA9\\xAB-\\xB4\\xB6-\\xB9\\xBB-\\xBF\\xD7\\xF7\\u02C2-\\u02C5\\u02D2-\\u02DF\\u02E5-\\u02EB\\u02ED\\u02EF-\\u02FF\\u0375\\u0378\\u0379\\u037E\\u0380-\\u0385\\u0387\\u038B\\u038D\\u03A2\\u03F6\\u0482\\u0530\\u0557\\u0558\\u055A-\\u055F\\u0589-\\u0590\\u05BE\\u05C0\\u05C3\\u05C6\\u05C8-\\u05CF\\u05EB-\\u05EE\\u05F3-\\u060F\\u061B-\\u061F\\u066A-\\u066D\\u06D4\\u06DD\\u06DE\\u06E9\\u06FD\\u06FE\\u0700-\\u070F\\u074B\\u074C\\u07B2-\\u07BF\\u07F6-\\u07F9\\u07FB\\u07FC\\u07FE\\u07FF\\u082E-\\u083F\\u085C-\\u085F\\u086B-\\u089F\\u08B5\\u08BE-\\u08D2\\u08E2\\u0964\\u0965\\u0970\\u0984\\u098D\\u098E\\u0991\\u0992\\u09A9\\u09B1\\u09B3-\\u09B5\\u09BA\\u09BB\\u09C5\\u09C6\\u09C9\\u09CA\\u09CF-\\u09D6\\u09D8-\\u09DB\\u09DE\\u09E4\\u09E5\\u09F2-\\u09FB\\u09FD\\u09FF\\u0A00\\u0A04\\u0A0B-\\u0A0E\\u0A11\\u0A12\\u0A29\\u0A31\\u0A34\\u0A37\\u0A3A\\u0A3B\\u0A3D\\u0A43-\\u0A46\\u0A49\\u0A4A\\u0A4E-\\u0A50\\u0A52-\\u0A58\\u0A5D\\u0A5F-\\u0A65\\u0A76-\\u0A80\\u0A84\\u0A8E\\u0A92\\u0AA9\\u0AB1\\u0AB4\\u0ABA\\u0ABB\\u0AC6\\u0ACA\\u0ACE\\u0ACF\\u0AD1-\\u0ADF\\u0AE4\\u0AE5\\u0AF0-\\u0AF8\\u0B00\\u0B04\\u0B0D\\u0B0E\\u0B11\\u0B12\\u0B29\\u0B31\\u0B34\\u0B3A\\u0B3B\\u0B45\\u0B46\\u0B49\\u0B4A\\u0B4E-\\u0B55\\u0B58-\\u0B5B\\u0B5E\\u0B64\\u0B65\\u0B70\\u0B72-\\u0B81\\u0B84\\u0B8B-\\u0B8D\\u0B91\\u0B96-\\u0B98\\u0B9B\\u0B9D\\u0BA0-\\u0BA2\\u0BA5-\\u0BA7\\u0BAB-\\u0BAD\\u0BBA-\\u0BBD\\u0BC3-\\u0BC5\\u0BC9\\u0BCE\\u0BCF\\u0BD1-\\u0BD6\\u0BD8-\\u0BE5\\u0BF0-\\u0BFF\\u0C0D\\u0C11\\u0C29\\u0C3A-\\u0C3C\\u0C45\\u0C49\\u0C4E-\\u0C54\\u0C57\\u0C5B-\\u0C5F\\u0C64\\u0C65\\u0C70-\\u0C7F\\u0C84\\u0C8D\\u0C91\\u0CA9\\u0CB4\\u0CBA\\u0CBB\\u0CC5\\u0CC9\\u0CCE-\\u0CD4\\u0CD7-\\u0CDD\\u0CDF\\u0CE4\\u0CE5\\u0CF0\\u0CF3-\\u0CFF\\u0D04\\u0D0D\\u0D11\\u0D45\\u0D49\\u0D4F-\\u0D53\\u0D58-\\u0D5E\\u0D64\\u0D65\\u0D70-\\u0D79\\u0D80\\u0D81\\u0D84\\u0D97-\\u0D99\\u0DB2\\u0DBC\\u0DBE\\u0DBF\\u0DC7-\\u0DC9\\u0DCB-\\u0DCE\\u0DD5\\u0DD7\\u0DE0-\\u0DE5\\u0DF0\\u0DF1\\u0DF4-\\u0E00\\u0E3B-\\u0E3F\\u0E4F\\u0E5A-\\u0E80\\u0E83\\u0E85\\u0E8B\\u0EA4\\u0EA6\\u0EBE\\u0EBF\\u0EC5\\u0EC7\\u0ECE\\u0ECF\\u0EDA\\u0EDB\\u0EE0-\\u0EFF\\u0F01-\\u0F17\\u0F1A-\\u0F1F\\u0F2A-\\u0F34\\u0F36\\u0F38\\u0F3A-\\u0F3D\\u0F48\\u0F6D-\\u0F70\\u0F85\\u0F98\\u0FBD-\\u0FC5\\u0FC7-\\u0FFF\\u104A-\\u104F\\u109E\\u109F\\u10C6\\u10C8-\\u10CC\\u10CE\\u10CF\\u10FB\\u1249\\u124E\\u124F\\u1257\\u1259\\u125E\\u125F\\u1289\\u128E\\u128F\\u12B1\\u12B6\\u12B7\\u12BF\\u12C1\\u12C6\\u12C7\\u12D7\\u1311\\u1316\\u1317\\u135B\\u135C\\u1360-\\u137F\\u1390-\\u139F\\u13F6\\u13F7\\u13FE-\\u1400\\u166D\\u166E\\u1680\\u169B-\\u169F\\u16EB-\\u16ED\\u16F9-\\u16FF\\u170D\\u1715-\\u171F\\u1735-\\u173F\\u1754-\\u175F\\u176D\\u1771\\u1774-\\u177F\\u17D4-\\u17D6\\u17D8-\\u17DB\\u17DE\\u17DF\\u17EA-\\u180A\\u180E\\u180F\\u181A-\\u181F\\u1879-\\u187F\\u18AB-\\u18AF\\u18F6-\\u18FF\\u191F\\u192C-\\u192F\\u193C-\\u1945\\u196E\\u196F\\u1975-\\u197F\\u19AC-\\u19AF\\u19CA-\\u19CF\\u19DA-\\u19FF\\u1A1C-\\u1A1F\\u1A5F\\u1A7D\\u1A7E\\u1A8A-\\u1A8F\\u1A9A-\\u1AA6\\u1AA8-\\u1AAF\\u1ABF-\\u1AFF\\u1B4C-\\u1B4F\\u1B5A-\\u1B6A\\u1B74-\\u1B7F\\u1BF4-\\u1BFF\\u1C38-\\u1C3F\\u1C4A-\\u1C4C\\u1C7E\\u1C7F\\u1C89-\\u1C8F\\u1CBB\\u1CBC\\u1CC0-\\u1CCF\\u1CD3\\u1CFB-\\u1CFF\\u1DFA\\u1F16\\u1F17\\u1F1E\\u1F1F\\u1F46\\u1F47\\u1F4E\\u1F4F\\u1F58\\u1F5A\\u1F5C\\u1F5E\\u1F7E\\u1F7F\\u1FB5\\u1FBD\\u1FBF-\\u1FC1\\u1FC5\\u1FCD-\\u1FCF\\u1FD4\\u1FD5\\u1FDC-\\u1FDF\\u1FED-\\u1FF1\\u1FF5\\u1FFD-\\u203E\\u2041-\\u2053\\u2055-\\u2070\\u2072-\\u207E\\u2080-\\u208F\\u209D-\\u20CF\\u20F1-\\u2101\\u2103-\\u2106\\u2108\\u2109\\u2114\\u2116-\\u2118\\u211E-\\u2123\\u2125\\u2127\\u2129\\u212E\\u213A\\u213B\\u2140-\\u2144\\u214A-\\u214D\\u214F-\\u215F\\u2189-\\u24B5\\u24EA-\\u2BFF\\u2C2F\\u2C5F\\u2CE5-\\u2CEA\\u2CF4-\\u2CFF\\u2D26\\u2D28-\\u2D2C\\u2D2E\\u2D2F\\u2D68-\\u2D6E\\u2D70-\\u2D7E\\u2D97-\\u2D9F\\u2DA7\\u2DAF\\u2DB7\\u2DBF\\u2DC7\\u2DCF\\u2DD7\\u2DDF\\u2E00-\\u2E2E\\u2E30-\\u3004\\u3008-\\u3020\\u3030\\u3036\\u3037\\u303D-\\u3040\\u3097\\u3098\\u309B\\u309C\\u30A0\\u30FB\\u3100-\\u3104\\u3130\\u318F-\\u319F\\u31BB-\\u31EF\\u3200-\\u33FF\\u4DB6-\\u4DFF\\u9FF0-\\u9FFF\\uA48D-\\uA4CF\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA62C-\\uA63F\\uA673\\uA67E\\uA6F2-\\uA716\\uA720\\uA721\\uA789\\uA78A\\uA7C0\\uA7C1\\uA7C7-\\uA7F6\\uA828-\\uA83F\\uA874-\\uA87F\\uA8C6-\\uA8CF\\uA8DA-\\uA8DF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA954-\\uA95F\\uA97D-\\uA97F\\uA9C1-\\uA9CE\\uA9DA-\\uA9DF\\uA9FF\\uAA37-\\uAA3F\\uAA4E\\uAA4F\\uAA5A-\\uAA5F\\uAA77-\\uAA79\\uAAC3-\\uAADA\\uAADE\\uAADF\\uAAF0\\uAAF1\\uAAF7-\\uAB00\\uAB07\\uAB08\\uAB0F\\uAB10\\uAB17-\\uAB1F\\uAB27\\uAB2F\\uAB5B\\uAB68-\\uAB6F\\uABEB\\uABEE\\uABEF\\uABFA-\\uABFF\\uD7A4-\\uD7AF\\uD7C7-\\uD7CA\\uD7FC-\\uD7FF\\uE000-\\uF8FF\\uFA6E\\uFA6F\\uFADA-\\uFAFF\\uFB07-\\uFB12\\uFB18-\\uFB1C\\uFB29\\uFB37\\uFB3D\\uFB3F\\uFB42\\uFB45\\uFBB2-\\uFBD2\\uFD3E-\\uFD4F\\uFD90\\uFD91\\uFDC8-\\uFDEF\\uFDFC-\\uFDFF\\uFE10-\\uFE1F\\uFE30-\\uFE32\\uFE35-\\uFE4C\\uFE50-\\uFE6F\\uFE75\\uFEFD-\\uFF0F\\uFF1A-\\uFF20\\uFF3B-\\uFF3E\\uFF40\\uFF5B-\\uFF65\\uFFBF-\\uFFC1\\uFFC8\\uFFC9\\uFFD0\\uFFD1\\uFFD8\\uFFD9\\uFFDD-\\uFFFF]|\\uD800[\\uDC0C\\uDC27\\uDC3B\\uDC3E\\uDC4E\\uDC4F\\uDC5E-\\uDC7F\\uDCFB-\\uDD3F\\uDD75-\\uDDFC\\uDDFE-\\uDE7F\\uDE9D-\\uDE9F\\uDED1-\\uDEDF\\uDEE1-\\uDEFF\\uDF20-\\uDF2C\\uDF4B-\\uDF4F\\uDF7B-\\uDF7F\\uDF9E\\uDF9F\\uDFC4-\\uDFC7\\uDFD0\\uDFD6-\\uDFFF]|\\uD801[\\uDC9E\\uDC9F\\uDCAA-\\uDCAF\\uDCD4-\\uDCD7\\uDCFC-\\uDCFF\\uDD28-\\uDD2F\\uDD64-\\uDDFF\\uDF37-\\uDF3F\\uDF56-\\uDF5F\\uDF68-\\uDFFF]|\\uD802[\\uDC06\\uDC07\\uDC09\\uDC36\\uDC39-\\uDC3B\\uDC3D\\uDC3E\\uDC56-\\uDC5F\\uDC77-\\uDC7F\\uDC9F-\\uDCDF\\uDCF3\\uDCF6-\\uDCFF\\uDD16-\\uDD1F\\uDD3A-\\uDD7F\\uDDB8-\\uDDBD\\uDDC0-\\uDDFF\\uDE04\\uDE07-\\uDE0B\\uDE14\\uDE18\\uDE36\\uDE37\\uDE3B-\\uDE3E\\uDE40-\\uDE5F\\uDE7D-\\uDE7F\\uDE9D-\\uDEBF\\uDEC8\\uDEE7-\\uDEFF\\uDF36-\\uDF3F\\uDF56-\\uDF5F\\uDF73-\\uDF7F\\uDF92-\\uDFFF]|\\uD803[\\uDC49-\\uDC7F\\uDCB3-\\uDCBF\\uDCF3-\\uDCFF\\uDD28-\\uDD2F\\uDD3A-\\uDEFF\\uDF1D-\\uDF26\\uDF28-\\uDF2F\\uDF51-\\uDFDF\\uDFF7-\\uDFFF]|\\uD804[\\uDC47-\\uDC65\\uDC70-\\uDC7E\\uDCBB-\\uDCCF\\uDCE9-\\uDCEF\\uDCFA-\\uDCFF\\uDD35\\uDD40-\\uDD43\\uDD47-\\uDD4F\\uDD74\\uDD75\\uDD77-\\uDD7F\\uDDC5-\\uDDC8\\uDDCD-\\uDDCF\\uDDDB\\uDDDD-\\uDDFF\\uDE12\\uDE38-\\uDE3D\\uDE3F-\\uDE7F\\uDE87\\uDE89\\uDE8E\\uDE9E\\uDEA9-\\uDEAF\\uDEEB-\\uDEEF\\uDEFA-\\uDEFF\\uDF04\\uDF0D\\uDF0E\\uDF11\\uDF12\\uDF29\\uDF31\\uDF34\\uDF3A\\uDF45\\uDF46\\uDF49\\uDF4A\\uDF4E\\uDF4F\\uDF51-\\uDF56\\uDF58-\\uDF5C\\uDF64\\uDF65\\uDF6D-\\uDF6F\\uDF75-\\uDFFF]|\\uD805[\\uDC4B-\\uDC4F\\uDC5A-\\uDC5D\\uDC60-\\uDC7F\\uDCC6\\uDCC8-\\uDCCF\\uDCDA-\\uDD7F\\uDDB6\\uDDB7\\uDDC1-\\uDDD7\\uDDDE-\\uDDFF\\uDE41-\\uDE43\\uDE45-\\uDE4F\\uDE5A-\\uDE7F\\uDEB9-\\uDEBF\\uDECA-\\uDEFF\\uDF1B\\uDF1C\\uDF2C-\\uDF2F\\uDF3A-\\uDFFF]|\\uD806[\\uDC3B-\\uDC9F\\uDCEA-\\uDCFE\\uDD00-\\uDD9F\\uDDA8\\uDDA9\\uDDD8\\uDDD9\\uDDE2\\uDDE5-\\uDDFF\\uDE3F-\\uDE46\\uDE48-\\uDE4F\\uDE9A-\\uDE9C\\uDE9E-\\uDEBF\\uDEF9-\\uDFFF]|\\uD807[\\uDC09\\uDC37\\uDC41-\\uDC4F\\uDC5A-\\uDC71\\uDC90\\uDC91\\uDCA8\\uDCB7-\\uDCFF\\uDD07\\uDD0A\\uDD37-\\uDD39\\uDD3B\\uDD3E\\uDD48-\\uDD4F\\uDD5A-\\uDD5F\\uDD66\\uDD69\\uDD8F\\uDD92\\uDD99-\\uDD9F\\uDDAA-\\uDEDF\\uDEF7-\\uDFFF]|\\uD808[\\uDF9A-\\uDFFF]|\\uD809[\\uDC6F-\\uDC7F\\uDD44-\\uDFFF]|[\\uD80A\\uD80B\\uD80E-\\uD810\\uD812-\\uD819\\uD823-\\uD82B\\uD82D\\uD82E\\uD830-\\uD833\\uD837\\uD839\\uD83D-\\uD83F\\uD87B-\\uD87D\\uD87F-\\uDB3F\\uDB41-\\uDBFF][\\uDC00-\\uDFFF]|\\uD80D[\\uDC2F-\\uDFFF]|\\uD811[\\uDE47-\\uDFFF]|\\uD81A[\\uDE39-\\uDE3F\\uDE5F\\uDE6A-\\uDECF\\uDEEE\\uDEEF\\uDEF5-\\uDEFF\\uDF37-\\uDF3F\\uDF44-\\uDF4F\\uDF5A-\\uDF62\\uDF78-\\uDF7C\\uDF90-\\uDFFF]|\\uD81B[\\uDC00-\\uDE3F\\uDE80-\\uDEFF\\uDF4B-\\uDF4E\\uDF88-\\uDF8E\\uDFA0-\\uDFDF\\uDFE2\\uDFE4-\\uDFFF]|\\uD821[\\uDFF8-\\uDFFF]|\\uD822[\\uDEF3-\\uDFFF]|\\uD82C[\\uDD1F-\\uDD4F\\uDD53-\\uDD63\\uDD68-\\uDD6F\\uDEFC-\\uDFFF]|\\uD82F[\\uDC6B-\\uDC6F\\uDC7D-\\uDC7F\\uDC89-\\uDC8F\\uDC9A-\\uDC9C\\uDC9F-\\uDFFF]|\\uD834[\\uDC00-\\uDD64\\uDD6A-\\uDD6C\\uDD73-\\uDD7A\\uDD83\\uDD84\\uDD8C-\\uDDA9\\uDDAE-\\uDE41\\uDE45-\\uDFFF]|\\uD835[\\uDC55\\uDC9D\\uDCA0\\uDCA1\\uDCA3\\uDCA4\\uDCA7\\uDCA8\\uDCAD\\uDCBA\\uDCBC\\uDCC4\\uDD06\\uDD0B\\uDD0C\\uDD15\\uDD1D\\uDD3A\\uDD3F\\uDD45\\uDD47-\\uDD49\\uDD51\\uDEA6\\uDEA7\\uDEC1\\uDEDB\\uDEFB\\uDF15\\uDF35\\uDF4F\\uDF6F\\uDF89\\uDFA9\\uDFC3\\uDFCC\\uDFCD]|\\uD836[\\uDC00-\\uDDFF\\uDE37-\\uDE3A\\uDE6D-\\uDE74\\uDE76-\\uDE83\\uDE85-\\uDE9A\\uDEA0\\uDEB0-\\uDFFF]|\\uD838[\\uDC07\\uDC19\\uDC1A\\uDC22\\uDC25\\uDC2B-\\uDCFF\\uDD2D-\\uDD2F\\uDD3E\\uDD3F\\uDD4A-\\uDD4D\\uDD4F-\\uDEBF\\uDEFA-\\uDFFF]|\\uD83A[\\uDCC5-\\uDCCF\\uDCD7-\\uDCFF\\uDD4C-\\uDD4F\\uDD5A-\\uDFFF]|\\uD83B[\\uDC00-\\uDDFF\\uDE04\\uDE20\\uDE23\\uDE25\\uDE26\\uDE28\\uDE33\\uDE38\\uDE3A\\uDE3C-\\uDE41\\uDE43-\\uDE46\\uDE48\\uDE4A\\uDE4C\\uDE50\\uDE53\\uDE55\\uDE56\\uDE58\\uDE5A\\uDE5C\\uDE5E\\uDE60\\uDE63\\uDE65\\uDE66\\uDE6B\\uDE73\\uDE78\\uDE7D\\uDE7F\\uDE8A\\uDE9C-\\uDEA0\\uDEA4\\uDEAA\\uDEBC-\\uDFFF]|\\uD83C[\\uDC00-\\uDD2F\\uDD4A-\\uDD4F\\uDD6A-\\uDD6F\\uDD8A-\\uDFFF]|\\uD869[\\uDED7-\\uDEFF]|\\uD86D[\\uDF35-\\uDF3F]|\\uD86E[\\uDC1E\\uDC1F]|\\uD873[\\uDEA2-\\uDEAF]|\\uD87A[\\uDFE1-\\uDFFF]|\\uD87E[\\uDE1E-\\uDFFF]|\\uDB40[\\uDC00-\\uDCFF\\uDDF0-\\uDFFF]/g\n","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\n\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/;\n\n// declaration\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/;\n\n// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\nvar TRIM_REGEX = /^\\s+|\\s+$/g;\n\n// strings\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = '';\n\n// types\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\nmodule.exports = function(style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n\n  options = options || {};\n\n  /**\n   * Positional.\n   */\n  var lineno = 1;\n  var column = 1;\n\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n  function position() {\n    var start = { line: lineno, column: column };\n    return function(node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n  function Position(start) {\n    this.start = start;\n    this.end = { line: lineno, column: column };\n    this.source = options.source;\n  }\n\n  /**\n   * Non-enumerable source string.\n   */\n  Position.prototype.content = style;\n\n  var errorsList = [];\n\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n  function error(msg) {\n    var err = new Error(\n      options.source + ':' + lineno + ':' + column + ': ' + msg\n    );\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n\n  /**\n   * Parse whitespace.\n   */\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n    while ((c = comment())) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n    return rules;\n  }\n\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n\n    var i = 2;\n    while (\n      EMPTY_STRING != style.charAt(i) &&\n      (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))\n    ) {\n      ++i;\n    }\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function declaration() {\n    var pos = position();\n\n    // prop\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment();\n\n    // :\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\");\n\n    // val\n    var val = match(VALUE_REGEX);\n\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val\n        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))\n        : EMPTY_STRING\n    });\n\n    // ;\n    match(SEMICOLON_REGEX);\n\n    return ret;\n  }\n\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n  function declarations() {\n    var decls = [];\n\n    comments(decls);\n\n    // declarations\n    var decl;\n    while ((decl = declaration())) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n  return obj != null && obj.constructor != null &&\n    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n","/**\n * @param {string} string    The string to parse\n * @returns {Array<number>}  Returns an energetic array.\n */\nfunction parsePart(string) {\n  let res = [];\n  let m;\n\n  for (let str of string.split(\",\").map((str) => str.trim())) {\n    // just a number\n    if (/^-?\\d+$/.test(str)) {\n      res.push(parseInt(str, 10));\n    } else if (\n      (m = str.match(/^(-?\\d+)(-|\\.\\.\\.?|\\u2025|\\u2026|\\u22EF)(-?\\d+)$/))\n    ) {\n      // 1-5 or 1..5 (equivalent) or 1...5 (doesn't include 5)\n      let [_, lhs, sep, rhs] = m;\n\n      if (lhs && rhs) {\n        lhs = parseInt(lhs);\n        rhs = parseInt(rhs);\n        const incr = lhs < rhs ? 1 : -1;\n\n        // Make it inclusive by moving the right 'stop-point' away by one.\n        if (sep === \"-\" || sep === \"..\" || sep === \"\\u2025\") rhs += incr;\n\n        for (let i = lhs; i !== rhs; i += incr) res.push(i);\n      }\n    }\n  }\n\n  return res;\n}\n\nexports.default = parsePart;\nmodule.exports = parsePart;\n","'use strict';\n\nconst { DOCUMENT_MODE } = require('./html');\n\n//Const\nconst VALID_DOCTYPE_NAME = 'html';\nconst VALID_SYSTEM_ID = 'about:legacy-compat';\nconst QUIRKS_MODE_SYSTEM_ID = 'http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd';\n\nconst QUIRKS_MODE_PUBLIC_ID_PREFIXES = [\n    '+//silmaril//dtd html pro v0r11 19970101//',\n    '-//as//dtd html 3.0 aswedit + extensions//',\n    '-//advasoft ltd//dtd html 3.0 aswedit + extensions//',\n    '-//ietf//dtd html 2.0 level 1//',\n    '-//ietf//dtd html 2.0 level 2//',\n    '-//ietf//dtd html 2.0 strict level 1//',\n    '-//ietf//dtd html 2.0 strict level 2//',\n    '-//ietf//dtd html 2.0 strict//',\n    '-//ietf//dtd html 2.0//',\n    '-//ietf//dtd html 2.1e//',\n    '-//ietf//dtd html 3.0//',\n    '-//ietf//dtd html 3.2 final//',\n    '-//ietf//dtd html 3.2//',\n    '-//ietf//dtd html 3//',\n    '-//ietf//dtd html level 0//',\n    '-//ietf//dtd html level 1//',\n    '-//ietf//dtd html level 2//',\n    '-//ietf//dtd html level 3//',\n    '-//ietf//dtd html strict level 0//',\n    '-//ietf//dtd html strict level 1//',\n    '-//ietf//dtd html strict level 2//',\n    '-//ietf//dtd html strict level 3//',\n    '-//ietf//dtd html strict//',\n    '-//ietf//dtd html//',\n    '-//metrius//dtd metrius presentational//',\n    '-//microsoft//dtd internet explorer 2.0 html strict//',\n    '-//microsoft//dtd internet explorer 2.0 html//',\n    '-//microsoft//dtd internet explorer 2.0 tables//',\n    '-//microsoft//dtd internet explorer 3.0 html strict//',\n    '-//microsoft//dtd internet explorer 3.0 html//',\n    '-//microsoft//dtd internet explorer 3.0 tables//',\n    '-//netscape comm. corp.//dtd html//',\n    '-//netscape comm. corp.//dtd strict html//',\n    \"-//o'reilly and associates//dtd html 2.0//\",\n    \"-//o'reilly and associates//dtd html extended 1.0//\",\n    \"-//o'reilly and associates//dtd html extended relaxed 1.0//\",\n    '-//sq//dtd html 2.0 hotmetal + extensions//',\n    '-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//',\n    '-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//',\n    '-//spyglass//dtd html 2.0 extended//',\n    '-//sun microsystems corp.//dtd hotjava html//',\n    '-//sun microsystems corp.//dtd hotjava strict html//',\n    '-//w3c//dtd html 3 1995-03-24//',\n    '-//w3c//dtd html 3.2 draft//',\n    '-//w3c//dtd html 3.2 final//',\n    '-//w3c//dtd html 3.2//',\n    '-//w3c//dtd html 3.2s draft//',\n    '-//w3c//dtd html 4.0 frameset//',\n    '-//w3c//dtd html 4.0 transitional//',\n    '-//w3c//dtd html experimental 19960712//',\n    '-//w3c//dtd html experimental 970421//',\n    '-//w3c//dtd w3 html//',\n    '-//w3o//dtd w3 html 3.0//',\n    '-//webtechs//dtd mozilla html 2.0//',\n    '-//webtechs//dtd mozilla html//'\n];\n\nconst QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = QUIRKS_MODE_PUBLIC_ID_PREFIXES.concat([\n    '-//w3c//dtd html 4.01 frameset//',\n    '-//w3c//dtd html 4.01 transitional//'\n]);\n\nconst QUIRKS_MODE_PUBLIC_IDS = ['-//w3o//dtd w3 html strict 3.0//en//', '-/w3c/dtd html 4.0 transitional/en', 'html'];\nconst LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ['-//w3c//dtd xhtml 1.0 frameset//', '-//w3c//dtd xhtml 1.0 transitional//'];\n\nconst LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = LIMITED_QUIRKS_PUBLIC_ID_PREFIXES.concat([\n    '-//w3c//dtd html 4.01 frameset//',\n    '-//w3c//dtd html 4.01 transitional//'\n]);\n\n//Utils\nfunction enquoteDoctypeId(id) {\n    const quote = id.indexOf('\"') !== -1 ? \"'\" : '\"';\n\n    return quote + id + quote;\n}\n\nfunction hasPrefix(publicId, prefixes) {\n    for (let i = 0; i < prefixes.length; i++) {\n        if (publicId.indexOf(prefixes[i]) === 0) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\n//API\nexports.isConforming = function(token) {\n    return (\n        token.name === VALID_DOCTYPE_NAME &&\n        token.publicId === null &&\n        (token.systemId === null || token.systemId === VALID_SYSTEM_ID)\n    );\n};\n\nexports.getDocumentMode = function(token) {\n    if (token.name !== VALID_DOCTYPE_NAME) {\n        return DOCUMENT_MODE.QUIRKS;\n    }\n\n    const systemId = token.systemId;\n\n    if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) {\n        return DOCUMENT_MODE.QUIRKS;\n    }\n\n    let publicId = token.publicId;\n\n    if (publicId !== null) {\n        publicId = publicId.toLowerCase();\n\n        if (QUIRKS_MODE_PUBLIC_IDS.indexOf(publicId) > -1) {\n            return DOCUMENT_MODE.QUIRKS;\n        }\n\n        let prefixes = systemId === null ? QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES : QUIRKS_MODE_PUBLIC_ID_PREFIXES;\n\n        if (hasPrefix(publicId, prefixes)) {\n            return DOCUMENT_MODE.QUIRKS;\n        }\n\n        prefixes =\n            systemId === null ? LIMITED_QUIRKS_PUBLIC_ID_PREFIXES : LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES;\n\n        if (hasPrefix(publicId, prefixes)) {\n            return DOCUMENT_MODE.LIMITED_QUIRKS;\n        }\n    }\n\n    return DOCUMENT_MODE.NO_QUIRKS;\n};\n\nexports.serializeContent = function(name, publicId, systemId) {\n    let str = '!DOCTYPE ';\n\n    if (name) {\n        str += name;\n    }\n\n    if (publicId) {\n        str += ' PUBLIC ' + enquoteDoctypeId(publicId);\n    } else if (systemId) {\n        str += ' SYSTEM';\n    }\n\n    if (systemId !== null) {\n        str += ' ' + enquoteDoctypeId(systemId);\n    }\n\n    return str;\n};\n","'use strict';\n\nmodule.exports = {\n    controlCharacterInInputStream: 'control-character-in-input-stream',\n    noncharacterInInputStream: 'noncharacter-in-input-stream',\n    surrogateInInputStream: 'surrogate-in-input-stream',\n    nonVoidHtmlElementStartTagWithTrailingSolidus: 'non-void-html-element-start-tag-with-trailing-solidus',\n    endTagWithAttributes: 'end-tag-with-attributes',\n    endTagWithTrailingSolidus: 'end-tag-with-trailing-solidus',\n    unexpectedSolidusInTag: 'unexpected-solidus-in-tag',\n    unexpectedNullCharacter: 'unexpected-null-character',\n    unexpectedQuestionMarkInsteadOfTagName: 'unexpected-question-mark-instead-of-tag-name',\n    invalidFirstCharacterOfTagName: 'invalid-first-character-of-tag-name',\n    unexpectedEqualsSignBeforeAttributeName: 'unexpected-equals-sign-before-attribute-name',\n    missingEndTagName: 'missing-end-tag-name',\n    unexpectedCharacterInAttributeName: 'unexpected-character-in-attribute-name',\n    unknownNamedCharacterReference: 'unknown-named-character-reference',\n    missingSemicolonAfterCharacterReference: 'missing-semicolon-after-character-reference',\n    unexpectedCharacterAfterDoctypeSystemIdentifier: 'unexpected-character-after-doctype-system-identifier',\n    unexpectedCharacterInUnquotedAttributeValue: 'unexpected-character-in-unquoted-attribute-value',\n    eofBeforeTagName: 'eof-before-tag-name',\n    eofInTag: 'eof-in-tag',\n    missingAttributeValue: 'missing-attribute-value',\n    missingWhitespaceBetweenAttributes: 'missing-whitespace-between-attributes',\n    missingWhitespaceAfterDoctypePublicKeyword: 'missing-whitespace-after-doctype-public-keyword',\n    missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers:\n        'missing-whitespace-between-doctype-public-and-system-identifiers',\n    missingWhitespaceAfterDoctypeSystemKeyword: 'missing-whitespace-after-doctype-system-keyword',\n    missingQuoteBeforeDoctypePublicIdentifier: 'missing-quote-before-doctype-public-identifier',\n    missingQuoteBeforeDoctypeSystemIdentifier: 'missing-quote-before-doctype-system-identifier',\n    missingDoctypePublicIdentifier: 'missing-doctype-public-identifier',\n    missingDoctypeSystemIdentifier: 'missing-doctype-system-identifier',\n    abruptDoctypePublicIdentifier: 'abrupt-doctype-public-identifier',\n    abruptDoctypeSystemIdentifier: 'abrupt-doctype-system-identifier',\n    cdataInHtmlContent: 'cdata-in-html-content',\n    incorrectlyOpenedComment: 'incorrectly-opened-comment',\n    eofInScriptHtmlCommentLikeText: 'eof-in-script-html-comment-like-text',\n    eofInDoctype: 'eof-in-doctype',\n    nestedComment: 'nested-comment',\n    abruptClosingOfEmptyComment: 'abrupt-closing-of-empty-comment',\n    eofInComment: 'eof-in-comment',\n    incorrectlyClosedComment: 'incorrectly-closed-comment',\n    eofInCdata: 'eof-in-cdata',\n    absenceOfDigitsInNumericCharacterReference: 'absence-of-digits-in-numeric-character-reference',\n    nullCharacterReference: 'null-character-reference',\n    surrogateCharacterReference: 'surrogate-character-reference',\n    characterReferenceOutsideUnicodeRange: 'character-reference-outside-unicode-range',\n    controlCharacterReference: 'control-character-reference',\n    noncharacterCharacterReference: 'noncharacter-character-reference',\n    missingWhitespaceBeforeDoctypeName: 'missing-whitespace-before-doctype-name',\n    missingDoctypeName: 'missing-doctype-name',\n    invalidCharacterSequenceAfterDoctypeName: 'invalid-character-sequence-after-doctype-name',\n    duplicateAttribute: 'duplicate-attribute',\n    nonConformingDoctype: 'non-conforming-doctype',\n    missingDoctype: 'missing-doctype',\n    misplacedDoctype: 'misplaced-doctype',\n    endTagWithoutMatchingOpenElement: 'end-tag-without-matching-open-element',\n    closingOfElementWithOpenChildElements: 'closing-of-element-with-open-child-elements',\n    disallowedContentInNoscriptInHead: 'disallowed-content-in-noscript-in-head',\n    openElementsLeftAfterEof: 'open-elements-left-after-eof',\n    abandonedHeadElementChild: 'abandoned-head-element-child',\n    misplacedStartTagForHeadElement: 'misplaced-start-tag-for-head-element',\n    nestedNoscriptInHead: 'nested-noscript-in-head',\n    eofInElementThatCanContainOnlyText: 'eof-in-element-that-can-contain-only-text'\n};\n","'use strict';\n\nconst Tokenizer = require('../tokenizer');\nconst HTML = require('./html');\n\n//Aliases\nconst $ = HTML.TAG_NAMES;\nconst NS = HTML.NAMESPACES;\nconst ATTRS = HTML.ATTRS;\n\n//MIME types\nconst MIME_TYPES = {\n    TEXT_HTML: 'text/html',\n    APPLICATION_XML: 'application/xhtml+xml'\n};\n\n//Attributes\nconst DEFINITION_URL_ATTR = 'definitionurl';\nconst ADJUSTED_DEFINITION_URL_ATTR = 'definitionURL';\nconst SVG_ATTRS_ADJUSTMENT_MAP = {\n    attributename: 'attributeName',\n    attributetype: 'attributeType',\n    basefrequency: 'baseFrequency',\n    baseprofile: 'baseProfile',\n    calcmode: 'calcMode',\n    clippathunits: 'clipPathUnits',\n    diffuseconstant: 'diffuseConstant',\n    edgemode: 'edgeMode',\n    filterunits: 'filterUnits',\n    glyphref: 'glyphRef',\n    gradienttransform: 'gradientTransform',\n    gradientunits: 'gradientUnits',\n    kernelmatrix: 'kernelMatrix',\n    kernelunitlength: 'kernelUnitLength',\n    keypoints: 'keyPoints',\n    keysplines: 'keySplines',\n    keytimes: 'keyTimes',\n    lengthadjust: 'lengthAdjust',\n    limitingconeangle: 'limitingConeAngle',\n    markerheight: 'markerHeight',\n    markerunits: 'markerUnits',\n    markerwidth: 'markerWidth',\n    maskcontentunits: 'maskContentUnits',\n    maskunits: 'maskUnits',\n    numoctaves: 'numOctaves',\n    pathlength: 'pathLength',\n    patterncontentunits: 'patternContentUnits',\n    patterntransform: 'patternTransform',\n    patternunits: 'patternUnits',\n    pointsatx: 'pointsAtX',\n    pointsaty: 'pointsAtY',\n    pointsatz: 'pointsAtZ',\n    preservealpha: 'preserveAlpha',\n    preserveaspectratio: 'preserveAspectRatio',\n    primitiveunits: 'primitiveUnits',\n    refx: 'refX',\n    refy: 'refY',\n    repeatcount: 'repeatCount',\n    repeatdur: 'repeatDur',\n    requiredextensions: 'requiredExtensions',\n    requiredfeatures: 'requiredFeatures',\n    specularconstant: 'specularConstant',\n    specularexponent: 'specularExponent',\n    spreadmethod: 'spreadMethod',\n    startoffset: 'startOffset',\n    stddeviation: 'stdDeviation',\n    stitchtiles: 'stitchTiles',\n    surfacescale: 'surfaceScale',\n    systemlanguage: 'systemLanguage',\n    tablevalues: 'tableValues',\n    targetx: 'targetX',\n    targety: 'targetY',\n    textlength: 'textLength',\n    viewbox: 'viewBox',\n    viewtarget: 'viewTarget',\n    xchannelselector: 'xChannelSelector',\n    ychannelselector: 'yChannelSelector',\n    zoomandpan: 'zoomAndPan'\n};\n\nconst XML_ATTRS_ADJUSTMENT_MAP = {\n    'xlink:actuate': { prefix: 'xlink', name: 'actuate', namespace: NS.XLINK },\n    'xlink:arcrole': { prefix: 'xlink', name: 'arcrole', namespace: NS.XLINK },\n    'xlink:href': { prefix: 'xlink', name: 'href', namespace: NS.XLINK },\n    'xlink:role': { prefix: 'xlink', name: 'role', namespace: NS.XLINK },\n    'xlink:show': { prefix: 'xlink', name: 'show', namespace: NS.XLINK },\n    'xlink:title': { prefix: 'xlink', name: 'title', namespace: NS.XLINK },\n    'xlink:type': { prefix: 'xlink', name: 'type', namespace: NS.XLINK },\n    'xml:base': { prefix: 'xml', name: 'base', namespace: NS.XML },\n    'xml:lang': { prefix: 'xml', name: 'lang', namespace: NS.XML },\n    'xml:space': { prefix: 'xml', name: 'space', namespace: NS.XML },\n    xmlns: { prefix: '', name: 'xmlns', namespace: NS.XMLNS },\n    'xmlns:xlink': { prefix: 'xmlns', name: 'xlink', namespace: NS.XMLNS }\n};\n\n//SVG tag names adjustment map\nconst SVG_TAG_NAMES_ADJUSTMENT_MAP = (exports.SVG_TAG_NAMES_ADJUSTMENT_MAP = {\n    altglyph: 'altGlyph',\n    altglyphdef: 'altGlyphDef',\n    altglyphitem: 'altGlyphItem',\n    animatecolor: 'animateColor',\n    animatemotion: 'animateMotion',\n    animatetransform: 'animateTransform',\n    clippath: 'clipPath',\n    feblend: 'feBlend',\n    fecolormatrix: 'feColorMatrix',\n    fecomponenttransfer: 'feComponentTransfer',\n    fecomposite: 'feComposite',\n    feconvolvematrix: 'feConvolveMatrix',\n    fediffuselighting: 'feDiffuseLighting',\n    fedisplacementmap: 'feDisplacementMap',\n    fedistantlight: 'feDistantLight',\n    feflood: 'feFlood',\n    fefunca: 'feFuncA',\n    fefuncb: 'feFuncB',\n    fefuncg: 'feFuncG',\n    fefuncr: 'feFuncR',\n    fegaussianblur: 'feGaussianBlur',\n    feimage: 'feImage',\n    femerge: 'feMerge',\n    femergenode: 'feMergeNode',\n    femorphology: 'feMorphology',\n    feoffset: 'feOffset',\n    fepointlight: 'fePointLight',\n    fespecularlighting: 'feSpecularLighting',\n    fespotlight: 'feSpotLight',\n    fetile: 'feTile',\n    feturbulence: 'feTurbulence',\n    foreignobject: 'foreignObject',\n    glyphref: 'glyphRef',\n    lineargradient: 'linearGradient',\n    radialgradient: 'radialGradient',\n    textpath: 'textPath'\n});\n\n//Tags that causes exit from foreign content\nconst EXITS_FOREIGN_CONTENT = {\n    [$.B]: true,\n    [$.BIG]: true,\n    [$.BLOCKQUOTE]: true,\n    [$.BODY]: true,\n    [$.BR]: true,\n    [$.CENTER]: true,\n    [$.CODE]: true,\n    [$.DD]: true,\n    [$.DIV]: true,\n    [$.DL]: true,\n    [$.DT]: true,\n    [$.EM]: true,\n    [$.EMBED]: true,\n    [$.H1]: true,\n    [$.H2]: true,\n    [$.H3]: true,\n    [$.H4]: true,\n    [$.H5]: true,\n    [$.H6]: true,\n    [$.HEAD]: true,\n    [$.HR]: true,\n    [$.I]: true,\n    [$.IMG]: true,\n    [$.LI]: true,\n    [$.LISTING]: true,\n    [$.MENU]: true,\n    [$.META]: true,\n    [$.NOBR]: true,\n    [$.OL]: true,\n    [$.P]: true,\n    [$.PRE]: true,\n    [$.RUBY]: true,\n    [$.S]: true,\n    [$.SMALL]: true,\n    [$.SPAN]: true,\n    [$.STRONG]: true,\n    [$.STRIKE]: true,\n    [$.SUB]: true,\n    [$.SUP]: true,\n    [$.TABLE]: true,\n    [$.TT]: true,\n    [$.U]: true,\n    [$.UL]: true,\n    [$.VAR]: true\n};\n\n//Check exit from foreign content\nexports.causesExit = function(startTagToken) {\n    const tn = startTagToken.tagName;\n    const isFontWithAttrs =\n        tn === $.FONT &&\n        (Tokenizer.getTokenAttr(startTagToken, ATTRS.COLOR) !== null ||\n            Tokenizer.getTokenAttr(startTagToken, ATTRS.SIZE) !== null ||\n            Tokenizer.getTokenAttr(startTagToken, ATTRS.FACE) !== null);\n\n    return isFontWithAttrs ? true : EXITS_FOREIGN_CONTENT[tn];\n};\n\n//Token adjustments\nexports.adjustTokenMathMLAttrs = function(token) {\n    for (let i = 0; i < token.attrs.length; i++) {\n        if (token.attrs[i].name === DEFINITION_URL_ATTR) {\n            token.attrs[i].name = ADJUSTED_DEFINITION_URL_ATTR;\n            break;\n        }\n    }\n};\n\nexports.adjustTokenSVGAttrs = function(token) {\n    for (let i = 0; i < token.attrs.length; i++) {\n        const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP[token.attrs[i].name];\n\n        if (adjustedAttrName) {\n            token.attrs[i].name = adjustedAttrName;\n        }\n    }\n};\n\nexports.adjustTokenXMLAttrs = function(token) {\n    for (let i = 0; i < token.attrs.length; i++) {\n        const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP[token.attrs[i].name];\n\n        if (adjustedAttrEntry) {\n            token.attrs[i].prefix = adjustedAttrEntry.prefix;\n            token.attrs[i].name = adjustedAttrEntry.name;\n            token.attrs[i].namespace = adjustedAttrEntry.namespace;\n        }\n    }\n};\n\nexports.adjustTokenSVGTagName = function(token) {\n    const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP[token.tagName];\n\n    if (adjustedTagName) {\n        token.tagName = adjustedTagName;\n    }\n};\n\n//Integration points\nfunction isMathMLTextIntegrationPoint(tn, ns) {\n    return ns === NS.MATHML && (tn === $.MI || tn === $.MO || tn === $.MN || tn === $.MS || tn === $.MTEXT);\n}\n\nfunction isHtmlIntegrationPoint(tn, ns, attrs) {\n    if (ns === NS.MATHML && tn === $.ANNOTATION_XML) {\n        for (let i = 0; i < attrs.length; i++) {\n            if (attrs[i].name === ATTRS.ENCODING) {\n                const value = attrs[i].value.toLowerCase();\n\n                return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML;\n            }\n        }\n    }\n\n    return ns === NS.SVG && (tn === $.FOREIGN_OBJECT || tn === $.DESC || tn === $.TITLE);\n}\n\nexports.isIntegrationPoint = function(tn, ns, attrs, foreignNS) {\n    if ((!foreignNS || foreignNS === NS.HTML) && isHtmlIntegrationPoint(tn, ns, attrs)) {\n        return true;\n    }\n\n    if ((!foreignNS || foreignNS === NS.MATHML) && isMathMLTextIntegrationPoint(tn, ns)) {\n        return true;\n    }\n\n    return false;\n};\n","'use strict';\n\nconst NS = (exports.NAMESPACES = {\n    HTML: 'http://www.w3.org/1999/xhtml',\n    MATHML: 'http://www.w3.org/1998/Math/MathML',\n    SVG: 'http://www.w3.org/2000/svg',\n    XLINK: 'http://www.w3.org/1999/xlink',\n    XML: 'http://www.w3.org/XML/1998/namespace',\n    XMLNS: 'http://www.w3.org/2000/xmlns/'\n});\n\nexports.ATTRS = {\n    TYPE: 'type',\n    ACTION: 'action',\n    ENCODING: 'encoding',\n    PROMPT: 'prompt',\n    NAME: 'name',\n    COLOR: 'color',\n    FACE: 'face',\n    SIZE: 'size'\n};\n\nexports.DOCUMENT_MODE = {\n    NO_QUIRKS: 'no-quirks',\n    QUIRKS: 'quirks',\n    LIMITED_QUIRKS: 'limited-quirks'\n};\n\nconst $ = (exports.TAG_NAMES = {\n    A: 'a',\n    ADDRESS: 'address',\n    ANNOTATION_XML: 'annotation-xml',\n    APPLET: 'applet',\n    AREA: 'area',\n    ARTICLE: 'article',\n    ASIDE: 'aside',\n\n    B: 'b',\n    BASE: 'base',\n    BASEFONT: 'basefont',\n    BGSOUND: 'bgsound',\n    BIG: 'big',\n    BLOCKQUOTE: 'blockquote',\n    BODY: 'body',\n    BR: 'br',\n    BUTTON: 'button',\n\n    CAPTION: 'caption',\n    CENTER: 'center',\n    CODE: 'code',\n    COL: 'col',\n    COLGROUP: 'colgroup',\n\n    DD: 'dd',\n    DESC: 'desc',\n    DETAILS: 'details',\n    DIALOG: 'dialog',\n    DIR: 'dir',\n    DIV: 'div',\n    DL: 'dl',\n    DT: 'dt',\n\n    EM: 'em',\n    EMBED: 'embed',\n\n    FIELDSET: 'fieldset',\n    FIGCAPTION: 'figcaption',\n    FIGURE: 'figure',\n    FONT: 'font',\n    FOOTER: 'footer',\n    FOREIGN_OBJECT: 'foreignObject',\n    FORM: 'form',\n    FRAME: 'frame',\n    FRAMESET: 'frameset',\n\n    H1: 'h1',\n    H2: 'h2',\n    H3: 'h3',\n    H4: 'h4',\n    H5: 'h5',\n    H6: 'h6',\n    HEAD: 'head',\n    HEADER: 'header',\n    HGROUP: 'hgroup',\n    HR: 'hr',\n    HTML: 'html',\n\n    I: 'i',\n    IMG: 'img',\n    IMAGE: 'image',\n    INPUT: 'input',\n    IFRAME: 'iframe',\n\n    KEYGEN: 'keygen',\n\n    LABEL: 'label',\n    LI: 'li',\n    LINK: 'link',\n    LISTING: 'listing',\n\n    MAIN: 'main',\n    MALIGNMARK: 'malignmark',\n    MARQUEE: 'marquee',\n    MATH: 'math',\n    MENU: 'menu',\n    META: 'meta',\n    MGLYPH: 'mglyph',\n    MI: 'mi',\n    MO: 'mo',\n    MN: 'mn',\n    MS: 'ms',\n    MTEXT: 'mtext',\n\n    NAV: 'nav',\n    NOBR: 'nobr',\n    NOFRAMES: 'noframes',\n    NOEMBED: 'noembed',\n    NOSCRIPT: 'noscript',\n\n    OBJECT: 'object',\n    OL: 'ol',\n    OPTGROUP: 'optgroup',\n    OPTION: 'option',\n\n    P: 'p',\n    PARAM: 'param',\n    PLAINTEXT: 'plaintext',\n    PRE: 'pre',\n\n    RB: 'rb',\n    RP: 'rp',\n    RT: 'rt',\n    RTC: 'rtc',\n    RUBY: 'ruby',\n\n    S: 's',\n    SCRIPT: 'script',\n    SECTION: 'section',\n    SELECT: 'select',\n    SOURCE: 'source',\n    SMALL: 'small',\n    SPAN: 'span',\n    STRIKE: 'strike',\n    STRONG: 'strong',\n    STYLE: 'style',\n    SUB: 'sub',\n    SUMMARY: 'summary',\n    SUP: 'sup',\n\n    TABLE: 'table',\n    TBODY: 'tbody',\n    TEMPLATE: 'template',\n    TEXTAREA: 'textarea',\n    TFOOT: 'tfoot',\n    TD: 'td',\n    TH: 'th',\n    THEAD: 'thead',\n    TITLE: 'title',\n    TR: 'tr',\n    TRACK: 'track',\n    TT: 'tt',\n\n    U: 'u',\n    UL: 'ul',\n\n    SVG: 'svg',\n\n    VAR: 'var',\n\n    WBR: 'wbr',\n\n    XMP: 'xmp'\n});\n\nexports.SPECIAL_ELEMENTS = {\n    [NS.HTML]: {\n        [$.ADDRESS]: true,\n        [$.APPLET]: true,\n        [$.AREA]: true,\n        [$.ARTICLE]: true,\n        [$.ASIDE]: true,\n        [$.BASE]: true,\n        [$.BASEFONT]: true,\n        [$.BGSOUND]: true,\n        [$.BLOCKQUOTE]: true,\n        [$.BODY]: true,\n        [$.BR]: true,\n        [$.BUTTON]: true,\n        [$.CAPTION]: true,\n        [$.CENTER]: true,\n        [$.COL]: true,\n        [$.COLGROUP]: true,\n        [$.DD]: true,\n        [$.DETAILS]: true,\n        [$.DIR]: true,\n        [$.DIV]: true,\n        [$.DL]: true,\n        [$.DT]: true,\n        [$.EMBED]: true,\n        [$.FIELDSET]: true,\n        [$.FIGCAPTION]: true,\n        [$.FIGURE]: true,\n        [$.FOOTER]: true,\n        [$.FORM]: true,\n        [$.FRAME]: true,\n        [$.FRAMESET]: true,\n        [$.H1]: true,\n        [$.H2]: true,\n        [$.H3]: true,\n        [$.H4]: true,\n        [$.H5]: true,\n        [$.H6]: true,\n        [$.HEAD]: true,\n        [$.HEADER]: true,\n        [$.HGROUP]: true,\n        [$.HR]: true,\n        [$.HTML]: true,\n        [$.IFRAME]: true,\n        [$.IMG]: true,\n        [$.INPUT]: true,\n        [$.LI]: true,\n        [$.LINK]: true,\n        [$.LISTING]: true,\n        [$.MAIN]: true,\n        [$.MARQUEE]: true,\n        [$.MENU]: true,\n        [$.META]: true,\n        [$.NAV]: true,\n        [$.NOEMBED]: true,\n        [$.NOFRAMES]: true,\n        [$.NOSCRIPT]: true,\n        [$.OBJECT]: true,\n        [$.OL]: true,\n        [$.P]: true,\n        [$.PARAM]: true,\n        [$.PLAINTEXT]: true,\n        [$.PRE]: true,\n        [$.SCRIPT]: true,\n        [$.SECTION]: true,\n        [$.SELECT]: true,\n        [$.SOURCE]: true,\n        [$.STYLE]: true,\n        [$.SUMMARY]: true,\n        [$.TABLE]: true,\n        [$.TBODY]: true,\n        [$.TD]: true,\n        [$.TEMPLATE]: true,\n        [$.TEXTAREA]: true,\n        [$.TFOOT]: true,\n        [$.TH]: true,\n        [$.THEAD]: true,\n        [$.TITLE]: true,\n        [$.TR]: true,\n        [$.TRACK]: true,\n        [$.UL]: true,\n        [$.WBR]: true,\n        [$.XMP]: true\n    },\n    [NS.MATHML]: {\n        [$.MI]: true,\n        [$.MO]: true,\n        [$.MN]: true,\n        [$.MS]: true,\n        [$.MTEXT]: true,\n        [$.ANNOTATION_XML]: true\n    },\n    [NS.SVG]: {\n        [$.TITLE]: true,\n        [$.FOREIGN_OBJECT]: true,\n        [$.DESC]: true\n    }\n};\n","'use strict';\n\nconst UNDEFINED_CODE_POINTS = [\n    0xfffe,\n    0xffff,\n    0x1fffe,\n    0x1ffff,\n    0x2fffe,\n    0x2ffff,\n    0x3fffe,\n    0x3ffff,\n    0x4fffe,\n    0x4ffff,\n    0x5fffe,\n    0x5ffff,\n    0x6fffe,\n    0x6ffff,\n    0x7fffe,\n    0x7ffff,\n    0x8fffe,\n    0x8ffff,\n    0x9fffe,\n    0x9ffff,\n    0xafffe,\n    0xaffff,\n    0xbfffe,\n    0xbffff,\n    0xcfffe,\n    0xcffff,\n    0xdfffe,\n    0xdffff,\n    0xefffe,\n    0xeffff,\n    0xffffe,\n    0xfffff,\n    0x10fffe,\n    0x10ffff\n];\n\nexports.REPLACEMENT_CHARACTER = '\\uFFFD';\n\nexports.CODE_POINTS = {\n    EOF: -1,\n    NULL: 0x00,\n    TABULATION: 0x09,\n    CARRIAGE_RETURN: 0x0d,\n    LINE_FEED: 0x0a,\n    FORM_FEED: 0x0c,\n    SPACE: 0x20,\n    EXCLAMATION_MARK: 0x21,\n    QUOTATION_MARK: 0x22,\n    NUMBER_SIGN: 0x23,\n    AMPERSAND: 0x26,\n    APOSTROPHE: 0x27,\n    HYPHEN_MINUS: 0x2d,\n    SOLIDUS: 0x2f,\n    DIGIT_0: 0x30,\n    DIGIT_9: 0x39,\n    SEMICOLON: 0x3b,\n    LESS_THAN_SIGN: 0x3c,\n    EQUALS_SIGN: 0x3d,\n    GREATER_THAN_SIGN: 0x3e,\n    QUESTION_MARK: 0x3f,\n    LATIN_CAPITAL_A: 0x41,\n    LATIN_CAPITAL_F: 0x46,\n    LATIN_CAPITAL_X: 0x58,\n    LATIN_CAPITAL_Z: 0x5a,\n    RIGHT_SQUARE_BRACKET: 0x5d,\n    GRAVE_ACCENT: 0x60,\n    LATIN_SMALL_A: 0x61,\n    LATIN_SMALL_F: 0x66,\n    LATIN_SMALL_X: 0x78,\n    LATIN_SMALL_Z: 0x7a,\n    REPLACEMENT_CHARACTER: 0xfffd\n};\n\nexports.CODE_POINT_SEQUENCES = {\n    DASH_DASH_STRING: [0x2d, 0x2d], //--\n    DOCTYPE_STRING: [0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45], //DOCTYPE\n    CDATA_START_STRING: [0x5b, 0x43, 0x44, 0x41, 0x54, 0x41, 0x5b], //[CDATA[\n    SCRIPT_STRING: [0x73, 0x63, 0x72, 0x69, 0x70, 0x74], //script\n    PUBLIC_STRING: [0x50, 0x55, 0x42, 0x4c, 0x49, 0x43], //PUBLIC\n    SYSTEM_STRING: [0x53, 0x59, 0x53, 0x54, 0x45, 0x4d] //SYSTEM\n};\n\n//Surrogates\nexports.isSurrogate = function(cp) {\n    return cp >= 0xd800 && cp <= 0xdfff;\n};\n\nexports.isSurrogatePair = function(cp) {\n    return cp >= 0xdc00 && cp <= 0xdfff;\n};\n\nexports.getSurrogatePairCodePoint = function(cp1, cp2) {\n    return (cp1 - 0xd800) * 0x400 + 0x2400 + cp2;\n};\n\n//NOTE: excluding NULL and ASCII whitespace\nexports.isControlCodePoint = function(cp) {\n    return (\n        (cp !== 0x20 && cp !== 0x0a && cp !== 0x0d && cp !== 0x09 && cp !== 0x0c && cp >= 0x01 && cp <= 0x1f) ||\n        (cp >= 0x7f && cp <= 0x9f)\n    );\n};\n\nexports.isUndefinedCodePoint = function(cp) {\n    return (cp >= 0xfdd0 && cp <= 0xfdef) || UNDEFINED_CODE_POINTS.indexOf(cp) > -1;\n};\n","'use strict';\n\nconst Mixin = require('../../utils/mixin');\n\nclass ErrorReportingMixinBase extends Mixin {\n    constructor(host, opts) {\n        super(host);\n\n        this.posTracker = null;\n        this.onParseError = opts.onParseError;\n    }\n\n    _setErrorLocation(err) {\n        err.startLine = err.endLine = this.posTracker.line;\n        err.startCol = err.endCol = this.posTracker.col;\n        err.startOffset = err.endOffset = this.posTracker.offset;\n    }\n\n    _reportError(code) {\n        const err = {\n            code: code,\n            startLine: -1,\n            startCol: -1,\n            startOffset: -1,\n            endLine: -1,\n            endCol: -1,\n            endOffset: -1\n        };\n\n        this._setErrorLocation(err);\n        this.onParseError(err);\n    }\n\n    _getOverriddenMethods(mxn) {\n        return {\n            _err(code) {\n                mxn._reportError(code);\n            }\n        };\n    }\n}\n\nmodule.exports = ErrorReportingMixinBase;\n","'use strict';\n\nconst ErrorReportingMixinBase = require('./mixin-base');\nconst ErrorReportingTokenizerMixin = require('./tokenizer-mixin');\nconst LocationInfoTokenizerMixin = require('../location-info/tokenizer-mixin');\nconst Mixin = require('../../utils/mixin');\n\nclass ErrorReportingParserMixin extends ErrorReportingMixinBase {\n    constructor(parser, opts) {\n        super(parser, opts);\n\n        this.opts = opts;\n        this.ctLoc = null;\n        this.locBeforeToken = false;\n    }\n\n    _setErrorLocation(err) {\n        if (this.ctLoc) {\n            err.startLine = this.ctLoc.startLine;\n            err.startCol = this.ctLoc.startCol;\n            err.startOffset = this.ctLoc.startOffset;\n\n            err.endLine = this.locBeforeToken ? this.ctLoc.startLine : this.ctLoc.endLine;\n            err.endCol = this.locBeforeToken ? this.ctLoc.startCol : this.ctLoc.endCol;\n            err.endOffset = this.locBeforeToken ? this.ctLoc.startOffset : this.ctLoc.endOffset;\n        }\n    }\n\n    _getOverriddenMethods(mxn, orig) {\n        return {\n            _bootstrap(document, fragmentContext) {\n                orig._bootstrap.call(this, document, fragmentContext);\n\n                Mixin.install(this.tokenizer, ErrorReportingTokenizerMixin, mxn.opts);\n                Mixin.install(this.tokenizer, LocationInfoTokenizerMixin);\n            },\n\n            _processInputToken(token) {\n                mxn.ctLoc = token.location;\n\n                orig._processInputToken.call(this, token);\n            },\n\n            _err(code, options) {\n                mxn.locBeforeToken = options && options.beforeToken;\n                mxn._reportError(code);\n            }\n        };\n    }\n}\n\nmodule.exports = ErrorReportingParserMixin;\n","'use strict';\n\nconst ErrorReportingMixinBase = require('./mixin-base');\nconst PositionTrackingPreprocessorMixin = require('../position-tracking/preprocessor-mixin');\nconst Mixin = require('../../utils/mixin');\n\nclass ErrorReportingPreprocessorMixin extends ErrorReportingMixinBase {\n    constructor(preprocessor, opts) {\n        super(preprocessor, opts);\n\n        this.posTracker = Mixin.install(preprocessor, PositionTrackingPreprocessorMixin);\n        this.lastErrOffset = -1;\n    }\n\n    _reportError(code) {\n        //NOTE: avoid reporting error twice on advance/retreat\n        if (this.lastErrOffset !== this.posTracker.offset) {\n            this.lastErrOffset = this.posTracker.offset;\n            super._reportError(code);\n        }\n    }\n}\n\nmodule.exports = ErrorReportingPreprocessorMixin;\n","'use strict';\n\nconst ErrorReportingMixinBase = require('./mixin-base');\nconst ErrorReportingPreprocessorMixin = require('./preprocessor-mixin');\nconst Mixin = require('../../utils/mixin');\n\nclass ErrorReportingTokenizerMixin extends ErrorReportingMixinBase {\n    constructor(tokenizer, opts) {\n        super(tokenizer, opts);\n\n        const preprocessorMixin = Mixin.install(tokenizer.preprocessor, ErrorReportingPreprocessorMixin, opts);\n\n        this.posTracker = preprocessorMixin.posTracker;\n    }\n}\n\nmodule.exports = ErrorReportingTokenizerMixin;\n","'use strict';\n\nconst Mixin = require('../../utils/mixin');\n\nclass LocationInfoOpenElementStackMixin extends Mixin {\n    constructor(stack, opts) {\n        super(stack);\n\n        this.onItemPop = opts.onItemPop;\n    }\n\n    _getOverriddenMethods(mxn, orig) {\n        return {\n            pop() {\n                mxn.onItemPop(this.current);\n                orig.pop.call(this);\n            },\n\n            popAllUpToHtmlElement() {\n                for (let i = this.stackTop; i > 0; i--) {\n                    mxn.onItemPop(this.items[i]);\n                }\n\n                orig.popAllUpToHtmlElement.call(this);\n            },\n\n            remove(element) {\n                mxn.onItemPop(this.current);\n                orig.remove.call(this, element);\n            }\n        };\n    }\n}\n\nmodule.exports = LocationInfoOpenElementStackMixin;\n","'use strict';\n\nconst Mixin = require('../../utils/mixin');\nconst Tokenizer = require('../../tokenizer');\nconst LocationInfoTokenizerMixin = require('./tokenizer-mixin');\nconst LocationInfoOpenElementStackMixin = require('./open-element-stack-mixin');\nconst HTML = require('../../common/html');\n\n//Aliases\nconst $ = HTML.TAG_NAMES;\n\nclass LocationInfoParserMixin extends Mixin {\n    constructor(parser) {\n        super(parser);\n\n        this.parser = parser;\n        this.treeAdapter = this.parser.treeAdapter;\n        this.posTracker = null;\n        this.lastStartTagToken = null;\n        this.lastFosterParentingLocation = null;\n        this.currentToken = null;\n    }\n\n    _setStartLocation(element) {\n        let loc = null;\n\n        if (this.lastStartTagToken) {\n            loc = Object.assign({}, this.lastStartTagToken.location);\n            loc.startTag = this.lastStartTagToken.location;\n        }\n\n        this.treeAdapter.setNodeSourceCodeLocation(element, loc);\n    }\n\n    _setEndLocation(element, closingToken) {\n        const loc = this.treeAdapter.getNodeSourceCodeLocation(element);\n\n        if (loc) {\n            if (closingToken.location) {\n                const ctLoc = closingToken.location;\n                const tn = this.treeAdapter.getTagName(element);\n\n                // NOTE: For cases like <p> <p> </p> - First 'p' closes without a closing\n                // tag and for cases like <td> <p> </td> - 'p' closes without a closing tag.\n                const isClosingEndTag = closingToken.type === Tokenizer.END_TAG_TOKEN && tn === closingToken.tagName;\n                const endLoc = {};\n                if (isClosingEndTag) {\n                    endLoc.endTag = Object.assign({}, ctLoc);\n                    endLoc.endLine = ctLoc.endLine;\n                    endLoc.endCol = ctLoc.endCol;\n                    endLoc.endOffset = ctLoc.endOffset;\n                } else {\n                    endLoc.endLine = ctLoc.startLine;\n                    endLoc.endCol = ctLoc.startCol;\n                    endLoc.endOffset = ctLoc.startOffset;\n                }\n\n                this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc);\n            }\n        }\n    }\n\n    _getOverriddenMethods(mxn, orig) {\n        return {\n            _bootstrap(document, fragmentContext) {\n                orig._bootstrap.call(this, document, fragmentContext);\n\n                mxn.lastStartTagToken = null;\n                mxn.lastFosterParentingLocation = null;\n                mxn.currentToken = null;\n\n                const tokenizerMixin = Mixin.install(this.tokenizer, LocationInfoTokenizerMixin);\n\n                mxn.posTracker = tokenizerMixin.posTracker;\n\n                Mixin.install(this.openElements, LocationInfoOpenElementStackMixin, {\n                    onItemPop: function(element) {\n                        mxn._setEndLocation(element, mxn.currentToken);\n                    }\n                });\n            },\n\n            _runParsingLoop(scriptHandler) {\n                orig._runParsingLoop.call(this, scriptHandler);\n\n                // NOTE: generate location info for elements\n                // that remains on open element stack\n                for (let i = this.openElements.stackTop; i >= 0; i--) {\n                    mxn._setEndLocation(this.openElements.items[i], mxn.currentToken);\n                }\n            },\n\n            //Token processing\n            _processTokenInForeignContent(token) {\n                mxn.currentToken = token;\n                orig._processTokenInForeignContent.call(this, token);\n            },\n\n            _processToken(token) {\n                mxn.currentToken = token;\n                orig._processToken.call(this, token);\n\n                //NOTE: <body> and <html> are never popped from the stack, so we need to updated\n                //their end location explicitly.\n                const requireExplicitUpdate =\n                    token.type === Tokenizer.END_TAG_TOKEN &&\n                    (token.tagName === $.HTML || (token.tagName === $.BODY && this.openElements.hasInScope($.BODY)));\n\n                if (requireExplicitUpdate) {\n                    for (let i = this.openElements.stackTop; i >= 0; i--) {\n                        const element = this.openElements.items[i];\n\n                        if (this.treeAdapter.getTagName(element) === token.tagName) {\n                            mxn._setEndLocation(element, token);\n                            break;\n                        }\n                    }\n                }\n            },\n\n            //Doctype\n            _setDocumentType(token) {\n                orig._setDocumentType.call(this, token);\n\n                const documentChildren = this.treeAdapter.getChildNodes(this.document);\n                const cnLength = documentChildren.length;\n\n                for (let i = 0; i < cnLength; i++) {\n                    const node = documentChildren[i];\n\n                    if (this.treeAdapter.isDocumentTypeNode(node)) {\n                        this.treeAdapter.setNodeSourceCodeLocation(node, token.location);\n                        break;\n                    }\n                }\n            },\n\n            //Elements\n            _attachElementToTree(element) {\n                //NOTE: _attachElementToTree is called from _appendElement, _insertElement and _insertTemplate methods.\n                //So we will use token location stored in this methods for the element.\n                mxn._setStartLocation(element);\n                mxn.lastStartTagToken = null;\n                orig._attachElementToTree.call(this, element);\n            },\n\n            _appendElement(token, namespaceURI) {\n                mxn.lastStartTagToken = token;\n                orig._appendElement.call(this, token, namespaceURI);\n            },\n\n            _insertElement(token, namespaceURI) {\n                mxn.lastStartTagToken = token;\n                orig._insertElement.call(this, token, namespaceURI);\n            },\n\n            _insertTemplate(token) {\n                mxn.lastStartTagToken = token;\n                orig._insertTemplate.call(this, token);\n\n                const tmplContent = this.treeAdapter.getTemplateContent(this.openElements.current);\n\n                this.treeAdapter.setNodeSourceCodeLocation(tmplContent, null);\n            },\n\n            _insertFakeRootElement() {\n                orig._insertFakeRootElement.call(this);\n                this.treeAdapter.setNodeSourceCodeLocation(this.openElements.current, null);\n            },\n\n            //Comments\n            _appendCommentNode(token, parent) {\n                orig._appendCommentNode.call(this, token, parent);\n\n                const children = this.treeAdapter.getChildNodes(parent);\n                const commentNode = children[children.length - 1];\n\n                this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);\n            },\n\n            //Text\n            _findFosterParentingLocation() {\n                //NOTE: store last foster parenting location, so we will be able to find inserted text\n                //in case of foster parenting\n                mxn.lastFosterParentingLocation = orig._findFosterParentingLocation.call(this);\n\n                return mxn.lastFosterParentingLocation;\n            },\n\n            _insertCharacters(token) {\n                orig._insertCharacters.call(this, token);\n\n                const hasFosterParent = this._shouldFosterParentOnInsertion();\n\n                const parent =\n                    (hasFosterParent && mxn.lastFosterParentingLocation.parent) ||\n                    this.openElements.currentTmplContent ||\n                    this.openElements.current;\n\n                const siblings = this.treeAdapter.getChildNodes(parent);\n\n                const textNodeIdx =\n                    hasFosterParent && mxn.lastFosterParentingLocation.beforeElement\n                        ? siblings.indexOf(mxn.lastFosterParentingLocation.beforeElement) - 1\n                        : siblings.length - 1;\n\n                const textNode = siblings[textNodeIdx];\n\n                //NOTE: if we have location assigned by another token, then just update end position\n                const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode);\n\n                if (tnLoc) {\n                    const { endLine, endCol, endOffset } = token.location;\n                    this.treeAdapter.updateNodeSourceCodeLocation(textNode, { endLine, endCol, endOffset });\n                } else {\n                    this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);\n                }\n            }\n        };\n    }\n}\n\nmodule.exports = LocationInfoParserMixin;\n","'use strict';\n\nconst Mixin = require('../../utils/mixin');\nconst Tokenizer = require('../../tokenizer');\nconst PositionTrackingPreprocessorMixin = require('../position-tracking/preprocessor-mixin');\n\nclass LocationInfoTokenizerMixin extends Mixin {\n    constructor(tokenizer) {\n        super(tokenizer);\n\n        this.tokenizer = tokenizer;\n        this.posTracker = Mixin.install(tokenizer.preprocessor, PositionTrackingPreprocessorMixin);\n        this.currentAttrLocation = null;\n        this.ctLoc = null;\n    }\n\n    _getCurrentLocation() {\n        return {\n            startLine: this.posTracker.line,\n            startCol: this.posTracker.col,\n            startOffset: this.posTracker.offset,\n            endLine: -1,\n            endCol: -1,\n            endOffset: -1\n        };\n    }\n\n    _attachCurrentAttrLocationInfo() {\n        this.currentAttrLocation.endLine = this.posTracker.line;\n        this.currentAttrLocation.endCol = this.posTracker.col;\n        this.currentAttrLocation.endOffset = this.posTracker.offset;\n\n        const currentToken = this.tokenizer.currentToken;\n        const currentAttr = this.tokenizer.currentAttr;\n\n        if (!currentToken.location.attrs) {\n            currentToken.location.attrs = Object.create(null);\n        }\n\n        currentToken.location.attrs[currentAttr.name] = this.currentAttrLocation;\n    }\n\n    _getOverriddenMethods(mxn, orig) {\n        const methods = {\n            _createStartTagToken() {\n                orig._createStartTagToken.call(this);\n                this.currentToken.location = mxn.ctLoc;\n            },\n\n            _createEndTagToken() {\n                orig._createEndTagToken.call(this);\n                this.currentToken.location = mxn.ctLoc;\n            },\n\n            _createCommentToken() {\n                orig._createCommentToken.call(this);\n                this.currentToken.location = mxn.ctLoc;\n            },\n\n            _createDoctypeToken(initialName) {\n                orig._createDoctypeToken.call(this, initialName);\n                this.currentToken.location = mxn.ctLoc;\n            },\n\n            _createCharacterToken(type, ch) {\n                orig._createCharacterToken.call(this, type, ch);\n                this.currentCharacterToken.location = mxn.ctLoc;\n            },\n\n            _createEOFToken() {\n                orig._createEOFToken.call(this);\n                this.currentToken.location = mxn._getCurrentLocation();\n            },\n\n            _createAttr(attrNameFirstCh) {\n                orig._createAttr.call(this, attrNameFirstCh);\n                mxn.currentAttrLocation = mxn._getCurrentLocation();\n            },\n\n            _leaveAttrName(toState) {\n                orig._leaveAttrName.call(this, toState);\n                mxn._attachCurrentAttrLocationInfo();\n            },\n\n            _leaveAttrValue(toState) {\n                orig._leaveAttrValue.call(this, toState);\n                mxn._attachCurrentAttrLocationInfo();\n            },\n\n            _emitCurrentToken() {\n                const ctLoc = this.currentToken.location;\n\n                //NOTE: if we have pending character token make it's end location equal to the\n                //current token's start location.\n                if (this.currentCharacterToken) {\n                    this.currentCharacterToken.location.endLine = ctLoc.startLine;\n                    this.currentCharacterToken.location.endCol = ctLoc.startCol;\n                    this.currentCharacterToken.location.endOffset = ctLoc.startOffset;\n                }\n\n                if (this.currentToken.type === Tokenizer.EOF_TOKEN) {\n                    ctLoc.endLine = ctLoc.startLine;\n                    ctLoc.endCol = ctLoc.startCol;\n                    ctLoc.endOffset = ctLoc.startOffset;\n                } else {\n                    ctLoc.endLine = mxn.posTracker.line;\n                    ctLoc.endCol = mxn.posTracker.col + 1;\n                    ctLoc.endOffset = mxn.posTracker.offset + 1;\n                }\n\n                orig._emitCurrentToken.call(this);\n            },\n\n            _emitCurrentCharacterToken() {\n                const ctLoc = this.currentCharacterToken && this.currentCharacterToken.location;\n\n                //NOTE: if we have character token and it's location wasn't set in the _emitCurrentToken(),\n                //then set it's location at the current preprocessor position.\n                //We don't need to increment preprocessor position, since character token\n                //emission is always forced by the start of the next character token here.\n                //So, we already have advanced position.\n                if (ctLoc && ctLoc.endOffset === -1) {\n                    ctLoc.endLine = mxn.posTracker.line;\n                    ctLoc.endCol = mxn.posTracker.col;\n                    ctLoc.endOffset = mxn.posTracker.offset;\n                }\n\n                orig._emitCurrentCharacterToken.call(this);\n            }\n        };\n\n        //NOTE: patch initial states for each mode to obtain token start position\n        Object.keys(Tokenizer.MODE).forEach(modeName => {\n            const state = Tokenizer.MODE[modeName];\n\n            methods[state] = function(cp) {\n                mxn.ctLoc = mxn._getCurrentLocation();\n                orig[state].call(this, cp);\n            };\n        });\n\n        return methods;\n    }\n}\n\nmodule.exports = LocationInfoTokenizerMixin;\n","'use strict';\n\nconst Mixin = require('../../utils/mixin');\n\nclass PositionTrackingPreprocessorMixin extends Mixin {\n    constructor(preprocessor) {\n        super(preprocessor);\n\n        this.preprocessor = preprocessor;\n        this.isEol = false;\n        this.lineStartPos = 0;\n        this.droppedBufferSize = 0;\n\n        this.offset = 0;\n        this.col = 0;\n        this.line = 1;\n    }\n\n    _getOverriddenMethods(mxn, orig) {\n        return {\n            advance() {\n                const pos = this.pos + 1;\n                const ch = this.html[pos];\n\n                //NOTE: LF should be in the last column of the line\n                if (mxn.isEol) {\n                    mxn.isEol = false;\n                    mxn.line++;\n                    mxn.lineStartPos = pos;\n                }\n\n                if (ch === '\\n' || (ch === '\\r' && this.html[pos + 1] !== '\\n')) {\n                    mxn.isEol = true;\n                }\n\n                mxn.col = pos - mxn.lineStartPos + 1;\n                mxn.offset = mxn.droppedBufferSize + pos;\n\n                return orig.advance.call(this);\n            },\n\n            retreat() {\n                orig.retreat.call(this);\n\n                mxn.isEol = false;\n                mxn.col = this.pos - mxn.lineStartPos + 1;\n            },\n\n            dropParsedChunk() {\n                const prevPos = this.pos;\n\n                orig.dropParsedChunk.call(this);\n\n                const reduction = prevPos - this.pos;\n\n                mxn.lineStartPos -= reduction;\n                mxn.droppedBufferSize += reduction;\n                mxn.offset = mxn.droppedBufferSize + this.pos;\n            }\n        };\n    }\n}\n\nmodule.exports = PositionTrackingPreprocessorMixin;\n","'use strict';\n\n//Const\nconst NOAH_ARK_CAPACITY = 3;\n\n//List of formatting elements\nclass FormattingElementList {\n    constructor(treeAdapter) {\n        this.length = 0;\n        this.entries = [];\n        this.treeAdapter = treeAdapter;\n        this.bookmark = null;\n    }\n\n    //Noah Ark's condition\n    //OPTIMIZATION: at first we try to find possible candidates for exclusion using\n    //lightweight heuristics without thorough attributes check.\n    _getNoahArkConditionCandidates(newElement) {\n        const candidates = [];\n\n        if (this.length >= NOAH_ARK_CAPACITY) {\n            const neAttrsLength = this.treeAdapter.getAttrList(newElement).length;\n            const neTagName = this.treeAdapter.getTagName(newElement);\n            const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);\n\n            for (let i = this.length - 1; i >= 0; i--) {\n                const entry = this.entries[i];\n\n                if (entry.type === FormattingElementList.MARKER_ENTRY) {\n                    break;\n                }\n\n                const element = entry.element;\n                const elementAttrs = this.treeAdapter.getAttrList(element);\n\n                const isCandidate =\n                    this.treeAdapter.getTagName(element) === neTagName &&\n                    this.treeAdapter.getNamespaceURI(element) === neNamespaceURI &&\n                    elementAttrs.length === neAttrsLength;\n\n                if (isCandidate) {\n                    candidates.push({ idx: i, attrs: elementAttrs });\n                }\n            }\n        }\n\n        return candidates.length < NOAH_ARK_CAPACITY ? [] : candidates;\n    }\n\n    _ensureNoahArkCondition(newElement) {\n        const candidates = this._getNoahArkConditionCandidates(newElement);\n        let cLength = candidates.length;\n\n        if (cLength) {\n            const neAttrs = this.treeAdapter.getAttrList(newElement);\n            const neAttrsLength = neAttrs.length;\n            const neAttrsMap = Object.create(null);\n\n            //NOTE: build attrs map for the new element so we can perform fast lookups\n            for (let i = 0; i < neAttrsLength; i++) {\n                const neAttr = neAttrs[i];\n\n                neAttrsMap[neAttr.name] = neAttr.value;\n            }\n\n            for (let i = 0; i < neAttrsLength; i++) {\n                for (let j = 0; j < cLength; j++) {\n                    const cAttr = candidates[j].attrs[i];\n\n                    if (neAttrsMap[cAttr.name] !== cAttr.value) {\n                        candidates.splice(j, 1);\n                        cLength--;\n                    }\n\n                    if (candidates.length < NOAH_ARK_CAPACITY) {\n                        return;\n                    }\n                }\n            }\n\n            //NOTE: remove bottommost candidates until Noah's Ark condition will not be met\n            for (let i = cLength - 1; i >= NOAH_ARK_CAPACITY - 1; i--) {\n                this.entries.splice(candidates[i].idx, 1);\n                this.length--;\n            }\n        }\n    }\n\n    //Mutations\n    insertMarker() {\n        this.entries.push({ type: FormattingElementList.MARKER_ENTRY });\n        this.length++;\n    }\n\n    pushElement(element, token) {\n        this._ensureNoahArkCondition(element);\n\n        this.entries.push({\n            type: FormattingElementList.ELEMENT_ENTRY,\n            element: element,\n            token: token\n        });\n\n        this.length++;\n    }\n\n    insertElementAfterBookmark(element, token) {\n        let bookmarkIdx = this.length - 1;\n\n        for (; bookmarkIdx >= 0; bookmarkIdx--) {\n            if (this.entries[bookmarkIdx] === this.bookmark) {\n                break;\n            }\n        }\n\n        this.entries.splice(bookmarkIdx + 1, 0, {\n            type: FormattingElementList.ELEMENT_ENTRY,\n            element: element,\n            token: token\n        });\n\n        this.length++;\n    }\n\n    removeEntry(entry) {\n        for (let i = this.length - 1; i >= 0; i--) {\n            if (this.entries[i] === entry) {\n                this.entries.splice(i, 1);\n                this.length--;\n                break;\n            }\n        }\n    }\n\n    clearToLastMarker() {\n        while (this.length) {\n            const entry = this.entries.pop();\n\n            this.length--;\n\n            if (entry.type === FormattingElementList.MARKER_ENTRY) {\n                break;\n            }\n        }\n    }\n\n    //Search\n    getElementEntryInScopeWithTagName(tagName) {\n        for (let i = this.length - 1; i >= 0; i--) {\n            const entry = this.entries[i];\n\n            if (entry.type === FormattingElementList.MARKER_ENTRY) {\n                return null;\n            }\n\n            if (this.treeAdapter.getTagName(entry.element) === tagName) {\n                return entry;\n            }\n        }\n\n        return null;\n    }\n\n    getElementEntry(element) {\n        for (let i = this.length - 1; i >= 0; i--) {\n            const entry = this.entries[i];\n\n            if (entry.type === FormattingElementList.ELEMENT_ENTRY && entry.element === element) {\n                return entry;\n            }\n        }\n\n        return null;\n    }\n}\n\n//Entry types\nFormattingElementList.MARKER_ENTRY = 'MARKER_ENTRY';\nFormattingElementList.ELEMENT_ENTRY = 'ELEMENT_ENTRY';\n\nmodule.exports = FormattingElementList;\n","'use strict';\n\nconst Tokenizer = require('../tokenizer');\nconst OpenElementStack = require('./open-element-stack');\nconst FormattingElementList = require('./formatting-element-list');\nconst LocationInfoParserMixin = require('../extensions/location-info/parser-mixin');\nconst ErrorReportingParserMixin = require('../extensions/error-reporting/parser-mixin');\nconst Mixin = require('../utils/mixin');\nconst defaultTreeAdapter = require('../tree-adapters/default');\nconst mergeOptions = require('../utils/merge-options');\nconst doctype = require('../common/doctype');\nconst foreignContent = require('../common/foreign-content');\nconst ERR = require('../common/error-codes');\nconst unicode = require('../common/unicode');\nconst HTML = require('../common/html');\n\n//Aliases\nconst $ = HTML.TAG_NAMES;\nconst NS = HTML.NAMESPACES;\nconst ATTRS = HTML.ATTRS;\n\nconst DEFAULT_OPTIONS = {\n    scriptingEnabled: true,\n    sourceCodeLocationInfo: false,\n    onParseError: null,\n    treeAdapter: defaultTreeAdapter\n};\n\n//Misc constants\nconst HIDDEN_INPUT_TYPE = 'hidden';\n\n//Adoption agency loops iteration count\nconst AA_OUTER_LOOP_ITER = 8;\nconst AA_INNER_LOOP_ITER = 3;\n\n//Insertion modes\nconst INITIAL_MODE = 'INITIAL_MODE';\nconst BEFORE_HTML_MODE = 'BEFORE_HTML_MODE';\nconst BEFORE_HEAD_MODE = 'BEFORE_HEAD_MODE';\nconst IN_HEAD_MODE = 'IN_HEAD_MODE';\nconst IN_HEAD_NO_SCRIPT_MODE = 'IN_HEAD_NO_SCRIPT_MODE';\nconst AFTER_HEAD_MODE = 'AFTER_HEAD_MODE';\nconst IN_BODY_MODE = 'IN_BODY_MODE';\nconst TEXT_MODE = 'TEXT_MODE';\nconst IN_TABLE_MODE = 'IN_TABLE_MODE';\nconst IN_TABLE_TEXT_MODE = 'IN_TABLE_TEXT_MODE';\nconst IN_CAPTION_MODE = 'IN_CAPTION_MODE';\nconst IN_COLUMN_GROUP_MODE = 'IN_COLUMN_GROUP_MODE';\nconst IN_TABLE_BODY_MODE = 'IN_TABLE_BODY_MODE';\nconst IN_ROW_MODE = 'IN_ROW_MODE';\nconst IN_CELL_MODE = 'IN_CELL_MODE';\nconst IN_SELECT_MODE = 'IN_SELECT_MODE';\nconst IN_SELECT_IN_TABLE_MODE = 'IN_SELECT_IN_TABLE_MODE';\nconst IN_TEMPLATE_MODE = 'IN_TEMPLATE_MODE';\nconst AFTER_BODY_MODE = 'AFTER_BODY_MODE';\nconst IN_FRAMESET_MODE = 'IN_FRAMESET_MODE';\nconst AFTER_FRAMESET_MODE = 'AFTER_FRAMESET_MODE';\nconst AFTER_AFTER_BODY_MODE = 'AFTER_AFTER_BODY_MODE';\nconst AFTER_AFTER_FRAMESET_MODE = 'AFTER_AFTER_FRAMESET_MODE';\n\n//Insertion mode reset map\nconst INSERTION_MODE_RESET_MAP = {\n    [$.TR]: IN_ROW_MODE,\n    [$.TBODY]: IN_TABLE_BODY_MODE,\n    [$.THEAD]: IN_TABLE_BODY_MODE,\n    [$.TFOOT]: IN_TABLE_BODY_MODE,\n    [$.CAPTION]: IN_CAPTION_MODE,\n    [$.COLGROUP]: IN_COLUMN_GROUP_MODE,\n    [$.TABLE]: IN_TABLE_MODE,\n    [$.BODY]: IN_BODY_MODE,\n    [$.FRAMESET]: IN_FRAMESET_MODE\n};\n\n//Template insertion mode switch map\nconst TEMPLATE_INSERTION_MODE_SWITCH_MAP = {\n    [$.CAPTION]: IN_TABLE_MODE,\n    [$.COLGROUP]: IN_TABLE_MODE,\n    [$.TBODY]: IN_TABLE_MODE,\n    [$.TFOOT]: IN_TABLE_MODE,\n    [$.THEAD]: IN_TABLE_MODE,\n    [$.COL]: IN_COLUMN_GROUP_MODE,\n    [$.TR]: IN_TABLE_BODY_MODE,\n    [$.TD]: IN_ROW_MODE,\n    [$.TH]: IN_ROW_MODE\n};\n\n//Token handlers map for insertion modes\nconst TOKEN_HANDLERS = {\n    [INITIAL_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenInInitialMode,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInInitialMode,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: doctypeInInitialMode,\n        [Tokenizer.START_TAG_TOKEN]: tokenInInitialMode,\n        [Tokenizer.END_TAG_TOKEN]: tokenInInitialMode,\n        [Tokenizer.EOF_TOKEN]: tokenInInitialMode\n    },\n    [BEFORE_HTML_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHtml,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHtml,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagBeforeHtml,\n        [Tokenizer.END_TAG_TOKEN]: endTagBeforeHtml,\n        [Tokenizer.EOF_TOKEN]: tokenBeforeHtml\n    },\n    [BEFORE_HEAD_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHead,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHead,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,\n        [Tokenizer.START_TAG_TOKEN]: startTagBeforeHead,\n        [Tokenizer.END_TAG_TOKEN]: endTagBeforeHead,\n        [Tokenizer.EOF_TOKEN]: tokenBeforeHead\n    },\n    [IN_HEAD_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenInHead,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHead,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,\n        [Tokenizer.START_TAG_TOKEN]: startTagInHead,\n        [Tokenizer.END_TAG_TOKEN]: endTagInHead,\n        [Tokenizer.EOF_TOKEN]: tokenInHead\n    },\n    [IN_HEAD_NO_SCRIPT_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenInHeadNoScript,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHeadNoScript,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,\n        [Tokenizer.START_TAG_TOKEN]: startTagInHeadNoScript,\n        [Tokenizer.END_TAG_TOKEN]: endTagInHeadNoScript,\n        [Tokenizer.EOF_TOKEN]: tokenInHeadNoScript\n    },\n    [AFTER_HEAD_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenAfterHead,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterHead,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,\n        [Tokenizer.START_TAG_TOKEN]: startTagAfterHead,\n        [Tokenizer.END_TAG_TOKEN]: endTagAfterHead,\n        [Tokenizer.EOF_TOKEN]: tokenAfterHead\n    },\n    [IN_BODY_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: characterInBody,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInBody,\n        [Tokenizer.END_TAG_TOKEN]: endTagInBody,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [TEXT_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: ignoreToken,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: ignoreToken,\n        [Tokenizer.END_TAG_TOKEN]: endTagInText,\n        [Tokenizer.EOF_TOKEN]: eofInText\n    },\n    [IN_TABLE_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInTable,\n        [Tokenizer.END_TAG_TOKEN]: endTagInTable,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [IN_TABLE_TEXT_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: characterInTableText,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInTableText,\n        [Tokenizer.COMMENT_TOKEN]: tokenInTableText,\n        [Tokenizer.DOCTYPE_TOKEN]: tokenInTableText,\n        [Tokenizer.START_TAG_TOKEN]: tokenInTableText,\n        [Tokenizer.END_TAG_TOKEN]: tokenInTableText,\n        [Tokenizer.EOF_TOKEN]: tokenInTableText\n    },\n    [IN_CAPTION_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: characterInBody,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInCaption,\n        [Tokenizer.END_TAG_TOKEN]: endTagInCaption,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [IN_COLUMN_GROUP_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenInColumnGroup,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInColumnGroup,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInColumnGroup,\n        [Tokenizer.END_TAG_TOKEN]: endTagInColumnGroup,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [IN_TABLE_BODY_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInTableBody,\n        [Tokenizer.END_TAG_TOKEN]: endTagInTableBody,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [IN_ROW_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInRow,\n        [Tokenizer.END_TAG_TOKEN]: endTagInRow,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [IN_CELL_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: characterInBody,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInCell,\n        [Tokenizer.END_TAG_TOKEN]: endTagInCell,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [IN_SELECT_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInSelect,\n        [Tokenizer.END_TAG_TOKEN]: endTagInSelect,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [IN_SELECT_IN_TABLE_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInSelectInTable,\n        [Tokenizer.END_TAG_TOKEN]: endTagInSelectInTable,\n        [Tokenizer.EOF_TOKEN]: eofInBody\n    },\n    [IN_TEMPLATE_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: characterInBody,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInTemplate,\n        [Tokenizer.END_TAG_TOKEN]: endTagInTemplate,\n        [Tokenizer.EOF_TOKEN]: eofInTemplate\n    },\n    [AFTER_BODY_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenAfterBody,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterBody,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,\n        [Tokenizer.COMMENT_TOKEN]: appendCommentToRootHtmlElement,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagAfterBody,\n        [Tokenizer.END_TAG_TOKEN]: endTagAfterBody,\n        [Tokenizer.EOF_TOKEN]: stopParsing\n    },\n    [IN_FRAMESET_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagInFrameset,\n        [Tokenizer.END_TAG_TOKEN]: endTagInFrameset,\n        [Tokenizer.EOF_TOKEN]: stopParsing\n    },\n    [AFTER_FRAMESET_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,\n        [Tokenizer.COMMENT_TOKEN]: appendComment,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagAfterFrameset,\n        [Tokenizer.END_TAG_TOKEN]: endTagAfterFrameset,\n        [Tokenizer.EOF_TOKEN]: stopParsing\n    },\n    [AFTER_AFTER_BODY_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: tokenAfterAfterBody,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterAfterBody,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,\n        [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterBody,\n        [Tokenizer.END_TAG_TOKEN]: tokenAfterAfterBody,\n        [Tokenizer.EOF_TOKEN]: stopParsing\n    },\n    [AFTER_AFTER_FRAMESET_MODE]: {\n        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,\n        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,\n        [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument,\n        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,\n        [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterFrameset,\n        [Tokenizer.END_TAG_TOKEN]: ignoreToken,\n        [Tokenizer.EOF_TOKEN]: stopParsing\n    }\n};\n\n//Parser\nclass Parser {\n    constructor(options) {\n        this.options = mergeOptions(DEFAULT_OPTIONS, options);\n\n        this.treeAdapter = this.options.treeAdapter;\n        this.pendingScript = null;\n\n        if (this.options.sourceCodeLocationInfo) {\n            Mixin.install(this, LocationInfoParserMixin);\n        }\n\n        if (this.options.onParseError) {\n            Mixin.install(this, ErrorReportingParserMixin, { onParseError: this.options.onParseError });\n        }\n    }\n\n    // API\n    parse(html) {\n        const document = this.treeAdapter.createDocument();\n\n        this._bootstrap(document, null);\n        this.tokenizer.write(html, true);\n        this._runParsingLoop(null);\n\n        return document;\n    }\n\n    parseFragment(html, fragmentContext) {\n        //NOTE: use <template> element as a fragment context if context element was not provided,\n        //so we will parse in \"forgiving\" manner\n        if (!fragmentContext) {\n            fragmentContext = this.treeAdapter.createElement($.TEMPLATE, NS.HTML, []);\n        }\n\n        //NOTE: create fake element which will be used as 'document' for fragment parsing.\n        //This is important for jsdom there 'document' can't be recreated, therefore\n        //fragment parsing causes messing of the main `document`.\n        const documentMock = this.treeAdapter.createElement('documentmock', NS.HTML, []);\n\n        this._bootstrap(documentMock, fragmentContext);\n\n        if (this.treeAdapter.getTagName(fragmentContext) === $.TEMPLATE) {\n            this._pushTmplInsertionMode(IN_TEMPLATE_MODE);\n        }\n\n        this._initTokenizerForFragmentParsing();\n        this._insertFakeRootElement();\n        this._resetInsertionMode();\n        this._findFormInFragmentContext();\n        this.tokenizer.write(html, true);\n        this._runParsingLoop(null);\n\n        const rootElement = this.treeAdapter.getFirstChild(documentMock);\n        const fragment = this.treeAdapter.createDocumentFragment();\n\n        this._adoptNodes(rootElement, fragment);\n\n        return fragment;\n    }\n\n    //Bootstrap parser\n    _bootstrap(document, fragmentContext) {\n        this.tokenizer = new Tokenizer(this.options);\n\n        this.stopped = false;\n\n        this.insertionMode = INITIAL_MODE;\n        this.originalInsertionMode = '';\n\n        this.document = document;\n        this.fragmentContext = fragmentContext;\n\n        this.headElement = null;\n        this.formElement = null;\n\n        this.openElements = new OpenElementStack(this.document, this.treeAdapter);\n        this.activeFormattingElements = new FormattingElementList(this.treeAdapter);\n\n        this.tmplInsertionModeStack = [];\n        this.tmplInsertionModeStackTop = -1;\n        this.currentTmplInsertionMode = null;\n\n        this.pendingCharacterTokens = [];\n        this.hasNonWhitespacePendingCharacterToken = false;\n\n        this.framesetOk = true;\n        this.skipNextNewLine = false;\n        this.fosterParentingEnabled = false;\n    }\n\n    //Errors\n    _err() {\n        // NOTE: err reporting is noop by default. Enabled by mixin.\n    }\n\n    //Parsing loop\n    _runParsingLoop(scriptHandler) {\n        while (!this.stopped) {\n            this._setupTokenizerCDATAMode();\n\n            const token = this.tokenizer.getNextToken();\n\n            if (token.type === Tokenizer.HIBERNATION_TOKEN) {\n                break;\n            }\n\n            if (this.skipNextNewLine) {\n                this.skipNextNewLine = false;\n\n                if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN && token.chars[0] === '\\n') {\n                    if (token.chars.length === 1) {\n                        continue;\n                    }\n\n                    token.chars = token.chars.substr(1);\n                }\n            }\n\n            this._processInputToken(token);\n\n            if (scriptHandler && this.pendingScript) {\n                break;\n            }\n        }\n    }\n\n    runParsingLoopForCurrentChunk(writeCallback, scriptHandler) {\n        this._runParsingLoop(scriptHandler);\n\n        if (scriptHandler && this.pendingScript) {\n            const script = this.pendingScript;\n\n            this.pendingScript = null;\n\n            scriptHandler(script);\n\n            return;\n        }\n\n        if (writeCallback) {\n            writeCallback();\n        }\n    }\n\n    //Text parsing\n    _setupTokenizerCDATAMode() {\n        const current = this._getAdjustedCurrentElement();\n\n        this.tokenizer.allowCDATA =\n            current &&\n            current !== this.document &&\n            this.treeAdapter.getNamespaceURI(current) !== NS.HTML &&\n            !this._isIntegrationPoint(current);\n    }\n\n    _switchToTextParsing(currentToken, nextTokenizerState) {\n        this._insertElement(currentToken, NS.HTML);\n        this.tokenizer.state = nextTokenizerState;\n        this.originalInsertionMode = this.insertionMode;\n        this.insertionMode = TEXT_MODE;\n    }\n\n    switchToPlaintextParsing() {\n        this.insertionMode = TEXT_MODE;\n        this.originalInsertionMode = IN_BODY_MODE;\n        this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;\n    }\n\n    //Fragment parsing\n    _getAdjustedCurrentElement() {\n        return this.openElements.stackTop === 0 && this.fragmentContext\n            ? this.fragmentContext\n            : this.openElements.current;\n    }\n\n    _findFormInFragmentContext() {\n        let node = this.fragmentContext;\n\n        do {\n            if (this.treeAdapter.getTagName(node) === $.FORM) {\n                this.formElement = node;\n                break;\n            }\n\n            node = this.treeAdapter.getParentNode(node);\n        } while (node);\n    }\n\n    _initTokenizerForFragmentParsing() {\n        if (this.treeAdapter.getNamespaceURI(this.fragmentContext) === NS.HTML) {\n            const tn = this.treeAdapter.getTagName(this.fragmentContext);\n\n            if (tn === $.TITLE || tn === $.TEXTAREA) {\n                this.tokenizer.state = Tokenizer.MODE.RCDATA;\n            } else if (\n                tn === $.STYLE ||\n                tn === $.XMP ||\n                tn === $.IFRAME ||\n                tn === $.NOEMBED ||\n                tn === $.NOFRAMES ||\n                tn === $.NOSCRIPT\n            ) {\n                this.tokenizer.state = Tokenizer.MODE.RAWTEXT;\n            } else if (tn === $.SCRIPT) {\n                this.tokenizer.state = Tokenizer.MODE.SCRIPT_DATA;\n            } else if (tn === $.PLAINTEXT) {\n                this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;\n            }\n        }\n    }\n\n    //Tree mutation\n    _setDocumentType(token) {\n        const name = token.name || '';\n        const publicId = token.publicId || '';\n        const systemId = token.systemId || '';\n\n        this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);\n    }\n\n    _attachElementToTree(element) {\n        if (this._shouldFosterParentOnInsertion()) {\n            this._fosterParentElement(element);\n        } else {\n            const parent = this.openElements.currentTmplContent || this.openElements.current;\n\n            this.treeAdapter.appendChild(parent, element);\n        }\n    }\n\n    _appendElement(token, namespaceURI) {\n        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);\n\n        this._attachElementToTree(element);\n    }\n\n    _insertElement(token, namespaceURI) {\n        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);\n\n        this._attachElementToTree(element);\n        this.openElements.push(element);\n    }\n\n    _insertFakeElement(tagName) {\n        const element = this.treeAdapter.createElement(tagName, NS.HTML, []);\n\n        this._attachElementToTree(element);\n        this.openElements.push(element);\n    }\n\n    _insertTemplate(token) {\n        const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);\n        const content = this.treeAdapter.createDocumentFragment();\n\n        this.treeAdapter.setTemplateContent(tmpl, content);\n        this._attachElementToTree(tmpl);\n        this.openElements.push(tmpl);\n    }\n\n    _insertFakeRootElement() {\n        const element = this.treeAdapter.createElement($.HTML, NS.HTML, []);\n\n        this.treeAdapter.appendChild(this.openElements.current, element);\n        this.openElements.push(element);\n    }\n\n    _appendCommentNode(token, parent) {\n        const commentNode = this.treeAdapter.createCommentNode(token.data);\n\n        this.treeAdapter.appendChild(parent, commentNode);\n    }\n\n    _insertCharacters(token) {\n        if (this._shouldFosterParentOnInsertion()) {\n            this._fosterParentText(token.chars);\n        } else {\n            const parent = this.openElements.currentTmplContent || this.openElements.current;\n\n            this.treeAdapter.insertText(parent, token.chars);\n        }\n    }\n\n    _adoptNodes(donor, recipient) {\n        for (let child = this.treeAdapter.getFirstChild(donor); child; child = this.treeAdapter.getFirstChild(donor)) {\n            this.treeAdapter.detachNode(child);\n            this.treeAdapter.appendChild(recipient, child);\n        }\n    }\n\n    //Token processing\n    _shouldProcessTokenInForeignContent(token) {\n        const current = this._getAdjustedCurrentElement();\n\n        if (!current || current === this.document) {\n            return false;\n        }\n\n        const ns = this.treeAdapter.getNamespaceURI(current);\n\n        if (ns === NS.HTML) {\n            return false;\n        }\n\n        if (\n            this.treeAdapter.getTagName(current) === $.ANNOTATION_XML &&\n            ns === NS.MATHML &&\n            token.type === Tokenizer.START_TAG_TOKEN &&\n            token.tagName === $.SVG\n        ) {\n            return false;\n        }\n\n        const isCharacterToken =\n            token.type === Tokenizer.CHARACTER_TOKEN ||\n            token.type === Tokenizer.NULL_CHARACTER_TOKEN ||\n            token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN;\n\n        const isMathMLTextStartTag =\n            token.type === Tokenizer.START_TAG_TOKEN && token.tagName !== $.MGLYPH && token.tagName !== $.MALIGNMARK;\n\n        if ((isMathMLTextStartTag || isCharacterToken) && this._isIntegrationPoint(current, NS.MATHML)) {\n            return false;\n        }\n\n        if (\n            (token.type === Tokenizer.START_TAG_TOKEN || isCharacterToken) &&\n            this._isIntegrationPoint(current, NS.HTML)\n        ) {\n            return false;\n        }\n\n        return token.type !== Tokenizer.EOF_TOKEN;\n    }\n\n    _processToken(token) {\n        TOKEN_HANDLERS[this.insertionMode][token.type](this, token);\n    }\n\n    _processTokenInBodyMode(token) {\n        TOKEN_HANDLERS[IN_BODY_MODE][token.type](this, token);\n    }\n\n    _processTokenInForeignContent(token) {\n        if (token.type === Tokenizer.CHARACTER_TOKEN) {\n            characterInForeignContent(this, token);\n        } else if (token.type === Tokenizer.NULL_CHARACTER_TOKEN) {\n            nullCharacterInForeignContent(this, token);\n        } else if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN) {\n            insertCharacters(this, token);\n        } else if (token.type === Tokenizer.COMMENT_TOKEN) {\n            appendComment(this, token);\n        } else if (token.type === Tokenizer.START_TAG_TOKEN) {\n            startTagInForeignContent(this, token);\n        } else if (token.type === Tokenizer.END_TAG_TOKEN) {\n            endTagInForeignContent(this, token);\n        }\n    }\n\n    _processInputToken(token) {\n        if (this._shouldProcessTokenInForeignContent(token)) {\n            this._processTokenInForeignContent(token);\n        } else {\n            this._processToken(token);\n        }\n\n        if (token.type === Tokenizer.START_TAG_TOKEN && token.selfClosing && !token.ackSelfClosing) {\n            this._err(ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);\n        }\n    }\n\n    //Integration points\n    _isIntegrationPoint(element, foreignNS) {\n        const tn = this.treeAdapter.getTagName(element);\n        const ns = this.treeAdapter.getNamespaceURI(element);\n        const attrs = this.treeAdapter.getAttrList(element);\n\n        return foreignContent.isIntegrationPoint(tn, ns, attrs, foreignNS);\n    }\n\n    //Active formatting elements reconstruction\n    _reconstructActiveFormattingElements() {\n        const listLength = this.activeFormattingElements.length;\n\n        if (listLength) {\n            let unopenIdx = listLength;\n            let entry = null;\n\n            do {\n                unopenIdx--;\n                entry = this.activeFormattingElements.entries[unopenIdx];\n\n                if (entry.type === FormattingElementList.MARKER_ENTRY || this.openElements.contains(entry.element)) {\n                    unopenIdx++;\n                    break;\n                }\n            } while (unopenIdx > 0);\n\n            for (let i = unopenIdx; i < listLength; i++) {\n                entry = this.activeFormattingElements.entries[i];\n                this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));\n                entry.element = this.openElements.current;\n            }\n        }\n    }\n\n    //Close elements\n    _closeTableCell() {\n        this.openElements.generateImpliedEndTags();\n        this.openElements.popUntilTableCellPopped();\n        this.activeFormattingElements.clearToLastMarker();\n        this.insertionMode = IN_ROW_MODE;\n    }\n\n    _closePElement() {\n        this.openElements.generateImpliedEndTagsWithExclusion($.P);\n        this.openElements.popUntilTagNamePopped($.P);\n    }\n\n    //Insertion modes\n    _resetInsertionMode() {\n        for (let i = this.openElements.stackTop, last = false; i >= 0; i--) {\n            let element = this.openElements.items[i];\n\n            if (i === 0) {\n                last = true;\n\n                if (this.fragmentContext) {\n                    element = this.fragmentContext;\n                }\n            }\n\n            const tn = this.treeAdapter.getTagName(element);\n            const newInsertionMode = INSERTION_MODE_RESET_MAP[tn];\n\n            if (newInsertionMode) {\n                this.insertionMode = newInsertionMode;\n                break;\n            } else if (!last && (tn === $.TD || tn === $.TH)) {\n                this.insertionMode = IN_CELL_MODE;\n                break;\n            } else if (!last && tn === $.HEAD) {\n                this.insertionMode = IN_HEAD_MODE;\n                break;\n            } else if (tn === $.SELECT) {\n                this._resetInsertionModeForSelect(i);\n                break;\n            } else if (tn === $.TEMPLATE) {\n                this.insertionMode = this.currentTmplInsertionMode;\n                break;\n            } else if (tn === $.HTML) {\n                this.insertionMode = this.headElement ? AFTER_HEAD_MODE : BEFORE_HEAD_MODE;\n                break;\n            } else if (last) {\n                this.insertionMode = IN_BODY_MODE;\n                break;\n            }\n        }\n    }\n\n    _resetInsertionModeForSelect(selectIdx) {\n        if (selectIdx > 0) {\n            for (let i = selectIdx - 1; i > 0; i--) {\n                const ancestor = this.openElements.items[i];\n                const tn = this.treeAdapter.getTagName(ancestor);\n\n                if (tn === $.TEMPLATE) {\n                    break;\n                } else if (tn === $.TABLE) {\n                    this.insertionMode = IN_SELECT_IN_TABLE_MODE;\n                    return;\n                }\n            }\n        }\n\n        this.insertionMode = IN_SELECT_MODE;\n    }\n\n    _pushTmplInsertionMode(mode) {\n        this.tmplInsertionModeStack.push(mode);\n        this.tmplInsertionModeStackTop++;\n        this.currentTmplInsertionMode = mode;\n    }\n\n    _popTmplInsertionMode() {\n        this.tmplInsertionModeStack.pop();\n        this.tmplInsertionModeStackTop--;\n        this.currentTmplInsertionMode = this.tmplInsertionModeStack[this.tmplInsertionModeStackTop];\n    }\n\n    //Foster parenting\n    _isElementCausesFosterParenting(element) {\n        const tn = this.treeAdapter.getTagName(element);\n\n        return tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR;\n    }\n\n    _shouldFosterParentOnInsertion() {\n        return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.current);\n    }\n\n    _findFosterParentingLocation() {\n        const location = {\n            parent: null,\n            beforeElement: null\n        };\n\n        for (let i = this.openElements.stackTop; i >= 0; i--) {\n            const openElement = this.openElements.items[i];\n            const tn = this.treeAdapter.getTagName(openElement);\n            const ns = this.treeAdapter.getNamespaceURI(openElement);\n\n            if (tn === $.TEMPLATE && ns === NS.HTML) {\n                location.parent = this.treeAdapter.getTemplateContent(openElement);\n                break;\n            } else if (tn === $.TABLE) {\n                location.parent = this.treeAdapter.getParentNode(openElement);\n\n                if (location.parent) {\n                    location.beforeElement = openElement;\n                } else {\n                    location.parent = this.openElements.items[i - 1];\n                }\n\n                break;\n            }\n        }\n\n        if (!location.parent) {\n            location.parent = this.openElements.items[0];\n        }\n\n        return location;\n    }\n\n    _fosterParentElement(element) {\n        const location = this._findFosterParentingLocation();\n\n        if (location.beforeElement) {\n            this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);\n        } else {\n            this.treeAdapter.appendChild(location.parent, element);\n        }\n    }\n\n    _fosterParentText(chars) {\n        const location = this._findFosterParentingLocation();\n\n        if (location.beforeElement) {\n            this.treeAdapter.insertTextBefore(location.parent, chars, location.beforeElement);\n        } else {\n            this.treeAdapter.insertText(location.parent, chars);\n        }\n    }\n\n    //Special elements\n    _isSpecialElement(element) {\n        const tn = this.treeAdapter.getTagName(element);\n        const ns = this.treeAdapter.getNamespaceURI(element);\n\n        return HTML.SPECIAL_ELEMENTS[ns][tn];\n    }\n}\n\nmodule.exports = Parser;\n\n//Adoption agency algorithm\n//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency)\n//------------------------------------------------------------------\n\n//Steps 5-8 of the algorithm\nfunction aaObtainFormattingElementEntry(p, token) {\n    let formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);\n\n    if (formattingElementEntry) {\n        if (!p.openElements.contains(formattingElementEntry.element)) {\n            p.activeFormattingElements.removeEntry(formattingElementEntry);\n            formattingElementEntry = null;\n        } else if (!p.openElements.hasInScope(token.tagName)) {\n            formattingElementEntry = null;\n        }\n    } else {\n        genericEndTagInBody(p, token);\n    }\n\n    return formattingElementEntry;\n}\n\n//Steps 9 and 10 of the algorithm\nfunction aaObtainFurthestBlock(p, formattingElementEntry) {\n    let furthestBlock = null;\n\n    for (let i = p.openElements.stackTop; i >= 0; i--) {\n        const element = p.openElements.items[i];\n\n        if (element === formattingElementEntry.element) {\n            break;\n        }\n\n        if (p._isSpecialElement(element)) {\n            furthestBlock = element;\n        }\n    }\n\n    if (!furthestBlock) {\n        p.openElements.popUntilElementPopped(formattingElementEntry.element);\n        p.activeFormattingElements.removeEntry(formattingElementEntry);\n    }\n\n    return furthestBlock;\n}\n\n//Step 13 of the algorithm\nfunction aaInnerLoop(p, furthestBlock, formattingElement) {\n    let lastElement = furthestBlock;\n    let nextElement = p.openElements.getCommonAncestor(furthestBlock);\n\n    for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {\n        //NOTE: store next element for the next loop iteration (it may be deleted from the stack by step 9.5)\n        nextElement = p.openElements.getCommonAncestor(element);\n\n        const elementEntry = p.activeFormattingElements.getElementEntry(element);\n        const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;\n        const shouldRemoveFromOpenElements = !elementEntry || counterOverflow;\n\n        if (shouldRemoveFromOpenElements) {\n            if (counterOverflow) {\n                p.activeFormattingElements.removeEntry(elementEntry);\n            }\n\n            p.openElements.remove(element);\n        } else {\n            element = aaRecreateElementFromEntry(p, elementEntry);\n\n            if (lastElement === furthestBlock) {\n                p.activeFormattingElements.bookmark = elementEntry;\n            }\n\n            p.treeAdapter.detachNode(lastElement);\n            p.treeAdapter.appendChild(element, lastElement);\n            lastElement = element;\n        }\n    }\n\n    return lastElement;\n}\n\n//Step 13.7 of the algorithm\nfunction aaRecreateElementFromEntry(p, elementEntry) {\n    const ns = p.treeAdapter.getNamespaceURI(elementEntry.element);\n    const newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);\n\n    p.openElements.replace(elementEntry.element, newElement);\n    elementEntry.element = newElement;\n\n    return newElement;\n}\n\n//Step 14 of the algorithm\nfunction aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {\n    if (p._isElementCausesFosterParenting(commonAncestor)) {\n        p._fosterParentElement(lastElement);\n    } else {\n        const tn = p.treeAdapter.getTagName(commonAncestor);\n        const ns = p.treeAdapter.getNamespaceURI(commonAncestor);\n\n        if (tn === $.TEMPLATE && ns === NS.HTML) {\n            commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);\n        }\n\n        p.treeAdapter.appendChild(commonAncestor, lastElement);\n    }\n}\n\n//Steps 15-19 of the algorithm\nfunction aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {\n    const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);\n    const token = formattingElementEntry.token;\n    const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);\n\n    p._adoptNodes(furthestBlock, newElement);\n    p.treeAdapter.appendChild(furthestBlock, newElement);\n\n    p.activeFormattingElements.insertElementAfterBookmark(newElement, formattingElementEntry.token);\n    p.activeFormattingElements.removeEntry(formattingElementEntry);\n\n    p.openElements.remove(formattingElementEntry.element);\n    p.openElements.insertAfter(furthestBlock, newElement);\n}\n\n//Algorithm entry point\nfunction callAdoptionAgency(p, token) {\n    let formattingElementEntry;\n\n    for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {\n        formattingElementEntry = aaObtainFormattingElementEntry(p, token, formattingElementEntry);\n\n        if (!formattingElementEntry) {\n            break;\n        }\n\n        const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);\n\n        if (!furthestBlock) {\n            break;\n        }\n\n        p.activeFormattingElements.bookmark = formattingElementEntry;\n\n        const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);\n        const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);\n\n        p.treeAdapter.detachNode(lastElement);\n        aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);\n        aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry);\n    }\n}\n\n//Generic token handlers\n//------------------------------------------------------------------\nfunction ignoreToken() {\n    //NOTE: do nothing =)\n}\n\nfunction misplacedDoctype(p) {\n    p._err(ERR.misplacedDoctype);\n}\n\nfunction appendComment(p, token) {\n    p._appendCommentNode(token, p.openElements.currentTmplContent || p.openElements.current);\n}\n\nfunction appendCommentToRootHtmlElement(p, token) {\n    p._appendCommentNode(token, p.openElements.items[0]);\n}\n\nfunction appendCommentToDocument(p, token) {\n    p._appendCommentNode(token, p.document);\n}\n\nfunction insertCharacters(p, token) {\n    p._insertCharacters(token);\n}\n\nfunction stopParsing(p) {\n    p.stopped = true;\n}\n\n// The \"initial\" insertion mode\n//------------------------------------------------------------------\nfunction doctypeInInitialMode(p, token) {\n    p._setDocumentType(token);\n\n    const mode = token.forceQuirks ? HTML.DOCUMENT_MODE.QUIRKS : doctype.getDocumentMode(token);\n\n    if (!doctype.isConforming(token)) {\n        p._err(ERR.nonConformingDoctype);\n    }\n\n    p.treeAdapter.setDocumentMode(p.document, mode);\n\n    p.insertionMode = BEFORE_HTML_MODE;\n}\n\nfunction tokenInInitialMode(p, token) {\n    p._err(ERR.missingDoctype, { beforeToken: true });\n    p.treeAdapter.setDocumentMode(p.document, HTML.DOCUMENT_MODE.QUIRKS);\n    p.insertionMode = BEFORE_HTML_MODE;\n    p._processToken(token);\n}\n\n// The \"before html\" insertion mode\n//------------------------------------------------------------------\nfunction startTagBeforeHtml(p, token) {\n    if (token.tagName === $.HTML) {\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = BEFORE_HEAD_MODE;\n    } else {\n        tokenBeforeHtml(p, token);\n    }\n}\n\nfunction endTagBeforeHtml(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML || tn === $.HEAD || tn === $.BODY || tn === $.BR) {\n        tokenBeforeHtml(p, token);\n    }\n}\n\nfunction tokenBeforeHtml(p, token) {\n    p._insertFakeRootElement();\n    p.insertionMode = BEFORE_HEAD_MODE;\n    p._processToken(token);\n}\n\n// The \"before head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagBeforeHead(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (tn === $.HEAD) {\n        p._insertElement(token, NS.HTML);\n        p.headElement = p.openElements.current;\n        p.insertionMode = IN_HEAD_MODE;\n    } else {\n        tokenBeforeHead(p, token);\n    }\n}\n\nfunction endTagBeforeHead(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HEAD || tn === $.BODY || tn === $.HTML || tn === $.BR) {\n        tokenBeforeHead(p, token);\n    } else {\n        p._err(ERR.endTagWithoutMatchingOpenElement);\n    }\n}\n\nfunction tokenBeforeHead(p, token) {\n    p._insertFakeElement($.HEAD);\n    p.headElement = p.openElements.current;\n    p.insertionMode = IN_HEAD_MODE;\n    p._processToken(token);\n}\n\n// The \"in head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInHead(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (tn === $.BASE || tn === $.BASEFONT || tn === $.BGSOUND || tn === $.LINK || tn === $.META) {\n        p._appendElement(token, NS.HTML);\n        token.ackSelfClosing = true;\n    } else if (tn === $.TITLE) {\n        p._switchToTextParsing(token, Tokenizer.MODE.RCDATA);\n    } else if (tn === $.NOSCRIPT) {\n        if (p.options.scriptingEnabled) {\n            p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);\n        } else {\n            p._insertElement(token, NS.HTML);\n            p.insertionMode = IN_HEAD_NO_SCRIPT_MODE;\n        }\n    } else if (tn === $.NOFRAMES || tn === $.STYLE) {\n        p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);\n    } else if (tn === $.SCRIPT) {\n        p._switchToTextParsing(token, Tokenizer.MODE.SCRIPT_DATA);\n    } else if (tn === $.TEMPLATE) {\n        p._insertTemplate(token, NS.HTML);\n        p.activeFormattingElements.insertMarker();\n        p.framesetOk = false;\n        p.insertionMode = IN_TEMPLATE_MODE;\n        p._pushTmplInsertionMode(IN_TEMPLATE_MODE);\n    } else if (tn === $.HEAD) {\n        p._err(ERR.misplacedStartTagForHeadElement);\n    } else {\n        tokenInHead(p, token);\n    }\n}\n\nfunction endTagInHead(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HEAD) {\n        p.openElements.pop();\n        p.insertionMode = AFTER_HEAD_MODE;\n    } else if (tn === $.BODY || tn === $.BR || tn === $.HTML) {\n        tokenInHead(p, token);\n    } else if (tn === $.TEMPLATE) {\n        if (p.openElements.tmplCount > 0) {\n            p.openElements.generateImpliedEndTagsThoroughly();\n\n            if (p.openElements.currentTagName !== $.TEMPLATE) {\n                p._err(ERR.closingOfElementWithOpenChildElements);\n            }\n\n            p.openElements.popUntilTagNamePopped($.TEMPLATE);\n            p.activeFormattingElements.clearToLastMarker();\n            p._popTmplInsertionMode();\n            p._resetInsertionMode();\n        } else {\n            p._err(ERR.endTagWithoutMatchingOpenElement);\n        }\n    } else {\n        p._err(ERR.endTagWithoutMatchingOpenElement);\n    }\n}\n\nfunction tokenInHead(p, token) {\n    p.openElements.pop();\n    p.insertionMode = AFTER_HEAD_MODE;\n    p._processToken(token);\n}\n\n// The \"in head no script\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInHeadNoScript(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (\n        tn === $.BASEFONT ||\n        tn === $.BGSOUND ||\n        tn === $.HEAD ||\n        tn === $.LINK ||\n        tn === $.META ||\n        tn === $.NOFRAMES ||\n        tn === $.STYLE\n    ) {\n        startTagInHead(p, token);\n    } else if (tn === $.NOSCRIPT) {\n        p._err(ERR.nestedNoscriptInHead);\n    } else {\n        tokenInHeadNoScript(p, token);\n    }\n}\n\nfunction endTagInHeadNoScript(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.NOSCRIPT) {\n        p.openElements.pop();\n        p.insertionMode = IN_HEAD_MODE;\n    } else if (tn === $.BR) {\n        tokenInHeadNoScript(p, token);\n    } else {\n        p._err(ERR.endTagWithoutMatchingOpenElement);\n    }\n}\n\nfunction tokenInHeadNoScript(p, token) {\n    const errCode =\n        token.type === Tokenizer.EOF_TOKEN ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead;\n\n    p._err(errCode);\n    p.openElements.pop();\n    p.insertionMode = IN_HEAD_MODE;\n    p._processToken(token);\n}\n\n// The \"after head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterHead(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (tn === $.BODY) {\n        p._insertElement(token, NS.HTML);\n        p.framesetOk = false;\n        p.insertionMode = IN_BODY_MODE;\n    } else if (tn === $.FRAMESET) {\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = IN_FRAMESET_MODE;\n    } else if (\n        tn === $.BASE ||\n        tn === $.BASEFONT ||\n        tn === $.BGSOUND ||\n        tn === $.LINK ||\n        tn === $.META ||\n        tn === $.NOFRAMES ||\n        tn === $.SCRIPT ||\n        tn === $.STYLE ||\n        tn === $.TEMPLATE ||\n        tn === $.TITLE\n    ) {\n        p._err(ERR.abandonedHeadElementChild);\n        p.openElements.push(p.headElement);\n        startTagInHead(p, token);\n        p.openElements.remove(p.headElement);\n    } else if (tn === $.HEAD) {\n        p._err(ERR.misplacedStartTagForHeadElement);\n    } else {\n        tokenAfterHead(p, token);\n    }\n}\n\nfunction endTagAfterHead(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.BODY || tn === $.HTML || tn === $.BR) {\n        tokenAfterHead(p, token);\n    } else if (tn === $.TEMPLATE) {\n        endTagInHead(p, token);\n    } else {\n        p._err(ERR.endTagWithoutMatchingOpenElement);\n    }\n}\n\nfunction tokenAfterHead(p, token) {\n    p._insertFakeElement($.BODY);\n    p.insertionMode = IN_BODY_MODE;\n    p._processToken(token);\n}\n\n// The \"in body\" insertion mode\n//------------------------------------------------------------------\nfunction whitespaceCharacterInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertCharacters(token);\n}\n\nfunction characterInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertCharacters(token);\n    p.framesetOk = false;\n}\n\nfunction htmlStartTagInBody(p, token) {\n    if (p.openElements.tmplCount === 0) {\n        p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);\n    }\n}\n\nfunction bodyStartTagInBody(p, token) {\n    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();\n\n    if (bodyElement && p.openElements.tmplCount === 0) {\n        p.framesetOk = false;\n        p.treeAdapter.adoptAttributes(bodyElement, token.attrs);\n    }\n}\n\nfunction framesetStartTagInBody(p, token) {\n    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();\n\n    if (p.framesetOk && bodyElement) {\n        p.treeAdapter.detachNode(bodyElement);\n        p.openElements.popAllUpToHtmlElement();\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = IN_FRAMESET_MODE;\n    }\n}\n\nfunction addressStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n\n    p._insertElement(token, NS.HTML);\n}\n\nfunction numberedHeaderStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n\n    const tn = p.openElements.currentTagName;\n\n    if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {\n        p.openElements.pop();\n    }\n\n    p._insertElement(token, NS.HTML);\n}\n\nfunction preStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n\n    p._insertElement(token, NS.HTML);\n    //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move\n    //on to the next one. (Newlines at the start of pre blocks are ignored as an authoring convenience.)\n    p.skipNextNewLine = true;\n    p.framesetOk = false;\n}\n\nfunction formStartTagInBody(p, token) {\n    const inTemplate = p.openElements.tmplCount > 0;\n\n    if (!p.formElement || inTemplate) {\n        if (p.openElements.hasInButtonScope($.P)) {\n            p._closePElement();\n        }\n\n        p._insertElement(token, NS.HTML);\n\n        if (!inTemplate) {\n            p.formElement = p.openElements.current;\n        }\n    }\n}\n\nfunction listItemStartTagInBody(p, token) {\n    p.framesetOk = false;\n\n    const tn = token.tagName;\n\n    for (let i = p.openElements.stackTop; i >= 0; i--) {\n        const element = p.openElements.items[i];\n        const elementTn = p.treeAdapter.getTagName(element);\n        let closeTn = null;\n\n        if (tn === $.LI && elementTn === $.LI) {\n            closeTn = $.LI;\n        } else if ((tn === $.DD || tn === $.DT) && (elementTn === $.DD || elementTn === $.DT)) {\n            closeTn = elementTn;\n        }\n\n        if (closeTn) {\n            p.openElements.generateImpliedEndTagsWithExclusion(closeTn);\n            p.openElements.popUntilTagNamePopped(closeTn);\n            break;\n        }\n\n        if (elementTn !== $.ADDRESS && elementTn !== $.DIV && elementTn !== $.P && p._isSpecialElement(element)) {\n            break;\n        }\n    }\n\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n\n    p._insertElement(token, NS.HTML);\n}\n\nfunction plaintextStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n\n    p._insertElement(token, NS.HTML);\n    p.tokenizer.state = Tokenizer.MODE.PLAINTEXT;\n}\n\nfunction buttonStartTagInBody(p, token) {\n    if (p.openElements.hasInScope($.BUTTON)) {\n        p.openElements.generateImpliedEndTags();\n        p.openElements.popUntilTagNamePopped($.BUTTON);\n    }\n\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.framesetOk = false;\n}\n\nfunction aStartTagInBody(p, token) {\n    const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName($.A);\n\n    if (activeElementEntry) {\n        callAdoptionAgency(p, token);\n        p.openElements.remove(activeElementEntry.element);\n        p.activeFormattingElements.removeEntry(activeElementEntry);\n    }\n\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\n\nfunction bStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\n\nfunction nobrStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n\n    if (p.openElements.hasInScope($.NOBR)) {\n        callAdoptionAgency(p, token);\n        p._reconstructActiveFormattingElements();\n    }\n\n    p._insertElement(token, NS.HTML);\n    p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\n\nfunction appletStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.activeFormattingElements.insertMarker();\n    p.framesetOk = false;\n}\n\nfunction tableStartTagInBody(p, token) {\n    if (\n        p.treeAdapter.getDocumentMode(p.document) !== HTML.DOCUMENT_MODE.QUIRKS &&\n        p.openElements.hasInButtonScope($.P)\n    ) {\n        p._closePElement();\n    }\n\n    p._insertElement(token, NS.HTML);\n    p.framesetOk = false;\n    p.insertionMode = IN_TABLE_MODE;\n}\n\nfunction areaStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._appendElement(token, NS.HTML);\n    p.framesetOk = false;\n    token.ackSelfClosing = true;\n}\n\nfunction inputStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._appendElement(token, NS.HTML);\n\n    const inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);\n\n    if (!inputType || inputType.toLowerCase() !== HIDDEN_INPUT_TYPE) {\n        p.framesetOk = false;\n    }\n\n    token.ackSelfClosing = true;\n}\n\nfunction paramStartTagInBody(p, token) {\n    p._appendElement(token, NS.HTML);\n    token.ackSelfClosing = true;\n}\n\nfunction hrStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n\n    p._appendElement(token, NS.HTML);\n    p.framesetOk = false;\n    token.ackSelfClosing = true;\n}\n\nfunction imageStartTagInBody(p, token) {\n    token.tagName = $.IMG;\n    areaStartTagInBody(p, token);\n}\n\nfunction textareaStartTagInBody(p, token) {\n    p._insertElement(token, NS.HTML);\n    //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move\n    //on to the next one. (Newlines at the start of textarea elements are ignored as an authoring convenience.)\n    p.skipNextNewLine = true;\n    p.tokenizer.state = Tokenizer.MODE.RCDATA;\n    p.originalInsertionMode = p.insertionMode;\n    p.framesetOk = false;\n    p.insertionMode = TEXT_MODE;\n}\n\nfunction xmpStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n\n    p._reconstructActiveFormattingElements();\n    p.framesetOk = false;\n    p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);\n}\n\nfunction iframeStartTagInBody(p, token) {\n    p.framesetOk = false;\n    p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);\n}\n\n//NOTE: here we assume that we always act as an user agent with enabled plugins, so we parse\n//<noembed> as a rawtext.\nfunction noembedStartTagInBody(p, token) {\n    p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);\n}\n\nfunction selectStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.framesetOk = false;\n\n    if (\n        p.insertionMode === IN_TABLE_MODE ||\n        p.insertionMode === IN_CAPTION_MODE ||\n        p.insertionMode === IN_TABLE_BODY_MODE ||\n        p.insertionMode === IN_ROW_MODE ||\n        p.insertionMode === IN_CELL_MODE\n    ) {\n        p.insertionMode = IN_SELECT_IN_TABLE_MODE;\n    } else {\n        p.insertionMode = IN_SELECT_MODE;\n    }\n}\n\nfunction optgroupStartTagInBody(p, token) {\n    if (p.openElements.currentTagName === $.OPTION) {\n        p.openElements.pop();\n    }\n\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n}\n\nfunction rbStartTagInBody(p, token) {\n    if (p.openElements.hasInScope($.RUBY)) {\n        p.openElements.generateImpliedEndTags();\n    }\n\n    p._insertElement(token, NS.HTML);\n}\n\nfunction rtStartTagInBody(p, token) {\n    if (p.openElements.hasInScope($.RUBY)) {\n        p.openElements.generateImpliedEndTagsWithExclusion($.RTC);\n    }\n\n    p._insertElement(token, NS.HTML);\n}\n\nfunction menuStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n\n    p._insertElement(token, NS.HTML);\n}\n\nfunction mathStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n\n    foreignContent.adjustTokenMathMLAttrs(token);\n    foreignContent.adjustTokenXMLAttrs(token);\n\n    if (token.selfClosing) {\n        p._appendElement(token, NS.MATHML);\n    } else {\n        p._insertElement(token, NS.MATHML);\n    }\n\n    token.ackSelfClosing = true;\n}\n\nfunction svgStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n\n    foreignContent.adjustTokenSVGAttrs(token);\n    foreignContent.adjustTokenXMLAttrs(token);\n\n    if (token.selfClosing) {\n        p._appendElement(token, NS.SVG);\n    } else {\n        p._insertElement(token, NS.SVG);\n    }\n\n    token.ackSelfClosing = true;\n}\n\nfunction genericStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n}\n\n//OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.\n//It's faster than using dictionary.\nfunction startTagInBody(p, token) {\n    const tn = token.tagName;\n\n    switch (tn.length) {\n        case 1:\n            if (tn === $.I || tn === $.S || tn === $.B || tn === $.U) {\n                bStartTagInBody(p, token);\n            } else if (tn === $.P) {\n                addressStartTagInBody(p, token);\n            } else if (tn === $.A) {\n                aStartTagInBody(p, token);\n            } else {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 2:\n            if (tn === $.DL || tn === $.OL || tn === $.UL) {\n                addressStartTagInBody(p, token);\n            } else if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {\n                numberedHeaderStartTagInBody(p, token);\n            } else if (tn === $.LI || tn === $.DD || tn === $.DT) {\n                listItemStartTagInBody(p, token);\n            } else if (tn === $.EM || tn === $.TT) {\n                bStartTagInBody(p, token);\n            } else if (tn === $.BR) {\n                areaStartTagInBody(p, token);\n            } else if (tn === $.HR) {\n                hrStartTagInBody(p, token);\n            } else if (tn === $.RB) {\n                rbStartTagInBody(p, token);\n            } else if (tn === $.RT || tn === $.RP) {\n                rtStartTagInBody(p, token);\n            } else if (tn !== $.TH && tn !== $.TD && tn !== $.TR) {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 3:\n            if (tn === $.DIV || tn === $.DIR || tn === $.NAV) {\n                addressStartTagInBody(p, token);\n            } else if (tn === $.PRE) {\n                preStartTagInBody(p, token);\n            } else if (tn === $.BIG) {\n                bStartTagInBody(p, token);\n            } else if (tn === $.IMG || tn === $.WBR) {\n                areaStartTagInBody(p, token);\n            } else if (tn === $.XMP) {\n                xmpStartTagInBody(p, token);\n            } else if (tn === $.SVG) {\n                svgStartTagInBody(p, token);\n            } else if (tn === $.RTC) {\n                rbStartTagInBody(p, token);\n            } else if (tn !== $.COL) {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 4:\n            if (tn === $.HTML) {\n                htmlStartTagInBody(p, token);\n            } else if (tn === $.BASE || tn === $.LINK || tn === $.META) {\n                startTagInHead(p, token);\n            } else if (tn === $.BODY) {\n                bodyStartTagInBody(p, token);\n            } else if (tn === $.MAIN || tn === $.MENU) {\n                addressStartTagInBody(p, token);\n            } else if (tn === $.FORM) {\n                formStartTagInBody(p, token);\n            } else if (tn === $.CODE || tn === $.FONT) {\n                bStartTagInBody(p, token);\n            } else if (tn === $.NOBR) {\n                nobrStartTagInBody(p, token);\n            } else if (tn === $.AREA) {\n                areaStartTagInBody(p, token);\n            } else if (tn === $.MATH) {\n                mathStartTagInBody(p, token);\n            } else if (tn === $.MENU) {\n                menuStartTagInBody(p, token);\n            } else if (tn !== $.HEAD) {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 5:\n            if (tn === $.STYLE || tn === $.TITLE) {\n                startTagInHead(p, token);\n            } else if (tn === $.ASIDE) {\n                addressStartTagInBody(p, token);\n            } else if (tn === $.SMALL) {\n                bStartTagInBody(p, token);\n            } else if (tn === $.TABLE) {\n                tableStartTagInBody(p, token);\n            } else if (tn === $.EMBED) {\n                areaStartTagInBody(p, token);\n            } else if (tn === $.INPUT) {\n                inputStartTagInBody(p, token);\n            } else if (tn === $.PARAM || tn === $.TRACK) {\n                paramStartTagInBody(p, token);\n            } else if (tn === $.IMAGE) {\n                imageStartTagInBody(p, token);\n            } else if (tn !== $.FRAME && tn !== $.TBODY && tn !== $.TFOOT && tn !== $.THEAD) {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 6:\n            if (tn === $.SCRIPT) {\n                startTagInHead(p, token);\n            } else if (\n                tn === $.CENTER ||\n                tn === $.FIGURE ||\n                tn === $.FOOTER ||\n                tn === $.HEADER ||\n                tn === $.HGROUP ||\n                tn === $.DIALOG\n            ) {\n                addressStartTagInBody(p, token);\n            } else if (tn === $.BUTTON) {\n                buttonStartTagInBody(p, token);\n            } else if (tn === $.STRIKE || tn === $.STRONG) {\n                bStartTagInBody(p, token);\n            } else if (tn === $.APPLET || tn === $.OBJECT) {\n                appletStartTagInBody(p, token);\n            } else if (tn === $.KEYGEN) {\n                areaStartTagInBody(p, token);\n            } else if (tn === $.SOURCE) {\n                paramStartTagInBody(p, token);\n            } else if (tn === $.IFRAME) {\n                iframeStartTagInBody(p, token);\n            } else if (tn === $.SELECT) {\n                selectStartTagInBody(p, token);\n            } else if (tn === $.OPTION) {\n                optgroupStartTagInBody(p, token);\n            } else {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 7:\n            if (tn === $.BGSOUND) {\n                startTagInHead(p, token);\n            } else if (\n                tn === $.DETAILS ||\n                tn === $.ADDRESS ||\n                tn === $.ARTICLE ||\n                tn === $.SECTION ||\n                tn === $.SUMMARY\n            ) {\n                addressStartTagInBody(p, token);\n            } else if (tn === $.LISTING) {\n                preStartTagInBody(p, token);\n            } else if (tn === $.MARQUEE) {\n                appletStartTagInBody(p, token);\n            } else if (tn === $.NOEMBED) {\n                noembedStartTagInBody(p, token);\n            } else if (tn !== $.CAPTION) {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 8:\n            if (tn === $.BASEFONT) {\n                startTagInHead(p, token);\n            } else if (tn === $.FRAMESET) {\n                framesetStartTagInBody(p, token);\n            } else if (tn === $.FIELDSET) {\n                addressStartTagInBody(p, token);\n            } else if (tn === $.TEXTAREA) {\n                textareaStartTagInBody(p, token);\n            } else if (tn === $.TEMPLATE) {\n                startTagInHead(p, token);\n            } else if (tn === $.NOSCRIPT) {\n                if (p.options.scriptingEnabled) {\n                    noembedStartTagInBody(p, token);\n                } else {\n                    genericStartTagInBody(p, token);\n                }\n            } else if (tn === $.OPTGROUP) {\n                optgroupStartTagInBody(p, token);\n            } else if (tn !== $.COLGROUP) {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 9:\n            if (tn === $.PLAINTEXT) {\n                plaintextStartTagInBody(p, token);\n            } else {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        case 10:\n            if (tn === $.BLOCKQUOTE || tn === $.FIGCAPTION) {\n                addressStartTagInBody(p, token);\n            } else {\n                genericStartTagInBody(p, token);\n            }\n\n            break;\n\n        default:\n            genericStartTagInBody(p, token);\n    }\n}\n\nfunction bodyEndTagInBody(p) {\n    if (p.openElements.hasInScope($.BODY)) {\n        p.insertionMode = AFTER_BODY_MODE;\n    }\n}\n\nfunction htmlEndTagInBody(p, token) {\n    if (p.openElements.hasInScope($.BODY)) {\n        p.insertionMode = AFTER_BODY_MODE;\n        p._processToken(token);\n    }\n}\n\nfunction addressEndTagInBody(p, token) {\n    const tn = token.tagName;\n\n    if (p.openElements.hasInScope(tn)) {\n        p.openElements.generateImpliedEndTags();\n        p.openElements.popUntilTagNamePopped(tn);\n    }\n}\n\nfunction formEndTagInBody(p) {\n    const inTemplate = p.openElements.tmplCount > 0;\n    const formElement = p.formElement;\n\n    if (!inTemplate) {\n        p.formElement = null;\n    }\n\n    if ((formElement || inTemplate) && p.openElements.hasInScope($.FORM)) {\n        p.openElements.generateImpliedEndTags();\n\n        if (inTemplate) {\n            p.openElements.popUntilTagNamePopped($.FORM);\n        } else {\n            p.openElements.remove(formElement);\n        }\n    }\n}\n\nfunction pEndTagInBody(p) {\n    if (!p.openElements.hasInButtonScope($.P)) {\n        p._insertFakeElement($.P);\n    }\n\n    p._closePElement();\n}\n\nfunction liEndTagInBody(p) {\n    if (p.openElements.hasInListItemScope($.LI)) {\n        p.openElements.generateImpliedEndTagsWithExclusion($.LI);\n        p.openElements.popUntilTagNamePopped($.LI);\n    }\n}\n\nfunction ddEndTagInBody(p, token) {\n    const tn = token.tagName;\n\n    if (p.openElements.hasInScope(tn)) {\n        p.openElements.generateImpliedEndTagsWithExclusion(tn);\n        p.openElements.popUntilTagNamePopped(tn);\n    }\n}\n\nfunction numberedHeaderEndTagInBody(p) {\n    if (p.openElements.hasNumberedHeaderInScope()) {\n        p.openElements.generateImpliedEndTags();\n        p.openElements.popUntilNumberedHeaderPopped();\n    }\n}\n\nfunction appletEndTagInBody(p, token) {\n    const tn = token.tagName;\n\n    if (p.openElements.hasInScope(tn)) {\n        p.openElements.generateImpliedEndTags();\n        p.openElements.popUntilTagNamePopped(tn);\n        p.activeFormattingElements.clearToLastMarker();\n    }\n}\n\nfunction brEndTagInBody(p) {\n    p._reconstructActiveFormattingElements();\n    p._insertFakeElement($.BR);\n    p.openElements.pop();\n    p.framesetOk = false;\n}\n\nfunction genericEndTagInBody(p, token) {\n    const tn = token.tagName;\n\n    for (let i = p.openElements.stackTop; i > 0; i--) {\n        const element = p.openElements.items[i];\n\n        if (p.treeAdapter.getTagName(element) === tn) {\n            p.openElements.generateImpliedEndTagsWithExclusion(tn);\n            p.openElements.popUntilElementPopped(element);\n            break;\n        }\n\n        if (p._isSpecialElement(element)) {\n            break;\n        }\n    }\n}\n\n//OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.\n//It's faster than using dictionary.\nfunction endTagInBody(p, token) {\n    const tn = token.tagName;\n\n    switch (tn.length) {\n        case 1:\n            if (tn === $.A || tn === $.B || tn === $.I || tn === $.S || tn === $.U) {\n                callAdoptionAgency(p, token);\n            } else if (tn === $.P) {\n                pEndTagInBody(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        case 2:\n            if (tn === $.DL || tn === $.UL || tn === $.OL) {\n                addressEndTagInBody(p, token);\n            } else if (tn === $.LI) {\n                liEndTagInBody(p, token);\n            } else if (tn === $.DD || tn === $.DT) {\n                ddEndTagInBody(p, token);\n            } else if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {\n                numberedHeaderEndTagInBody(p, token);\n            } else if (tn === $.BR) {\n                brEndTagInBody(p, token);\n            } else if (tn === $.EM || tn === $.TT) {\n                callAdoptionAgency(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        case 3:\n            if (tn === $.BIG) {\n                callAdoptionAgency(p, token);\n            } else if (tn === $.DIR || tn === $.DIV || tn === $.NAV || tn === $.PRE) {\n                addressEndTagInBody(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        case 4:\n            if (tn === $.BODY) {\n                bodyEndTagInBody(p, token);\n            } else if (tn === $.HTML) {\n                htmlEndTagInBody(p, token);\n            } else if (tn === $.FORM) {\n                formEndTagInBody(p, token);\n            } else if (tn === $.CODE || tn === $.FONT || tn === $.NOBR) {\n                callAdoptionAgency(p, token);\n            } else if (tn === $.MAIN || tn === $.MENU) {\n                addressEndTagInBody(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        case 5:\n            if (tn === $.ASIDE) {\n                addressEndTagInBody(p, token);\n            } else if (tn === $.SMALL) {\n                callAdoptionAgency(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        case 6:\n            if (\n                tn === $.CENTER ||\n                tn === $.FIGURE ||\n                tn === $.FOOTER ||\n                tn === $.HEADER ||\n                tn === $.HGROUP ||\n                tn === $.DIALOG\n            ) {\n                addressEndTagInBody(p, token);\n            } else if (tn === $.APPLET || tn === $.OBJECT) {\n                appletEndTagInBody(p, token);\n            } else if (tn === $.STRIKE || tn === $.STRONG) {\n                callAdoptionAgency(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        case 7:\n            if (\n                tn === $.ADDRESS ||\n                tn === $.ARTICLE ||\n                tn === $.DETAILS ||\n                tn === $.SECTION ||\n                tn === $.SUMMARY ||\n                tn === $.LISTING\n            ) {\n                addressEndTagInBody(p, token);\n            } else if (tn === $.MARQUEE) {\n                appletEndTagInBody(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        case 8:\n            if (tn === $.FIELDSET) {\n                addressEndTagInBody(p, token);\n            } else if (tn === $.TEMPLATE) {\n                endTagInHead(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        case 10:\n            if (tn === $.BLOCKQUOTE || tn === $.FIGCAPTION) {\n                addressEndTagInBody(p, token);\n            } else {\n                genericEndTagInBody(p, token);\n            }\n\n            break;\n\n        default:\n            genericEndTagInBody(p, token);\n    }\n}\n\nfunction eofInBody(p, token) {\n    if (p.tmplInsertionModeStackTop > -1) {\n        eofInTemplate(p, token);\n    } else {\n        p.stopped = true;\n    }\n}\n\n// The \"text\" insertion mode\n//------------------------------------------------------------------\nfunction endTagInText(p, token) {\n    if (token.tagName === $.SCRIPT) {\n        p.pendingScript = p.openElements.current;\n    }\n\n    p.openElements.pop();\n    p.insertionMode = p.originalInsertionMode;\n}\n\nfunction eofInText(p, token) {\n    p._err(ERR.eofInElementThatCanContainOnlyText);\n    p.openElements.pop();\n    p.insertionMode = p.originalInsertionMode;\n    p._processToken(token);\n}\n\n// The \"in table\" insertion mode\n//------------------------------------------------------------------\nfunction characterInTable(p, token) {\n    const curTn = p.openElements.currentTagName;\n\n    if (curTn === $.TABLE || curTn === $.TBODY || curTn === $.TFOOT || curTn === $.THEAD || curTn === $.TR) {\n        p.pendingCharacterTokens = [];\n        p.hasNonWhitespacePendingCharacterToken = false;\n        p.originalInsertionMode = p.insertionMode;\n        p.insertionMode = IN_TABLE_TEXT_MODE;\n        p._processToken(token);\n    } else {\n        tokenInTable(p, token);\n    }\n}\n\nfunction captionStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p.activeFormattingElements.insertMarker();\n    p._insertElement(token, NS.HTML);\n    p.insertionMode = IN_CAPTION_MODE;\n}\n\nfunction colgroupStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p._insertElement(token, NS.HTML);\n    p.insertionMode = IN_COLUMN_GROUP_MODE;\n}\n\nfunction colStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p._insertFakeElement($.COLGROUP);\n    p.insertionMode = IN_COLUMN_GROUP_MODE;\n    p._processToken(token);\n}\n\nfunction tbodyStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p._insertElement(token, NS.HTML);\n    p.insertionMode = IN_TABLE_BODY_MODE;\n}\n\nfunction tdStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p._insertFakeElement($.TBODY);\n    p.insertionMode = IN_TABLE_BODY_MODE;\n    p._processToken(token);\n}\n\nfunction tableStartTagInTable(p, token) {\n    if (p.openElements.hasInTableScope($.TABLE)) {\n        p.openElements.popUntilTagNamePopped($.TABLE);\n        p._resetInsertionMode();\n        p._processToken(token);\n    }\n}\n\nfunction inputStartTagInTable(p, token) {\n    const inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);\n\n    if (inputType && inputType.toLowerCase() === HIDDEN_INPUT_TYPE) {\n        p._appendElement(token, NS.HTML);\n    } else {\n        tokenInTable(p, token);\n    }\n\n    token.ackSelfClosing = true;\n}\n\nfunction formStartTagInTable(p, token) {\n    if (!p.formElement && p.openElements.tmplCount === 0) {\n        p._insertElement(token, NS.HTML);\n        p.formElement = p.openElements.current;\n        p.openElements.pop();\n    }\n}\n\nfunction startTagInTable(p, token) {\n    const tn = token.tagName;\n\n    switch (tn.length) {\n        case 2:\n            if (tn === $.TD || tn === $.TH || tn === $.TR) {\n                tdStartTagInTable(p, token);\n            } else {\n                tokenInTable(p, token);\n            }\n\n            break;\n\n        case 3:\n            if (tn === $.COL) {\n                colStartTagInTable(p, token);\n            } else {\n                tokenInTable(p, token);\n            }\n\n            break;\n\n        case 4:\n            if (tn === $.FORM) {\n                formStartTagInTable(p, token);\n            } else {\n                tokenInTable(p, token);\n            }\n\n            break;\n\n        case 5:\n            if (tn === $.TABLE) {\n                tableStartTagInTable(p, token);\n            } else if (tn === $.STYLE) {\n                startTagInHead(p, token);\n            } else if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {\n                tbodyStartTagInTable(p, token);\n            } else if (tn === $.INPUT) {\n                inputStartTagInTable(p, token);\n            } else {\n                tokenInTable(p, token);\n            }\n\n            break;\n\n        case 6:\n            if (tn === $.SCRIPT) {\n                startTagInHead(p, token);\n            } else {\n                tokenInTable(p, token);\n            }\n\n            break;\n\n        case 7:\n            if (tn === $.CAPTION) {\n                captionStartTagInTable(p, token);\n            } else {\n                tokenInTable(p, token);\n            }\n\n            break;\n\n        case 8:\n            if (tn === $.COLGROUP) {\n                colgroupStartTagInTable(p, token);\n            } else if (tn === $.TEMPLATE) {\n                startTagInHead(p, token);\n            } else {\n                tokenInTable(p, token);\n            }\n\n            break;\n\n        default:\n            tokenInTable(p, token);\n    }\n}\n\nfunction endTagInTable(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.TABLE) {\n        if (p.openElements.hasInTableScope($.TABLE)) {\n            p.openElements.popUntilTagNamePopped($.TABLE);\n            p._resetInsertionMode();\n        }\n    } else if (tn === $.TEMPLATE) {\n        endTagInHead(p, token);\n    } else if (\n        tn !== $.BODY &&\n        tn !== $.CAPTION &&\n        tn !== $.COL &&\n        tn !== $.COLGROUP &&\n        tn !== $.HTML &&\n        tn !== $.TBODY &&\n        tn !== $.TD &&\n        tn !== $.TFOOT &&\n        tn !== $.TH &&\n        tn !== $.THEAD &&\n        tn !== $.TR\n    ) {\n        tokenInTable(p, token);\n    }\n}\n\nfunction tokenInTable(p, token) {\n    const savedFosterParentingState = p.fosterParentingEnabled;\n\n    p.fosterParentingEnabled = true;\n    p._processTokenInBodyMode(token);\n    p.fosterParentingEnabled = savedFosterParentingState;\n}\n\n// The \"in table text\" insertion mode\n//------------------------------------------------------------------\nfunction whitespaceCharacterInTableText(p, token) {\n    p.pendingCharacterTokens.push(token);\n}\n\nfunction characterInTableText(p, token) {\n    p.pendingCharacterTokens.push(token);\n    p.hasNonWhitespacePendingCharacterToken = true;\n}\n\nfunction tokenInTableText(p, token) {\n    let i = 0;\n\n    if (p.hasNonWhitespacePendingCharacterToken) {\n        for (; i < p.pendingCharacterTokens.length; i++) {\n            tokenInTable(p, p.pendingCharacterTokens[i]);\n        }\n    } else {\n        for (; i < p.pendingCharacterTokens.length; i++) {\n            p._insertCharacters(p.pendingCharacterTokens[i]);\n        }\n    }\n\n    p.insertionMode = p.originalInsertionMode;\n    p._processToken(token);\n}\n\n// The \"in caption\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInCaption(p, token) {\n    const tn = token.tagName;\n\n    if (\n        tn === $.CAPTION ||\n        tn === $.COL ||\n        tn === $.COLGROUP ||\n        tn === $.TBODY ||\n        tn === $.TD ||\n        tn === $.TFOOT ||\n        tn === $.TH ||\n        tn === $.THEAD ||\n        tn === $.TR\n    ) {\n        if (p.openElements.hasInTableScope($.CAPTION)) {\n            p.openElements.generateImpliedEndTags();\n            p.openElements.popUntilTagNamePopped($.CAPTION);\n            p.activeFormattingElements.clearToLastMarker();\n            p.insertionMode = IN_TABLE_MODE;\n            p._processToken(token);\n        }\n    } else {\n        startTagInBody(p, token);\n    }\n}\n\nfunction endTagInCaption(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.CAPTION || tn === $.TABLE) {\n        if (p.openElements.hasInTableScope($.CAPTION)) {\n            p.openElements.generateImpliedEndTags();\n            p.openElements.popUntilTagNamePopped($.CAPTION);\n            p.activeFormattingElements.clearToLastMarker();\n            p.insertionMode = IN_TABLE_MODE;\n\n            if (tn === $.TABLE) {\n                p._processToken(token);\n            }\n        }\n    } else if (\n        tn !== $.BODY &&\n        tn !== $.COL &&\n        tn !== $.COLGROUP &&\n        tn !== $.HTML &&\n        tn !== $.TBODY &&\n        tn !== $.TD &&\n        tn !== $.TFOOT &&\n        tn !== $.TH &&\n        tn !== $.THEAD &&\n        tn !== $.TR\n    ) {\n        endTagInBody(p, token);\n    }\n}\n\n// The \"in column group\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInColumnGroup(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (tn === $.COL) {\n        p._appendElement(token, NS.HTML);\n        token.ackSelfClosing = true;\n    } else if (tn === $.TEMPLATE) {\n        startTagInHead(p, token);\n    } else {\n        tokenInColumnGroup(p, token);\n    }\n}\n\nfunction endTagInColumnGroup(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.COLGROUP) {\n        if (p.openElements.currentTagName === $.COLGROUP) {\n            p.openElements.pop();\n            p.insertionMode = IN_TABLE_MODE;\n        }\n    } else if (tn === $.TEMPLATE) {\n        endTagInHead(p, token);\n    } else if (tn !== $.COL) {\n        tokenInColumnGroup(p, token);\n    }\n}\n\nfunction tokenInColumnGroup(p, token) {\n    if (p.openElements.currentTagName === $.COLGROUP) {\n        p.openElements.pop();\n        p.insertionMode = IN_TABLE_MODE;\n        p._processToken(token);\n    }\n}\n\n// The \"in table body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInTableBody(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.TR) {\n        p.openElements.clearBackToTableBodyContext();\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = IN_ROW_MODE;\n    } else if (tn === $.TH || tn === $.TD) {\n        p.openElements.clearBackToTableBodyContext();\n        p._insertFakeElement($.TR);\n        p.insertionMode = IN_ROW_MODE;\n        p._processToken(token);\n    } else if (\n        tn === $.CAPTION ||\n        tn === $.COL ||\n        tn === $.COLGROUP ||\n        tn === $.TBODY ||\n        tn === $.TFOOT ||\n        tn === $.THEAD\n    ) {\n        if (p.openElements.hasTableBodyContextInTableScope()) {\n            p.openElements.clearBackToTableBodyContext();\n            p.openElements.pop();\n            p.insertionMode = IN_TABLE_MODE;\n            p._processToken(token);\n        }\n    } else {\n        startTagInTable(p, token);\n    }\n}\n\nfunction endTagInTableBody(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {\n        if (p.openElements.hasInTableScope(tn)) {\n            p.openElements.clearBackToTableBodyContext();\n            p.openElements.pop();\n            p.insertionMode = IN_TABLE_MODE;\n        }\n    } else if (tn === $.TABLE) {\n        if (p.openElements.hasTableBodyContextInTableScope()) {\n            p.openElements.clearBackToTableBodyContext();\n            p.openElements.pop();\n            p.insertionMode = IN_TABLE_MODE;\n            p._processToken(token);\n        }\n    } else if (\n        (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP) ||\n        (tn !== $.HTML && tn !== $.TD && tn !== $.TH && tn !== $.TR)\n    ) {\n        endTagInTable(p, token);\n    }\n}\n\n// The \"in row\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInRow(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.TH || tn === $.TD) {\n        p.openElements.clearBackToTableRowContext();\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = IN_CELL_MODE;\n        p.activeFormattingElements.insertMarker();\n    } else if (\n        tn === $.CAPTION ||\n        tn === $.COL ||\n        tn === $.COLGROUP ||\n        tn === $.TBODY ||\n        tn === $.TFOOT ||\n        tn === $.THEAD ||\n        tn === $.TR\n    ) {\n        if (p.openElements.hasInTableScope($.TR)) {\n            p.openElements.clearBackToTableRowContext();\n            p.openElements.pop();\n            p.insertionMode = IN_TABLE_BODY_MODE;\n            p._processToken(token);\n        }\n    } else {\n        startTagInTable(p, token);\n    }\n}\n\nfunction endTagInRow(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.TR) {\n        if (p.openElements.hasInTableScope($.TR)) {\n            p.openElements.clearBackToTableRowContext();\n            p.openElements.pop();\n            p.insertionMode = IN_TABLE_BODY_MODE;\n        }\n    } else if (tn === $.TABLE) {\n        if (p.openElements.hasInTableScope($.TR)) {\n            p.openElements.clearBackToTableRowContext();\n            p.openElements.pop();\n            p.insertionMode = IN_TABLE_BODY_MODE;\n            p._processToken(token);\n        }\n    } else if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {\n        if (p.openElements.hasInTableScope(tn) || p.openElements.hasInTableScope($.TR)) {\n            p.openElements.clearBackToTableRowContext();\n            p.openElements.pop();\n            p.insertionMode = IN_TABLE_BODY_MODE;\n            p._processToken(token);\n        }\n    } else if (\n        (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP) ||\n        (tn !== $.HTML && tn !== $.TD && tn !== $.TH)\n    ) {\n        endTagInTable(p, token);\n    }\n}\n\n// The \"in cell\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInCell(p, token) {\n    const tn = token.tagName;\n\n    if (\n        tn === $.CAPTION ||\n        tn === $.COL ||\n        tn === $.COLGROUP ||\n        tn === $.TBODY ||\n        tn === $.TD ||\n        tn === $.TFOOT ||\n        tn === $.TH ||\n        tn === $.THEAD ||\n        tn === $.TR\n    ) {\n        if (p.openElements.hasInTableScope($.TD) || p.openElements.hasInTableScope($.TH)) {\n            p._closeTableCell();\n            p._processToken(token);\n        }\n    } else {\n        startTagInBody(p, token);\n    }\n}\n\nfunction endTagInCell(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.TD || tn === $.TH) {\n        if (p.openElements.hasInTableScope(tn)) {\n            p.openElements.generateImpliedEndTags();\n            p.openElements.popUntilTagNamePopped(tn);\n            p.activeFormattingElements.clearToLastMarker();\n            p.insertionMode = IN_ROW_MODE;\n        }\n    } else if (tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR) {\n        if (p.openElements.hasInTableScope(tn)) {\n            p._closeTableCell();\n            p._processToken(token);\n        }\n    } else if (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP && tn !== $.HTML) {\n        endTagInBody(p, token);\n    }\n}\n\n// The \"in select\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInSelect(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (tn === $.OPTION) {\n        if (p.openElements.currentTagName === $.OPTION) {\n            p.openElements.pop();\n        }\n\n        p._insertElement(token, NS.HTML);\n    } else if (tn === $.OPTGROUP) {\n        if (p.openElements.currentTagName === $.OPTION) {\n            p.openElements.pop();\n        }\n\n        if (p.openElements.currentTagName === $.OPTGROUP) {\n            p.openElements.pop();\n        }\n\n        p._insertElement(token, NS.HTML);\n    } else if (tn === $.INPUT || tn === $.KEYGEN || tn === $.TEXTAREA || tn === $.SELECT) {\n        if (p.openElements.hasInSelectScope($.SELECT)) {\n            p.openElements.popUntilTagNamePopped($.SELECT);\n            p._resetInsertionMode();\n\n            if (tn !== $.SELECT) {\n                p._processToken(token);\n            }\n        }\n    } else if (tn === $.SCRIPT || tn === $.TEMPLATE) {\n        startTagInHead(p, token);\n    }\n}\n\nfunction endTagInSelect(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.OPTGROUP) {\n        const prevOpenElement = p.openElements.items[p.openElements.stackTop - 1];\n        const prevOpenElementTn = prevOpenElement && p.treeAdapter.getTagName(prevOpenElement);\n\n        if (p.openElements.currentTagName === $.OPTION && prevOpenElementTn === $.OPTGROUP) {\n            p.openElements.pop();\n        }\n\n        if (p.openElements.currentTagName === $.OPTGROUP) {\n            p.openElements.pop();\n        }\n    } else if (tn === $.OPTION) {\n        if (p.openElements.currentTagName === $.OPTION) {\n            p.openElements.pop();\n        }\n    } else if (tn === $.SELECT && p.openElements.hasInSelectScope($.SELECT)) {\n        p.openElements.popUntilTagNamePopped($.SELECT);\n        p._resetInsertionMode();\n    } else if (tn === $.TEMPLATE) {\n        endTagInHead(p, token);\n    }\n}\n\n//12.2.5.4.17 The \"in select in table\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInSelectInTable(p, token) {\n    const tn = token.tagName;\n\n    if (\n        tn === $.CAPTION ||\n        tn === $.TABLE ||\n        tn === $.TBODY ||\n        tn === $.TFOOT ||\n        tn === $.THEAD ||\n        tn === $.TR ||\n        tn === $.TD ||\n        tn === $.TH\n    ) {\n        p.openElements.popUntilTagNamePopped($.SELECT);\n        p._resetInsertionMode();\n        p._processToken(token);\n    } else {\n        startTagInSelect(p, token);\n    }\n}\n\nfunction endTagInSelectInTable(p, token) {\n    const tn = token.tagName;\n\n    if (\n        tn === $.CAPTION ||\n        tn === $.TABLE ||\n        tn === $.TBODY ||\n        tn === $.TFOOT ||\n        tn === $.THEAD ||\n        tn === $.TR ||\n        tn === $.TD ||\n        tn === $.TH\n    ) {\n        if (p.openElements.hasInTableScope(tn)) {\n            p.openElements.popUntilTagNamePopped($.SELECT);\n            p._resetInsertionMode();\n            p._processToken(token);\n        }\n    } else {\n        endTagInSelect(p, token);\n    }\n}\n\n// The \"in template\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInTemplate(p, token) {\n    const tn = token.tagName;\n\n    if (\n        tn === $.BASE ||\n        tn === $.BASEFONT ||\n        tn === $.BGSOUND ||\n        tn === $.LINK ||\n        tn === $.META ||\n        tn === $.NOFRAMES ||\n        tn === $.SCRIPT ||\n        tn === $.STYLE ||\n        tn === $.TEMPLATE ||\n        tn === $.TITLE\n    ) {\n        startTagInHead(p, token);\n    } else {\n        const newInsertionMode = TEMPLATE_INSERTION_MODE_SWITCH_MAP[tn] || IN_BODY_MODE;\n\n        p._popTmplInsertionMode();\n        p._pushTmplInsertionMode(newInsertionMode);\n        p.insertionMode = newInsertionMode;\n        p._processToken(token);\n    }\n}\n\nfunction endTagInTemplate(p, token) {\n    if (token.tagName === $.TEMPLATE) {\n        endTagInHead(p, token);\n    }\n}\n\nfunction eofInTemplate(p, token) {\n    if (p.openElements.tmplCount > 0) {\n        p.openElements.popUntilTagNamePopped($.TEMPLATE);\n        p.activeFormattingElements.clearToLastMarker();\n        p._popTmplInsertionMode();\n        p._resetInsertionMode();\n        p._processToken(token);\n    } else {\n        p.stopped = true;\n    }\n}\n\n// The \"after body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterBody(p, token) {\n    if (token.tagName === $.HTML) {\n        startTagInBody(p, token);\n    } else {\n        tokenAfterBody(p, token);\n    }\n}\n\nfunction endTagAfterBody(p, token) {\n    if (token.tagName === $.HTML) {\n        if (!p.fragmentContext) {\n            p.insertionMode = AFTER_AFTER_BODY_MODE;\n        }\n    } else {\n        tokenAfterBody(p, token);\n    }\n}\n\nfunction tokenAfterBody(p, token) {\n    p.insertionMode = IN_BODY_MODE;\n    p._processToken(token);\n}\n\n// The \"in frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInFrameset(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (tn === $.FRAMESET) {\n        p._insertElement(token, NS.HTML);\n    } else if (tn === $.FRAME) {\n        p._appendElement(token, NS.HTML);\n        token.ackSelfClosing = true;\n    } else if (tn === $.NOFRAMES) {\n        startTagInHead(p, token);\n    }\n}\n\nfunction endTagInFrameset(p, token) {\n    if (token.tagName === $.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {\n        p.openElements.pop();\n\n        if (!p.fragmentContext && p.openElements.currentTagName !== $.FRAMESET) {\n            p.insertionMode = AFTER_FRAMESET_MODE;\n        }\n    }\n}\n\n// The \"after frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterFrameset(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (tn === $.NOFRAMES) {\n        startTagInHead(p, token);\n    }\n}\n\nfunction endTagAfterFrameset(p, token) {\n    if (token.tagName === $.HTML) {\n        p.insertionMode = AFTER_AFTER_FRAMESET_MODE;\n    }\n}\n\n// The \"after after body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterAfterBody(p, token) {\n    if (token.tagName === $.HTML) {\n        startTagInBody(p, token);\n    } else {\n        tokenAfterAfterBody(p, token);\n    }\n}\n\nfunction tokenAfterAfterBody(p, token) {\n    p.insertionMode = IN_BODY_MODE;\n    p._processToken(token);\n}\n\n// The \"after after frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterAfterFrameset(p, token) {\n    const tn = token.tagName;\n\n    if (tn === $.HTML) {\n        startTagInBody(p, token);\n    } else if (tn === $.NOFRAMES) {\n        startTagInHead(p, token);\n    }\n}\n\n// The rules for parsing tokens in foreign content\n//------------------------------------------------------------------\nfunction nullCharacterInForeignContent(p, token) {\n    token.chars = unicode.REPLACEMENT_CHARACTER;\n    p._insertCharacters(token);\n}\n\nfunction characterInForeignContent(p, token) {\n    p._insertCharacters(token);\n    p.framesetOk = false;\n}\n\nfunction startTagInForeignContent(p, token) {\n    if (foreignContent.causesExit(token) && !p.fragmentContext) {\n        while (\n            p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML &&\n            !p._isIntegrationPoint(p.openElements.current)\n        ) {\n            p.openElements.pop();\n        }\n\n        p._processToken(token);\n    } else {\n        const current = p._getAdjustedCurrentElement();\n        const currentNs = p.treeAdapter.getNamespaceURI(current);\n\n        if (currentNs === NS.MATHML) {\n            foreignContent.adjustTokenMathMLAttrs(token);\n        } else if (currentNs === NS.SVG) {\n            foreignContent.adjustTokenSVGTagName(token);\n            foreignContent.adjustTokenSVGAttrs(token);\n        }\n\n        foreignContent.adjustTokenXMLAttrs(token);\n\n        if (token.selfClosing) {\n            p._appendElement(token, currentNs);\n        } else {\n            p._insertElement(token, currentNs);\n        }\n\n        token.ackSelfClosing = true;\n    }\n}\n\nfunction endTagInForeignContent(p, token) {\n    for (let i = p.openElements.stackTop; i > 0; i--) {\n        const element = p.openElements.items[i];\n\n        if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {\n            p._processToken(token);\n            break;\n        }\n\n        if (p.treeAdapter.getTagName(element).toLowerCase() === token.tagName) {\n            p.openElements.popUntilElementPopped(element);\n            break;\n        }\n    }\n}\n","'use strict';\n\nconst HTML = require('../common/html');\n\n//Aliases\nconst $ = HTML.TAG_NAMES;\nconst NS = HTML.NAMESPACES;\n\n//Element utils\n\n//OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.\n//It's faster than using dictionary.\nfunction isImpliedEndTagRequired(tn) {\n    switch (tn.length) {\n        case 1:\n            return tn === $.P;\n\n        case 2:\n            return tn === $.RB || tn === $.RP || tn === $.RT || tn === $.DD || tn === $.DT || tn === $.LI;\n\n        case 3:\n            return tn === $.RTC;\n\n        case 6:\n            return tn === $.OPTION;\n\n        case 8:\n            return tn === $.OPTGROUP;\n    }\n\n    return false;\n}\n\nfunction isImpliedEndTagRequiredThoroughly(tn) {\n    switch (tn.length) {\n        case 1:\n            return tn === $.P;\n\n        case 2:\n            return (\n                tn === $.RB ||\n                tn === $.RP ||\n                tn === $.RT ||\n                tn === $.DD ||\n                tn === $.DT ||\n                tn === $.LI ||\n                tn === $.TD ||\n                tn === $.TH ||\n                tn === $.TR\n            );\n\n        case 3:\n            return tn === $.RTC;\n\n        case 5:\n            return tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD;\n\n        case 6:\n            return tn === $.OPTION;\n\n        case 7:\n            return tn === $.CAPTION;\n\n        case 8:\n            return tn === $.OPTGROUP || tn === $.COLGROUP;\n    }\n\n    return false;\n}\n\nfunction isScopingElement(tn, ns) {\n    switch (tn.length) {\n        case 2:\n            if (tn === $.TD || tn === $.TH) {\n                return ns === NS.HTML;\n            } else if (tn === $.MI || tn === $.MO || tn === $.MN || tn === $.MS) {\n                return ns === NS.MATHML;\n            }\n\n            break;\n\n        case 4:\n            if (tn === $.HTML) {\n                return ns === NS.HTML;\n            } else if (tn === $.DESC) {\n                return ns === NS.SVG;\n            }\n\n            break;\n\n        case 5:\n            if (tn === $.TABLE) {\n                return ns === NS.HTML;\n            } else if (tn === $.MTEXT) {\n                return ns === NS.MATHML;\n            } else if (tn === $.TITLE) {\n                return ns === NS.SVG;\n            }\n\n            break;\n\n        case 6:\n            return (tn === $.APPLET || tn === $.OBJECT) && ns === NS.HTML;\n\n        case 7:\n            return (tn === $.CAPTION || tn === $.MARQUEE) && ns === NS.HTML;\n\n        case 8:\n            return tn === $.TEMPLATE && ns === NS.HTML;\n\n        case 13:\n            return tn === $.FOREIGN_OBJECT && ns === NS.SVG;\n\n        case 14:\n            return tn === $.ANNOTATION_XML && ns === NS.MATHML;\n    }\n\n    return false;\n}\n\n//Stack of open elements\nclass OpenElementStack {\n    constructor(document, treeAdapter) {\n        this.stackTop = -1;\n        this.items = [];\n        this.current = document;\n        this.currentTagName = null;\n        this.currentTmplContent = null;\n        this.tmplCount = 0;\n        this.treeAdapter = treeAdapter;\n    }\n\n    //Index of element\n    _indexOf(element) {\n        let idx = -1;\n\n        for (let i = this.stackTop; i >= 0; i--) {\n            if (this.items[i] === element) {\n                idx = i;\n                break;\n            }\n        }\n        return idx;\n    }\n\n    //Update current element\n    _isInTemplate() {\n        return this.currentTagName === $.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;\n    }\n\n    _updateCurrentElement() {\n        this.current = this.items[this.stackTop];\n        this.currentTagName = this.current && this.treeAdapter.getTagName(this.current);\n\n        this.currentTmplContent = this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : null;\n    }\n\n    //Mutations\n    push(element) {\n        this.items[++this.stackTop] = element;\n        this._updateCurrentElement();\n\n        if (this._isInTemplate()) {\n            this.tmplCount++;\n        }\n    }\n\n    pop() {\n        this.stackTop--;\n\n        if (this.tmplCount > 0 && this._isInTemplate()) {\n            this.tmplCount--;\n        }\n\n        this._updateCurrentElement();\n    }\n\n    replace(oldElement, newElement) {\n        const idx = this._indexOf(oldElement);\n\n        this.items[idx] = newElement;\n\n        if (idx === this.stackTop) {\n            this._updateCurrentElement();\n        }\n    }\n\n    insertAfter(referenceElement, newElement) {\n        const insertionIdx = this._indexOf(referenceElement) + 1;\n\n        this.items.splice(insertionIdx, 0, newElement);\n\n        if (insertionIdx === ++this.stackTop) {\n            this._updateCurrentElement();\n        }\n    }\n\n    popUntilTagNamePopped(tagName) {\n        while (this.stackTop > -1) {\n            const tn = this.currentTagName;\n            const ns = this.treeAdapter.getNamespaceURI(this.current);\n\n            this.pop();\n\n            if (tn === tagName && ns === NS.HTML) {\n                break;\n            }\n        }\n    }\n\n    popUntilElementPopped(element) {\n        while (this.stackTop > -1) {\n            const poppedElement = this.current;\n\n            this.pop();\n\n            if (poppedElement === element) {\n                break;\n            }\n        }\n    }\n\n    popUntilNumberedHeaderPopped() {\n        while (this.stackTop > -1) {\n            const tn = this.currentTagName;\n            const ns = this.treeAdapter.getNamespaceURI(this.current);\n\n            this.pop();\n\n            if (\n                tn === $.H1 ||\n                tn === $.H2 ||\n                tn === $.H3 ||\n                tn === $.H4 ||\n                tn === $.H5 ||\n                (tn === $.H6 && ns === NS.HTML)\n            ) {\n                break;\n            }\n        }\n    }\n\n    popUntilTableCellPopped() {\n        while (this.stackTop > -1) {\n            const tn = this.currentTagName;\n            const ns = this.treeAdapter.getNamespaceURI(this.current);\n\n            this.pop();\n\n            if (tn === $.TD || (tn === $.TH && ns === NS.HTML)) {\n                break;\n            }\n        }\n    }\n\n    popAllUpToHtmlElement() {\n        //NOTE: here we assume that root <html> element is always first in the open element stack, so\n        //we perform this fast stack clean up.\n        this.stackTop = 0;\n        this._updateCurrentElement();\n    }\n\n    clearBackToTableContext() {\n        while (\n            (this.currentTagName !== $.TABLE && this.currentTagName !== $.TEMPLATE && this.currentTagName !== $.HTML) ||\n            this.treeAdapter.getNamespaceURI(this.current) !== NS.HTML\n        ) {\n            this.pop();\n        }\n    }\n\n    clearBackToTableBodyContext() {\n        while (\n            (this.currentTagName !== $.TBODY &&\n                this.currentTagName !== $.TFOOT &&\n                this.currentTagName !== $.THEAD &&\n                this.currentTagName !== $.TEMPLATE &&\n                this.currentTagName !== $.HTML) ||\n            this.treeAdapter.getNamespaceURI(this.current) !== NS.HTML\n        ) {\n            this.pop();\n        }\n    }\n\n    clearBackToTableRowContext() {\n        while (\n            (this.currentTagName !== $.TR && this.currentTagName !== $.TEMPLATE && this.currentTagName !== $.HTML) ||\n            this.treeAdapter.getNamespaceURI(this.current) !== NS.HTML\n        ) {\n            this.pop();\n        }\n    }\n\n    remove(element) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            if (this.items[i] === element) {\n                this.items.splice(i, 1);\n                this.stackTop--;\n                this._updateCurrentElement();\n                break;\n            }\n        }\n    }\n\n    //Search\n    tryPeekProperlyNestedBodyElement() {\n        //Properly nested <body> element (should be second element in stack).\n        const element = this.items[1];\n\n        return element && this.treeAdapter.getTagName(element) === $.BODY ? element : null;\n    }\n\n    contains(element) {\n        return this._indexOf(element) > -1;\n    }\n\n    getCommonAncestor(element) {\n        let elementIdx = this._indexOf(element);\n\n        return --elementIdx >= 0 ? this.items[elementIdx] : null;\n    }\n\n    isRootHtmlElementCurrent() {\n        return this.stackTop === 0 && this.currentTagName === $.HTML;\n    }\n\n    //Element in scope\n    hasInScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.treeAdapter.getTagName(this.items[i]);\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n\n            if (tn === tagName && ns === NS.HTML) {\n                return true;\n            }\n\n            if (isScopingElement(tn, ns)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    hasNumberedHeaderInScope() {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.treeAdapter.getTagName(this.items[i]);\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n\n            if (\n                (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) &&\n                ns === NS.HTML\n            ) {\n                return true;\n            }\n\n            if (isScopingElement(tn, ns)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    hasInListItemScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.treeAdapter.getTagName(this.items[i]);\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n\n            if (tn === tagName && ns === NS.HTML) {\n                return true;\n            }\n\n            if (((tn === $.UL || tn === $.OL) && ns === NS.HTML) || isScopingElement(tn, ns)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    hasInButtonScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.treeAdapter.getTagName(this.items[i]);\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n\n            if (tn === tagName && ns === NS.HTML) {\n                return true;\n            }\n\n            if ((tn === $.BUTTON && ns === NS.HTML) || isScopingElement(tn, ns)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    hasInTableScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.treeAdapter.getTagName(this.items[i]);\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n\n            if (ns !== NS.HTML) {\n                continue;\n            }\n\n            if (tn === tagName) {\n                return true;\n            }\n\n            if (tn === $.TABLE || tn === $.TEMPLATE || tn === $.HTML) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    hasTableBodyContextInTableScope() {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.treeAdapter.getTagName(this.items[i]);\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n\n            if (ns !== NS.HTML) {\n                continue;\n            }\n\n            if (tn === $.TBODY || tn === $.THEAD || tn === $.TFOOT) {\n                return true;\n            }\n\n            if (tn === $.TABLE || tn === $.HTML) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    hasInSelectScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.treeAdapter.getTagName(this.items[i]);\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n\n            if (ns !== NS.HTML) {\n                continue;\n            }\n\n            if (tn === tagName) {\n                return true;\n            }\n\n            if (tn !== $.OPTION && tn !== $.OPTGROUP) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    //Implied end tags\n    generateImpliedEndTags() {\n        while (isImpliedEndTagRequired(this.currentTagName)) {\n            this.pop();\n        }\n    }\n\n    generateImpliedEndTagsThoroughly() {\n        while (isImpliedEndTagRequiredThoroughly(this.currentTagName)) {\n            this.pop();\n        }\n    }\n\n    generateImpliedEndTagsWithExclusion(exclusionTagName) {\n        while (isImpliedEndTagRequired(this.currentTagName) && this.currentTagName !== exclusionTagName) {\n            this.pop();\n        }\n    }\n}\n\nmodule.exports = OpenElementStack;\n","'use strict';\n\nconst Preprocessor = require('./preprocessor');\nconst unicode = require('../common/unicode');\nconst neTree = require('./named-entity-data');\nconst ERR = require('../common/error-codes');\n\n//Aliases\nconst $ = unicode.CODE_POINTS;\nconst $$ = unicode.CODE_POINT_SEQUENCES;\n\n//C1 Unicode control character reference replacements\nconst C1_CONTROLS_REFERENCE_REPLACEMENTS = {\n    0x80: 0x20ac,\n    0x82: 0x201a,\n    0x83: 0x0192,\n    0x84: 0x201e,\n    0x85: 0x2026,\n    0x86: 0x2020,\n    0x87: 0x2021,\n    0x88: 0x02c6,\n    0x89: 0x2030,\n    0x8a: 0x0160,\n    0x8b: 0x2039,\n    0x8c: 0x0152,\n    0x8e: 0x017d,\n    0x91: 0x2018,\n    0x92: 0x2019,\n    0x93: 0x201c,\n    0x94: 0x201d,\n    0x95: 0x2022,\n    0x96: 0x2013,\n    0x97: 0x2014,\n    0x98: 0x02dc,\n    0x99: 0x2122,\n    0x9a: 0x0161,\n    0x9b: 0x203a,\n    0x9c: 0x0153,\n    0x9e: 0x017e,\n    0x9f: 0x0178\n};\n\n// Named entity tree flags\nconst HAS_DATA_FLAG = 1 << 0;\nconst DATA_DUPLET_FLAG = 1 << 1;\nconst HAS_BRANCHES_FLAG = 1 << 2;\nconst MAX_BRANCH_MARKER_VALUE = HAS_DATA_FLAG | DATA_DUPLET_FLAG | HAS_BRANCHES_FLAG;\n\n//States\nconst DATA_STATE = 'DATA_STATE';\nconst RCDATA_STATE = 'RCDATA_STATE';\nconst RAWTEXT_STATE = 'RAWTEXT_STATE';\nconst SCRIPT_DATA_STATE = 'SCRIPT_DATA_STATE';\nconst PLAINTEXT_STATE = 'PLAINTEXT_STATE';\nconst TAG_OPEN_STATE = 'TAG_OPEN_STATE';\nconst END_TAG_OPEN_STATE = 'END_TAG_OPEN_STATE';\nconst TAG_NAME_STATE = 'TAG_NAME_STATE';\nconst RCDATA_LESS_THAN_SIGN_STATE = 'RCDATA_LESS_THAN_SIGN_STATE';\nconst RCDATA_END_TAG_OPEN_STATE = 'RCDATA_END_TAG_OPEN_STATE';\nconst RCDATA_END_TAG_NAME_STATE = 'RCDATA_END_TAG_NAME_STATE';\nconst RAWTEXT_LESS_THAN_SIGN_STATE = 'RAWTEXT_LESS_THAN_SIGN_STATE';\nconst RAWTEXT_END_TAG_OPEN_STATE = 'RAWTEXT_END_TAG_OPEN_STATE';\nconst RAWTEXT_END_TAG_NAME_STATE = 'RAWTEXT_END_TAG_NAME_STATE';\nconst SCRIPT_DATA_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_LESS_THAN_SIGN_STATE';\nconst SCRIPT_DATA_END_TAG_OPEN_STATE = 'SCRIPT_DATA_END_TAG_OPEN_STATE';\nconst SCRIPT_DATA_END_TAG_NAME_STATE = 'SCRIPT_DATA_END_TAG_NAME_STATE';\nconst SCRIPT_DATA_ESCAPE_START_STATE = 'SCRIPT_DATA_ESCAPE_START_STATE';\nconst SCRIPT_DATA_ESCAPE_START_DASH_STATE = 'SCRIPT_DATA_ESCAPE_START_DASH_STATE';\nconst SCRIPT_DATA_ESCAPED_STATE = 'SCRIPT_DATA_ESCAPED_STATE';\nconst SCRIPT_DATA_ESCAPED_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_STATE';\nconst SCRIPT_DATA_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_DASH_STATE';\nconst SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE';\nconst SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE';\nconst SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE';\nconst SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE';\nconst SCRIPT_DATA_DOUBLE_ESCAPED_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_STATE';\nconst SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE';\nconst SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE';\nconst SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE';\nconst SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE';\nconst BEFORE_ATTRIBUTE_NAME_STATE = 'BEFORE_ATTRIBUTE_NAME_STATE';\nconst ATTRIBUTE_NAME_STATE = 'ATTRIBUTE_NAME_STATE';\nconst AFTER_ATTRIBUTE_NAME_STATE = 'AFTER_ATTRIBUTE_NAME_STATE';\nconst BEFORE_ATTRIBUTE_VALUE_STATE = 'BEFORE_ATTRIBUTE_VALUE_STATE';\nconst ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE';\nconst ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE';\nconst ATTRIBUTE_VALUE_UNQUOTED_STATE = 'ATTRIBUTE_VALUE_UNQUOTED_STATE';\nconst AFTER_ATTRIBUTE_VALUE_QUOTED_STATE = 'AFTER_ATTRIBUTE_VALUE_QUOTED_STATE';\nconst SELF_CLOSING_START_TAG_STATE = 'SELF_CLOSING_START_TAG_STATE';\nconst BOGUS_COMMENT_STATE = 'BOGUS_COMMENT_STATE';\nconst MARKUP_DECLARATION_OPEN_STATE = 'MARKUP_DECLARATION_OPEN_STATE';\nconst COMMENT_START_STATE = 'COMMENT_START_STATE';\nconst COMMENT_START_DASH_STATE = 'COMMENT_START_DASH_STATE';\nconst COMMENT_STATE = 'COMMENT_STATE';\nconst COMMENT_LESS_THAN_SIGN_STATE = 'COMMENT_LESS_THAN_SIGN_STATE';\nconst COMMENT_LESS_THAN_SIGN_BANG_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_STATE';\nconst COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE';\nconst COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE';\nconst COMMENT_END_DASH_STATE = 'COMMENT_END_DASH_STATE';\nconst COMMENT_END_STATE = 'COMMENT_END_STATE';\nconst COMMENT_END_BANG_STATE = 'COMMENT_END_BANG_STATE';\nconst DOCTYPE_STATE = 'DOCTYPE_STATE';\nconst BEFORE_DOCTYPE_NAME_STATE = 'BEFORE_DOCTYPE_NAME_STATE';\nconst DOCTYPE_NAME_STATE = 'DOCTYPE_NAME_STATE';\nconst AFTER_DOCTYPE_NAME_STATE = 'AFTER_DOCTYPE_NAME_STATE';\nconst AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE = 'AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE';\nconst BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE';\nconst DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE';\nconst DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE';\nconst AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE';\nconst BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE = 'BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE';\nconst AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE = 'AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE';\nconst BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE';\nconst DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE';\nconst DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE';\nconst AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE';\nconst BOGUS_DOCTYPE_STATE = 'BOGUS_DOCTYPE_STATE';\nconst CDATA_SECTION_STATE = 'CDATA_SECTION_STATE';\nconst CDATA_SECTION_BRACKET_STATE = 'CDATA_SECTION_BRACKET_STATE';\nconst CDATA_SECTION_END_STATE = 'CDATA_SECTION_END_STATE';\nconst CHARACTER_REFERENCE_STATE = 'CHARACTER_REFERENCE_STATE';\nconst NAMED_CHARACTER_REFERENCE_STATE = 'NAMED_CHARACTER_REFERENCE_STATE';\nconst AMBIGUOUS_AMPERSAND_STATE = 'AMBIGUOS_AMPERSAND_STATE';\nconst NUMERIC_CHARACTER_REFERENCE_STATE = 'NUMERIC_CHARACTER_REFERENCE_STATE';\nconst HEXADEMICAL_CHARACTER_REFERENCE_START_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_START_STATE';\nconst DECIMAL_CHARACTER_REFERENCE_START_STATE = 'DECIMAL_CHARACTER_REFERENCE_START_STATE';\nconst HEXADEMICAL_CHARACTER_REFERENCE_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_STATE';\nconst DECIMAL_CHARACTER_REFERENCE_STATE = 'DECIMAL_CHARACTER_REFERENCE_STATE';\nconst NUMERIC_CHARACTER_REFERENCE_END_STATE = 'NUMERIC_CHARACTER_REFERENCE_END_STATE';\n\n//Utils\n\n//OPTIMIZATION: these utility functions should not be moved out of this module. V8 Crankshaft will not inline\n//this functions if they will be situated in another module due to context switch.\n//Always perform inlining check before modifying this functions ('node --trace-inlining').\nfunction isWhitespace(cp) {\n    return cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED;\n}\n\nfunction isAsciiDigit(cp) {\n    return cp >= $.DIGIT_0 && cp <= $.DIGIT_9;\n}\n\nfunction isAsciiUpper(cp) {\n    return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_Z;\n}\n\nfunction isAsciiLower(cp) {\n    return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_Z;\n}\n\nfunction isAsciiLetter(cp) {\n    return isAsciiLower(cp) || isAsciiUpper(cp);\n}\n\nfunction isAsciiAlphaNumeric(cp) {\n    return isAsciiLetter(cp) || isAsciiDigit(cp);\n}\n\nfunction isAsciiUpperHexDigit(cp) {\n    return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_F;\n}\n\nfunction isAsciiLowerHexDigit(cp) {\n    return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_F;\n}\n\nfunction isAsciiHexDigit(cp) {\n    return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);\n}\n\nfunction toAsciiLowerCodePoint(cp) {\n    return cp + 0x0020;\n}\n\n//NOTE: String.fromCharCode() function can handle only characters from BMP subset.\n//So, we need to workaround this manually.\n//(see: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/fromCharCode#Getting_it_to_work_with_higher_values)\nfunction toChar(cp) {\n    if (cp <= 0xffff) {\n        return String.fromCharCode(cp);\n    }\n\n    cp -= 0x10000;\n    return String.fromCharCode(((cp >>> 10) & 0x3ff) | 0xd800) + String.fromCharCode(0xdc00 | (cp & 0x3ff));\n}\n\nfunction toAsciiLowerChar(cp) {\n    return String.fromCharCode(toAsciiLowerCodePoint(cp));\n}\n\nfunction findNamedEntityTreeBranch(nodeIx, cp) {\n    const branchCount = neTree[++nodeIx];\n    let lo = ++nodeIx;\n    let hi = lo + branchCount - 1;\n\n    while (lo <= hi) {\n        const mid = (lo + hi) >>> 1;\n        const midCp = neTree[mid];\n\n        if (midCp < cp) {\n            lo = mid + 1;\n        } else if (midCp > cp) {\n            hi = mid - 1;\n        } else {\n            return neTree[mid + branchCount];\n        }\n    }\n\n    return -1;\n}\n\n//Tokenizer\nclass Tokenizer {\n    constructor() {\n        this.preprocessor = new Preprocessor();\n\n        this.tokenQueue = [];\n\n        this.allowCDATA = false;\n\n        this.state = DATA_STATE;\n        this.returnState = '';\n\n        this.charRefCode = -1;\n        this.tempBuff = [];\n        this.lastStartTagName = '';\n\n        this.consumedAfterSnapshot = -1;\n        this.active = false;\n\n        this.currentCharacterToken = null;\n        this.currentToken = null;\n        this.currentAttr = null;\n    }\n\n    //Errors\n    _err() {\n        // NOTE: err reporting is noop by default. Enabled by mixin.\n    }\n\n    _errOnNextCodePoint(err) {\n        this._consume();\n        this._err(err);\n        this._unconsume();\n    }\n\n    //API\n    getNextToken() {\n        while (!this.tokenQueue.length && this.active) {\n            this.consumedAfterSnapshot = 0;\n\n            const cp = this._consume();\n\n            if (!this._ensureHibernation()) {\n                this[this.state](cp);\n            }\n        }\n\n        return this.tokenQueue.shift();\n    }\n\n    write(chunk, isLastChunk) {\n        this.active = true;\n        this.preprocessor.write(chunk, isLastChunk);\n    }\n\n    insertHtmlAtCurrentPos(chunk) {\n        this.active = true;\n        this.preprocessor.insertHtmlAtCurrentPos(chunk);\n    }\n\n    //Hibernation\n    _ensureHibernation() {\n        if (this.preprocessor.endOfChunkHit) {\n            for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--) {\n                this.preprocessor.retreat();\n            }\n\n            this.active = false;\n            this.tokenQueue.push({ type: Tokenizer.HIBERNATION_TOKEN });\n\n            return true;\n        }\n\n        return false;\n    }\n\n    //Consumption\n    _consume() {\n        this.consumedAfterSnapshot++;\n        return this.preprocessor.advance();\n    }\n\n    _unconsume() {\n        this.consumedAfterSnapshot--;\n        this.preprocessor.retreat();\n    }\n\n    _reconsumeInState(state) {\n        this.state = state;\n        this._unconsume();\n    }\n\n    _consumeSequenceIfMatch(pattern, startCp, caseSensitive) {\n        let consumedCount = 0;\n        let isMatch = true;\n        const patternLength = pattern.length;\n        let patternPos = 0;\n        let cp = startCp;\n        let patternCp = void 0;\n\n        for (; patternPos < patternLength; patternPos++) {\n            if (patternPos > 0) {\n                cp = this._consume();\n                consumedCount++;\n            }\n\n            if (cp === $.EOF) {\n                isMatch = false;\n                break;\n            }\n\n            patternCp = pattern[patternPos];\n\n            if (cp !== patternCp && (caseSensitive || cp !== toAsciiLowerCodePoint(patternCp))) {\n                isMatch = false;\n                break;\n            }\n        }\n\n        if (!isMatch) {\n            while (consumedCount--) {\n                this._unconsume();\n            }\n        }\n\n        return isMatch;\n    }\n\n    //Temp buffer\n    _isTempBufferEqualToScriptString() {\n        if (this.tempBuff.length !== $$.SCRIPT_STRING.length) {\n            return false;\n        }\n\n        for (let i = 0; i < this.tempBuff.length; i++) {\n            if (this.tempBuff[i] !== $$.SCRIPT_STRING[i]) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    //Token creation\n    _createStartTagToken() {\n        this.currentToken = {\n            type: Tokenizer.START_TAG_TOKEN,\n            tagName: '',\n            selfClosing: false,\n            ackSelfClosing: false,\n            attrs: []\n        };\n    }\n\n    _createEndTagToken() {\n        this.currentToken = {\n            type: Tokenizer.END_TAG_TOKEN,\n            tagName: '',\n            selfClosing: false,\n            attrs: []\n        };\n    }\n\n    _createCommentToken() {\n        this.currentToken = {\n            type: Tokenizer.COMMENT_TOKEN,\n            data: ''\n        };\n    }\n\n    _createDoctypeToken(initialName) {\n        this.currentToken = {\n            type: Tokenizer.DOCTYPE_TOKEN,\n            name: initialName,\n            forceQuirks: false,\n            publicId: null,\n            systemId: null\n        };\n    }\n\n    _createCharacterToken(type, ch) {\n        this.currentCharacterToken = {\n            type: type,\n            chars: ch\n        };\n    }\n\n    _createEOFToken() {\n        this.currentToken = { type: Tokenizer.EOF_TOKEN };\n    }\n\n    //Tag attributes\n    _createAttr(attrNameFirstCh) {\n        this.currentAttr = {\n            name: attrNameFirstCh,\n            value: ''\n        };\n    }\n\n    _leaveAttrName(toState) {\n        if (Tokenizer.getTokenAttr(this.currentToken, this.currentAttr.name) === null) {\n            this.currentToken.attrs.push(this.currentAttr);\n        } else {\n            this._err(ERR.duplicateAttribute);\n        }\n\n        this.state = toState;\n    }\n\n    _leaveAttrValue(toState) {\n        this.state = toState;\n    }\n\n    //Token emission\n    _emitCurrentToken() {\n        this._emitCurrentCharacterToken();\n\n        const ct = this.currentToken;\n\n        this.currentToken = null;\n\n        //NOTE: store emited start tag's tagName to determine is the following end tag token is appropriate.\n        if (ct.type === Tokenizer.START_TAG_TOKEN) {\n            this.lastStartTagName = ct.tagName;\n        } else if (ct.type === Tokenizer.END_TAG_TOKEN) {\n            if (ct.attrs.length > 0) {\n                this._err(ERR.endTagWithAttributes);\n            }\n\n            if (ct.selfClosing) {\n                this._err(ERR.endTagWithTrailingSolidus);\n            }\n        }\n\n        this.tokenQueue.push(ct);\n    }\n\n    _emitCurrentCharacterToken() {\n        if (this.currentCharacterToken) {\n            this.tokenQueue.push(this.currentCharacterToken);\n            this.currentCharacterToken = null;\n        }\n    }\n\n    _emitEOFToken() {\n        this._createEOFToken();\n        this._emitCurrentToken();\n    }\n\n    //Characters emission\n\n    //OPTIMIZATION: specification uses only one type of character tokens (one token per character).\n    //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.\n    //If we have a sequence of characters that belong to the same group, parser can process it\n    //as a single solid character token.\n    //So, there are 3 types of character tokens in parse5:\n    //1)NULL_CHARACTER_TOKEN - \\u0000-character sequences (e.g. '\\u0000\\u0000\\u0000')\n    //2)WHITESPACE_CHARACTER_TOKEN - any whitespace/new-line character sequences (e.g. '\\n  \\r\\t   \\f')\n    //3)CHARACTER_TOKEN - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')\n    _appendCharToCurrentCharacterToken(type, ch) {\n        if (this.currentCharacterToken && this.currentCharacterToken.type !== type) {\n            this._emitCurrentCharacterToken();\n        }\n\n        if (this.currentCharacterToken) {\n            this.currentCharacterToken.chars += ch;\n        } else {\n            this._createCharacterToken(type, ch);\n        }\n    }\n\n    _emitCodePoint(cp) {\n        let type = Tokenizer.CHARACTER_TOKEN;\n\n        if (isWhitespace(cp)) {\n            type = Tokenizer.WHITESPACE_CHARACTER_TOKEN;\n        } else if (cp === $.NULL) {\n            type = Tokenizer.NULL_CHARACTER_TOKEN;\n        }\n\n        this._appendCharToCurrentCharacterToken(type, toChar(cp));\n    }\n\n    _emitSeveralCodePoints(codePoints) {\n        for (let i = 0; i < codePoints.length; i++) {\n            this._emitCodePoint(codePoints[i]);\n        }\n    }\n\n    //NOTE: used then we emit character explicitly. This is always a non-whitespace and a non-null character.\n    //So we can avoid additional checks here.\n    _emitChars(ch) {\n        this._appendCharToCurrentCharacterToken(Tokenizer.CHARACTER_TOKEN, ch);\n    }\n\n    // Character reference helpers\n    _matchNamedCharacterReference(startCp) {\n        let result = null;\n        let excess = 1;\n        let i = findNamedEntityTreeBranch(0, startCp);\n\n        this.tempBuff.push(startCp);\n\n        while (i > -1) {\n            const current = neTree[i];\n            const inNode = current < MAX_BRANCH_MARKER_VALUE;\n            const nodeWithData = inNode && current & HAS_DATA_FLAG;\n\n            if (nodeWithData) {\n                //NOTE: we use greedy search, so we continue lookup at this point\n                result = current & DATA_DUPLET_FLAG ? [neTree[++i], neTree[++i]] : [neTree[++i]];\n                excess = 0;\n            }\n\n            const cp = this._consume();\n\n            this.tempBuff.push(cp);\n            excess++;\n\n            if (cp === $.EOF) {\n                break;\n            }\n\n            if (inNode) {\n                i = current & HAS_BRANCHES_FLAG ? findNamedEntityTreeBranch(i, cp) : -1;\n            } else {\n                i = cp === current ? ++i : -1;\n            }\n        }\n\n        while (excess--) {\n            this.tempBuff.pop();\n            this._unconsume();\n        }\n\n        return result;\n    }\n\n    _isCharacterReferenceInAttribute() {\n        return (\n            this.returnState === ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE ||\n            this.returnState === ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE ||\n            this.returnState === ATTRIBUTE_VALUE_UNQUOTED_STATE\n        );\n    }\n\n    _isCharacterReferenceAttributeQuirk(withSemicolon) {\n        if (!withSemicolon && this._isCharacterReferenceInAttribute()) {\n            const nextCp = this._consume();\n\n            this._unconsume();\n\n            return nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);\n        }\n\n        return false;\n    }\n\n    _flushCodePointsConsumedAsCharacterReference() {\n        if (this._isCharacterReferenceInAttribute()) {\n            for (let i = 0; i < this.tempBuff.length; i++) {\n                this.currentAttr.value += toChar(this.tempBuff[i]);\n            }\n        } else {\n            this._emitSeveralCodePoints(this.tempBuff);\n        }\n\n        this.tempBuff = [];\n    }\n\n    // State machine\n\n    // Data state\n    //------------------------------------------------------------------\n    [DATA_STATE](cp) {\n        this.preprocessor.dropParsedChunk();\n\n        if (cp === $.LESS_THAN_SIGN) {\n            this.state = TAG_OPEN_STATE;\n        } else if (cp === $.AMPERSAND) {\n            this.returnState = DATA_STATE;\n            this.state = CHARACTER_REFERENCE_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this._emitCodePoint(cp);\n        } else if (cp === $.EOF) {\n            this._emitEOFToken();\n        } else {\n            this._emitCodePoint(cp);\n        }\n    }\n\n    //  RCDATA state\n    //------------------------------------------------------------------\n    [RCDATA_STATE](cp) {\n        this.preprocessor.dropParsedChunk();\n\n        if (cp === $.AMPERSAND) {\n            this.returnState = RCDATA_STATE;\n            this.state = CHARACTER_REFERENCE_STATE;\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.state = RCDATA_LESS_THAN_SIGN_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._emitEOFToken();\n        } else {\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // RAWTEXT state\n    //------------------------------------------------------------------\n    [RAWTEXT_STATE](cp) {\n        this.preprocessor.dropParsedChunk();\n\n        if (cp === $.LESS_THAN_SIGN) {\n            this.state = RAWTEXT_LESS_THAN_SIGN_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._emitEOFToken();\n        } else {\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // Script data state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_STATE](cp) {\n        this.preprocessor.dropParsedChunk();\n\n        if (cp === $.LESS_THAN_SIGN) {\n            this.state = SCRIPT_DATA_LESS_THAN_SIGN_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._emitEOFToken();\n        } else {\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // PLAINTEXT state\n    //------------------------------------------------------------------\n    [PLAINTEXT_STATE](cp) {\n        this.preprocessor.dropParsedChunk();\n\n        if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._emitEOFToken();\n        } else {\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // Tag open state\n    //------------------------------------------------------------------\n    [TAG_OPEN_STATE](cp) {\n        if (cp === $.EXCLAMATION_MARK) {\n            this.state = MARKUP_DECLARATION_OPEN_STATE;\n        } else if (cp === $.SOLIDUS) {\n            this.state = END_TAG_OPEN_STATE;\n        } else if (isAsciiLetter(cp)) {\n            this._createStartTagToken();\n            this._reconsumeInState(TAG_NAME_STATE);\n        } else if (cp === $.QUESTION_MARK) {\n            this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);\n            this._createCommentToken();\n            this._reconsumeInState(BOGUS_COMMENT_STATE);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofBeforeTagName);\n            this._emitChars('<');\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.invalidFirstCharacterOfTagName);\n            this._emitChars('<');\n            this._reconsumeInState(DATA_STATE);\n        }\n    }\n\n    // End tag open state\n    //------------------------------------------------------------------\n    [END_TAG_OPEN_STATE](cp) {\n        if (isAsciiLetter(cp)) {\n            this._createEndTagToken();\n            this._reconsumeInState(TAG_NAME_STATE);\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.missingEndTagName);\n            this.state = DATA_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofBeforeTagName);\n            this._emitChars('</');\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.invalidFirstCharacterOfTagName);\n            this._createCommentToken();\n            this._reconsumeInState(BOGUS_COMMENT_STATE);\n        }\n    }\n\n    // Tag name state\n    //------------------------------------------------------------------\n    [TAG_NAME_STATE](cp) {\n        if (isWhitespace(cp)) {\n            this.state = BEFORE_ATTRIBUTE_NAME_STATE;\n        } else if (cp === $.SOLIDUS) {\n            this.state = SELF_CLOSING_START_TAG_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (isAsciiUpper(cp)) {\n            this.currentToken.tagName += toAsciiLowerChar(cp);\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentToken.tagName += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInTag);\n            this._emitEOFToken();\n        } else {\n            this.currentToken.tagName += toChar(cp);\n        }\n    }\n\n    // RCDATA less-than sign state\n    //------------------------------------------------------------------\n    [RCDATA_LESS_THAN_SIGN_STATE](cp) {\n        if (cp === $.SOLIDUS) {\n            this.tempBuff = [];\n            this.state = RCDATA_END_TAG_OPEN_STATE;\n        } else {\n            this._emitChars('<');\n            this._reconsumeInState(RCDATA_STATE);\n        }\n    }\n\n    // RCDATA end tag open state\n    //------------------------------------------------------------------\n    [RCDATA_END_TAG_OPEN_STATE](cp) {\n        if (isAsciiLetter(cp)) {\n            this._createEndTagToken();\n            this._reconsumeInState(RCDATA_END_TAG_NAME_STATE);\n        } else {\n            this._emitChars('</');\n            this._reconsumeInState(RCDATA_STATE);\n        }\n    }\n\n    // RCDATA end tag name state\n    //------------------------------------------------------------------\n    [RCDATA_END_TAG_NAME_STATE](cp) {\n        if (isAsciiUpper(cp)) {\n            this.currentToken.tagName += toAsciiLowerChar(cp);\n            this.tempBuff.push(cp);\n        } else if (isAsciiLower(cp)) {\n            this.currentToken.tagName += toChar(cp);\n            this.tempBuff.push(cp);\n        } else {\n            if (this.lastStartTagName === this.currentToken.tagName) {\n                if (isWhitespace(cp)) {\n                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;\n                    return;\n                }\n\n                if (cp === $.SOLIDUS) {\n                    this.state = SELF_CLOSING_START_TAG_STATE;\n                    return;\n                }\n\n                if (cp === $.GREATER_THAN_SIGN) {\n                    this.state = DATA_STATE;\n                    this._emitCurrentToken();\n                    return;\n                }\n            }\n\n            this._emitChars('</');\n            this._emitSeveralCodePoints(this.tempBuff);\n            this._reconsumeInState(RCDATA_STATE);\n        }\n    }\n\n    // RAWTEXT less-than sign state\n    //------------------------------------------------------------------\n    [RAWTEXT_LESS_THAN_SIGN_STATE](cp) {\n        if (cp === $.SOLIDUS) {\n            this.tempBuff = [];\n            this.state = RAWTEXT_END_TAG_OPEN_STATE;\n        } else {\n            this._emitChars('<');\n            this._reconsumeInState(RAWTEXT_STATE);\n        }\n    }\n\n    // RAWTEXT end tag open state\n    //------------------------------------------------------------------\n    [RAWTEXT_END_TAG_OPEN_STATE](cp) {\n        if (isAsciiLetter(cp)) {\n            this._createEndTagToken();\n            this._reconsumeInState(RAWTEXT_END_TAG_NAME_STATE);\n        } else {\n            this._emitChars('</');\n            this._reconsumeInState(RAWTEXT_STATE);\n        }\n    }\n\n    // RAWTEXT end tag name state\n    //------------------------------------------------------------------\n    [RAWTEXT_END_TAG_NAME_STATE](cp) {\n        if (isAsciiUpper(cp)) {\n            this.currentToken.tagName += toAsciiLowerChar(cp);\n            this.tempBuff.push(cp);\n        } else if (isAsciiLower(cp)) {\n            this.currentToken.tagName += toChar(cp);\n            this.tempBuff.push(cp);\n        } else {\n            if (this.lastStartTagName === this.currentToken.tagName) {\n                if (isWhitespace(cp)) {\n                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;\n                    return;\n                }\n\n                if (cp === $.SOLIDUS) {\n                    this.state = SELF_CLOSING_START_TAG_STATE;\n                    return;\n                }\n\n                if (cp === $.GREATER_THAN_SIGN) {\n                    this._emitCurrentToken();\n                    this.state = DATA_STATE;\n                    return;\n                }\n            }\n\n            this._emitChars('</');\n            this._emitSeveralCodePoints(this.tempBuff);\n            this._reconsumeInState(RAWTEXT_STATE);\n        }\n    }\n\n    // Script data less-than sign state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_LESS_THAN_SIGN_STATE](cp) {\n        if (cp === $.SOLIDUS) {\n            this.tempBuff = [];\n            this.state = SCRIPT_DATA_END_TAG_OPEN_STATE;\n        } else if (cp === $.EXCLAMATION_MARK) {\n            this.state = SCRIPT_DATA_ESCAPE_START_STATE;\n            this._emitChars('<!');\n        } else {\n            this._emitChars('<');\n            this._reconsumeInState(SCRIPT_DATA_STATE);\n        }\n    }\n\n    // Script data end tag open state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_END_TAG_OPEN_STATE](cp) {\n        if (isAsciiLetter(cp)) {\n            this._createEndTagToken();\n            this._reconsumeInState(SCRIPT_DATA_END_TAG_NAME_STATE);\n        } else {\n            this._emitChars('</');\n            this._reconsumeInState(SCRIPT_DATA_STATE);\n        }\n    }\n\n    // Script data end tag name state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_END_TAG_NAME_STATE](cp) {\n        if (isAsciiUpper(cp)) {\n            this.currentToken.tagName += toAsciiLowerChar(cp);\n            this.tempBuff.push(cp);\n        } else if (isAsciiLower(cp)) {\n            this.currentToken.tagName += toChar(cp);\n            this.tempBuff.push(cp);\n        } else {\n            if (this.lastStartTagName === this.currentToken.tagName) {\n                if (isWhitespace(cp)) {\n                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;\n                    return;\n                } else if (cp === $.SOLIDUS) {\n                    this.state = SELF_CLOSING_START_TAG_STATE;\n                    return;\n                } else if (cp === $.GREATER_THAN_SIGN) {\n                    this._emitCurrentToken();\n                    this.state = DATA_STATE;\n                    return;\n                }\n            }\n\n            this._emitChars('</');\n            this._emitSeveralCodePoints(this.tempBuff);\n            this._reconsumeInState(SCRIPT_DATA_STATE);\n        }\n    }\n\n    // Script data escape start state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_ESCAPE_START_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = SCRIPT_DATA_ESCAPE_START_DASH_STATE;\n            this._emitChars('-');\n        } else {\n            this._reconsumeInState(SCRIPT_DATA_STATE);\n        }\n    }\n\n    // Script data escape start dash state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_ESCAPE_START_DASH_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;\n            this._emitChars('-');\n        } else {\n            this._reconsumeInState(SCRIPT_DATA_STATE);\n        }\n    }\n\n    // Script data escaped state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_ESCAPED_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = SCRIPT_DATA_ESCAPED_DASH_STATE;\n            this._emitChars('-');\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInScriptHtmlCommentLikeText);\n            this._emitEOFToken();\n        } else {\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // Script data escaped dash state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_ESCAPED_DASH_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;\n            this._emitChars('-');\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.state = SCRIPT_DATA_ESCAPED_STATE;\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInScriptHtmlCommentLikeText);\n            this._emitEOFToken();\n        } else {\n            this.state = SCRIPT_DATA_ESCAPED_STATE;\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // Script data escaped dash dash state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_ESCAPED_DASH_DASH_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this._emitChars('-');\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this.state = SCRIPT_DATA_STATE;\n            this._emitChars('>');\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.state = SCRIPT_DATA_ESCAPED_STATE;\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInScriptHtmlCommentLikeText);\n            this._emitEOFToken();\n        } else {\n            this.state = SCRIPT_DATA_ESCAPED_STATE;\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // Script data escaped less-than sign state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE](cp) {\n        if (cp === $.SOLIDUS) {\n            this.tempBuff = [];\n            this.state = SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE;\n        } else if (isAsciiLetter(cp)) {\n            this.tempBuff = [];\n            this._emitChars('<');\n            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE);\n        } else {\n            this._emitChars('<');\n            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);\n        }\n    }\n\n    // Script data escaped end tag open state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE](cp) {\n        if (isAsciiLetter(cp)) {\n            this._createEndTagToken();\n            this._reconsumeInState(SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE);\n        } else {\n            this._emitChars('</');\n            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);\n        }\n    }\n\n    // Script data escaped end tag name state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE](cp) {\n        if (isAsciiUpper(cp)) {\n            this.currentToken.tagName += toAsciiLowerChar(cp);\n            this.tempBuff.push(cp);\n        } else if (isAsciiLower(cp)) {\n            this.currentToken.tagName += toChar(cp);\n            this.tempBuff.push(cp);\n        } else {\n            if (this.lastStartTagName === this.currentToken.tagName) {\n                if (isWhitespace(cp)) {\n                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;\n                    return;\n                }\n\n                if (cp === $.SOLIDUS) {\n                    this.state = SELF_CLOSING_START_TAG_STATE;\n                    return;\n                }\n\n                if (cp === $.GREATER_THAN_SIGN) {\n                    this._emitCurrentToken();\n                    this.state = DATA_STATE;\n                    return;\n                }\n            }\n\n            this._emitChars('</');\n            this._emitSeveralCodePoints(this.tempBuff);\n            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);\n        }\n    }\n\n    // Script data double escape start state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE](cp) {\n        if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {\n            this.state = this._isTempBufferEqualToScriptString()\n                ? SCRIPT_DATA_DOUBLE_ESCAPED_STATE\n                : SCRIPT_DATA_ESCAPED_STATE;\n            this._emitCodePoint(cp);\n        } else if (isAsciiUpper(cp)) {\n            this.tempBuff.push(toAsciiLowerCodePoint(cp));\n            this._emitCodePoint(cp);\n        } else if (isAsciiLower(cp)) {\n            this.tempBuff.push(cp);\n            this._emitCodePoint(cp);\n        } else {\n            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);\n        }\n    }\n\n    // Script data double escaped state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_DOUBLE_ESCAPED_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE;\n            this._emitChars('-');\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;\n            this._emitChars('<');\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInScriptHtmlCommentLikeText);\n            this._emitEOFToken();\n        } else {\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // Script data double escaped dash state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE;\n            this._emitChars('-');\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;\n            this._emitChars('<');\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInScriptHtmlCommentLikeText);\n            this._emitEOFToken();\n        } else {\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // Script data double escaped dash dash state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this._emitChars('-');\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;\n            this._emitChars('<');\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this.state = SCRIPT_DATA_STATE;\n            this._emitChars('>');\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;\n            this._emitChars(unicode.REPLACEMENT_CHARACTER);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInScriptHtmlCommentLikeText);\n            this._emitEOFToken();\n        } else {\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // Script data double escaped less-than sign state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE](cp) {\n        if (cp === $.SOLIDUS) {\n            this.tempBuff = [];\n            this.state = SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE;\n            this._emitChars('/');\n        } else {\n            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);\n        }\n    }\n\n    // Script data double escape end state\n    //------------------------------------------------------------------\n    [SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE](cp) {\n        if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {\n            this.state = this._isTempBufferEqualToScriptString()\n                ? SCRIPT_DATA_ESCAPED_STATE\n                : SCRIPT_DATA_DOUBLE_ESCAPED_STATE;\n\n            this._emitCodePoint(cp);\n        } else if (isAsciiUpper(cp)) {\n            this.tempBuff.push(toAsciiLowerCodePoint(cp));\n            this._emitCodePoint(cp);\n        } else if (isAsciiLower(cp)) {\n            this.tempBuff.push(cp);\n            this._emitCodePoint(cp);\n        } else {\n            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);\n        }\n    }\n\n    // Before attribute name state\n    //------------------------------------------------------------------\n    [BEFORE_ATTRIBUTE_NAME_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {\n            this._reconsumeInState(AFTER_ATTRIBUTE_NAME_STATE);\n        } else if (cp === $.EQUALS_SIGN) {\n            this._err(ERR.unexpectedEqualsSignBeforeAttributeName);\n            this._createAttr('=');\n            this.state = ATTRIBUTE_NAME_STATE;\n        } else {\n            this._createAttr('');\n            this._reconsumeInState(ATTRIBUTE_NAME_STATE);\n        }\n    }\n\n    // Attribute name state\n    //------------------------------------------------------------------\n    [ATTRIBUTE_NAME_STATE](cp) {\n        if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {\n            this._leaveAttrName(AFTER_ATTRIBUTE_NAME_STATE);\n            this._unconsume();\n        } else if (cp === $.EQUALS_SIGN) {\n            this._leaveAttrName(BEFORE_ATTRIBUTE_VALUE_STATE);\n        } else if (isAsciiUpper(cp)) {\n            this.currentAttr.name += toAsciiLowerChar(cp);\n        } else if (cp === $.QUOTATION_MARK || cp === $.APOSTROPHE || cp === $.LESS_THAN_SIGN) {\n            this._err(ERR.unexpectedCharacterInAttributeName);\n            this.currentAttr.name += toChar(cp);\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentAttr.name += unicode.REPLACEMENT_CHARACTER;\n        } else {\n            this.currentAttr.name += toChar(cp);\n        }\n    }\n\n    // After attribute name state\n    //------------------------------------------------------------------\n    [AFTER_ATTRIBUTE_NAME_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (cp === $.SOLIDUS) {\n            this.state = SELF_CLOSING_START_TAG_STATE;\n        } else if (cp === $.EQUALS_SIGN) {\n            this.state = BEFORE_ATTRIBUTE_VALUE_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInTag);\n            this._emitEOFToken();\n        } else {\n            this._createAttr('');\n            this._reconsumeInState(ATTRIBUTE_NAME_STATE);\n        }\n    }\n\n    // Before attribute value state\n    //------------------------------------------------------------------\n    [BEFORE_ATTRIBUTE_VALUE_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (cp === $.QUOTATION_MARK) {\n            this.state = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;\n        } else if (cp === $.APOSTROPHE) {\n            this.state = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.missingAttributeValue);\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else {\n            this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_STATE);\n        }\n    }\n\n    // Attribute value (double-quoted) state\n    //------------------------------------------------------------------\n    [ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE](cp) {\n        if (cp === $.QUOTATION_MARK) {\n            this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;\n        } else if (cp === $.AMPERSAND) {\n            this.returnState = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;\n            this.state = CHARACTER_REFERENCE_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInTag);\n            this._emitEOFToken();\n        } else {\n            this.currentAttr.value += toChar(cp);\n        }\n    }\n\n    // Attribute value (single-quoted) state\n    //------------------------------------------------------------------\n    [ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE](cp) {\n        if (cp === $.APOSTROPHE) {\n            this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;\n        } else if (cp === $.AMPERSAND) {\n            this.returnState = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;\n            this.state = CHARACTER_REFERENCE_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInTag);\n            this._emitEOFToken();\n        } else {\n            this.currentAttr.value += toChar(cp);\n        }\n    }\n\n    // Attribute value (unquoted) state\n    //------------------------------------------------------------------\n    [ATTRIBUTE_VALUE_UNQUOTED_STATE](cp) {\n        if (isWhitespace(cp)) {\n            this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);\n        } else if (cp === $.AMPERSAND) {\n            this.returnState = ATTRIBUTE_VALUE_UNQUOTED_STATE;\n            this.state = CHARACTER_REFERENCE_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._leaveAttrValue(DATA_STATE);\n            this._emitCurrentToken();\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;\n        } else if (\n            cp === $.QUOTATION_MARK ||\n            cp === $.APOSTROPHE ||\n            cp === $.LESS_THAN_SIGN ||\n            cp === $.EQUALS_SIGN ||\n            cp === $.GRAVE_ACCENT\n        ) {\n            this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);\n            this.currentAttr.value += toChar(cp);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInTag);\n            this._emitEOFToken();\n        } else {\n            this.currentAttr.value += toChar(cp);\n        }\n    }\n\n    // After attribute value (quoted) state\n    //------------------------------------------------------------------\n    [AFTER_ATTRIBUTE_VALUE_QUOTED_STATE](cp) {\n        if (isWhitespace(cp)) {\n            this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);\n        } else if (cp === $.SOLIDUS) {\n            this._leaveAttrValue(SELF_CLOSING_START_TAG_STATE);\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._leaveAttrValue(DATA_STATE);\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInTag);\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.missingWhitespaceBetweenAttributes);\n            this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);\n        }\n    }\n\n    // Self-closing start tag state\n    //------------------------------------------------------------------\n    [SELF_CLOSING_START_TAG_STATE](cp) {\n        if (cp === $.GREATER_THAN_SIGN) {\n            this.currentToken.selfClosing = true;\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInTag);\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.unexpectedSolidusInTag);\n            this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);\n        }\n    }\n\n    // Bogus comment state\n    //------------------------------------------------------------------\n    [BOGUS_COMMENT_STATE](cp) {\n        if (cp === $.GREATER_THAN_SIGN) {\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentToken.data += unicode.REPLACEMENT_CHARACTER;\n        } else {\n            this.currentToken.data += toChar(cp);\n        }\n    }\n\n    // Markup declaration open state\n    //------------------------------------------------------------------\n    [MARKUP_DECLARATION_OPEN_STATE](cp) {\n        if (this._consumeSequenceIfMatch($$.DASH_DASH_STRING, cp, true)) {\n            this._createCommentToken();\n            this.state = COMMENT_START_STATE;\n        } else if (this._consumeSequenceIfMatch($$.DOCTYPE_STRING, cp, false)) {\n            this.state = DOCTYPE_STATE;\n        } else if (this._consumeSequenceIfMatch($$.CDATA_START_STRING, cp, true)) {\n            if (this.allowCDATA) {\n                this.state = CDATA_SECTION_STATE;\n            } else {\n                this._err(ERR.cdataInHtmlContent);\n                this._createCommentToken();\n                this.currentToken.data = '[CDATA[';\n                this.state = BOGUS_COMMENT_STATE;\n            }\n        }\n\n        //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup\n        //results are no longer valid and we will need to start over.\n        else if (!this._ensureHibernation()) {\n            this._err(ERR.incorrectlyOpenedComment);\n            this._createCommentToken();\n            this._reconsumeInState(BOGUS_COMMENT_STATE);\n        }\n    }\n\n    // Comment start state\n    //------------------------------------------------------------------\n    [COMMENT_START_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = COMMENT_START_DASH_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.abruptClosingOfEmptyComment);\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else {\n            this._reconsumeInState(COMMENT_STATE);\n        }\n    }\n\n    // Comment start dash state\n    //------------------------------------------------------------------\n    [COMMENT_START_DASH_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = COMMENT_END_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.abruptClosingOfEmptyComment);\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInComment);\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.data += '-';\n            this._reconsumeInState(COMMENT_STATE);\n        }\n    }\n\n    // Comment state\n    //------------------------------------------------------------------\n    [COMMENT_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = COMMENT_END_DASH_STATE;\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.currentToken.data += '<';\n            this.state = COMMENT_LESS_THAN_SIGN_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentToken.data += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInComment);\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.data += toChar(cp);\n        }\n    }\n\n    // Comment less-than sign state\n    //------------------------------------------------------------------\n    [COMMENT_LESS_THAN_SIGN_STATE](cp) {\n        if (cp === $.EXCLAMATION_MARK) {\n            this.currentToken.data += '!';\n            this.state = COMMENT_LESS_THAN_SIGN_BANG_STATE;\n        } else if (cp === $.LESS_THAN_SIGN) {\n            this.currentToken.data += '!';\n        } else {\n            this._reconsumeInState(COMMENT_STATE);\n        }\n    }\n\n    // Comment less-than sign bang state\n    //------------------------------------------------------------------\n    [COMMENT_LESS_THAN_SIGN_BANG_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE;\n        } else {\n            this._reconsumeInState(COMMENT_STATE);\n        }\n    }\n\n    // Comment less-than sign bang dash state\n    //------------------------------------------------------------------\n    [COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE;\n        } else {\n            this._reconsumeInState(COMMENT_END_DASH_STATE);\n        }\n    }\n\n    // Comment less-than sign bang dash dash state\n    //------------------------------------------------------------------\n    [COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE](cp) {\n        if (cp !== $.GREATER_THAN_SIGN && cp !== $.EOF) {\n            this._err(ERR.nestedComment);\n        }\n\n        this._reconsumeInState(COMMENT_END_STATE);\n    }\n\n    // Comment end dash state\n    //------------------------------------------------------------------\n    [COMMENT_END_DASH_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = COMMENT_END_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInComment);\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.data += '-';\n            this._reconsumeInState(COMMENT_STATE);\n        }\n    }\n\n    // Comment end state\n    //------------------------------------------------------------------\n    [COMMENT_END_STATE](cp) {\n        if (cp === $.GREATER_THAN_SIGN) {\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EXCLAMATION_MARK) {\n            this.state = COMMENT_END_BANG_STATE;\n        } else if (cp === $.HYPHEN_MINUS) {\n            this.currentToken.data += '-';\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInComment);\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.data += '--';\n            this._reconsumeInState(COMMENT_STATE);\n        }\n    }\n\n    // Comment end bang state\n    //------------------------------------------------------------------\n    [COMMENT_END_BANG_STATE](cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.currentToken.data += '--!';\n            this.state = COMMENT_END_DASH_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.incorrectlyClosedComment);\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInComment);\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.data += '--!';\n            this._reconsumeInState(COMMENT_STATE);\n        }\n    }\n\n    // DOCTYPE state\n    //------------------------------------------------------------------\n    [DOCTYPE_STATE](cp) {\n        if (isWhitespace(cp)) {\n            this.state = BEFORE_DOCTYPE_NAME_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this._createDoctypeToken(null);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.missingWhitespaceBeforeDoctypeName);\n            this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);\n        }\n    }\n\n    // Before DOCTYPE name state\n    //------------------------------------------------------------------\n    [BEFORE_DOCTYPE_NAME_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (isAsciiUpper(cp)) {\n            this._createDoctypeToken(toAsciiLowerChar(cp));\n            this.state = DOCTYPE_NAME_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this._createDoctypeToken(unicode.REPLACEMENT_CHARACTER);\n            this.state = DOCTYPE_NAME_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.missingDoctypeName);\n            this._createDoctypeToken(null);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this.state = DATA_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this._createDoctypeToken(null);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._createDoctypeToken(toChar(cp));\n            this.state = DOCTYPE_NAME_STATE;\n        }\n    }\n\n    // DOCTYPE name state\n    //------------------------------------------------------------------\n    [DOCTYPE_NAME_STATE](cp) {\n        if (isWhitespace(cp)) {\n            this.state = AFTER_DOCTYPE_NAME_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (isAsciiUpper(cp)) {\n            this.currentToken.name += toAsciiLowerChar(cp);\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentToken.name += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.name += toChar(cp);\n        }\n    }\n\n    // After DOCTYPE name state\n    //------------------------------------------------------------------\n    [AFTER_DOCTYPE_NAME_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (cp === $.GREATER_THAN_SIGN) {\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else if (this._consumeSequenceIfMatch($$.PUBLIC_STRING, cp, false)) {\n            this.state = AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE;\n        } else if (this._consumeSequenceIfMatch($$.SYSTEM_STRING, cp, false)) {\n            this.state = AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE;\n        }\n        //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup\n        //results are no longer valid and we will need to start over.\n        else if (!this._ensureHibernation()) {\n            this._err(ERR.invalidCharacterSequenceAfterDoctypeName);\n            this.currentToken.forceQuirks = true;\n            this._reconsumeInState(BOGUS_DOCTYPE_STATE);\n        }\n    }\n\n    // After DOCTYPE public keyword state\n    //------------------------------------------------------------------\n    [AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE](cp) {\n        if (isWhitespace(cp)) {\n            this.state = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;\n        } else if (cp === $.QUOTATION_MARK) {\n            this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);\n            this.currentToken.publicId = '';\n            this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;\n        } else if (cp === $.APOSTROPHE) {\n            this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);\n            this.currentToken.publicId = '';\n            this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.missingDoctypePublicIdentifier);\n            this.currentToken.forceQuirks = true;\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._reconsumeInState(BOGUS_DOCTYPE_STATE);\n        }\n    }\n\n    // Before DOCTYPE public identifier state\n    //------------------------------------------------------------------\n    [BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (cp === $.QUOTATION_MARK) {\n            this.currentToken.publicId = '';\n            this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;\n        } else if (cp === $.APOSTROPHE) {\n            this.currentToken.publicId = '';\n            this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.missingDoctypePublicIdentifier);\n            this.currentToken.forceQuirks = true;\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._reconsumeInState(BOGUS_DOCTYPE_STATE);\n        }\n    }\n\n    // DOCTYPE public identifier (double-quoted) state\n    //------------------------------------------------------------------\n    [DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {\n        if (cp === $.QUOTATION_MARK) {\n            this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentToken.publicId += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.abruptDoctypePublicIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this.state = DATA_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.publicId += toChar(cp);\n        }\n    }\n\n    // DOCTYPE public identifier (single-quoted) state\n    //------------------------------------------------------------------\n    [DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {\n        if (cp === $.APOSTROPHE) {\n            this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentToken.publicId += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.abruptDoctypePublicIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this.state = DATA_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.publicId += toChar(cp);\n        }\n    }\n\n    // After DOCTYPE public identifier state\n    //------------------------------------------------------------------\n    [AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {\n        if (isWhitespace(cp)) {\n            this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.QUOTATION_MARK) {\n            this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);\n            this.currentToken.systemId = '';\n            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;\n        } else if (cp === $.APOSTROPHE) {\n            this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);\n            this.currentToken.systemId = '';\n            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._reconsumeInState(BOGUS_DOCTYPE_STATE);\n        }\n    }\n\n    // Between DOCTYPE public and system identifiers state\n    //------------------------------------------------------------------\n    [BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (cp === $.GREATER_THAN_SIGN) {\n            this._emitCurrentToken();\n            this.state = DATA_STATE;\n        } else if (cp === $.QUOTATION_MARK) {\n            this.currentToken.systemId = '';\n            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;\n        } else if (cp === $.APOSTROPHE) {\n            this.currentToken.systemId = '';\n            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._reconsumeInState(BOGUS_DOCTYPE_STATE);\n        }\n    }\n\n    // After DOCTYPE system keyword state\n    //------------------------------------------------------------------\n    [AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE](cp) {\n        if (isWhitespace(cp)) {\n            this.state = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;\n        } else if (cp === $.QUOTATION_MARK) {\n            this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);\n            this.currentToken.systemId = '';\n            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;\n        } else if (cp === $.APOSTROPHE) {\n            this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);\n            this.currentToken.systemId = '';\n            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.missingDoctypeSystemIdentifier);\n            this.currentToken.forceQuirks = true;\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._reconsumeInState(BOGUS_DOCTYPE_STATE);\n        }\n    }\n\n    // Before DOCTYPE system identifier state\n    //------------------------------------------------------------------\n    [BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (cp === $.QUOTATION_MARK) {\n            this.currentToken.systemId = '';\n            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;\n        } else if (cp === $.APOSTROPHE) {\n            this.currentToken.systemId = '';\n            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.missingDoctypeSystemIdentifier);\n            this.currentToken.forceQuirks = true;\n            this.state = DATA_STATE;\n            this._emitCurrentToken();\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._reconsumeInState(BOGUS_DOCTYPE_STATE);\n        }\n    }\n\n    // DOCTYPE system identifier (double-quoted) state\n    //------------------------------------------------------------------\n    [DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {\n        if (cp === $.QUOTATION_MARK) {\n            this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentToken.systemId += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.abruptDoctypeSystemIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this.state = DATA_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.systemId += toChar(cp);\n        }\n    }\n\n    // DOCTYPE system identifier (single-quoted) state\n    //------------------------------------------------------------------\n    [DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {\n        if (cp === $.APOSTROPHE) {\n            this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n            this.currentToken.systemId += unicode.REPLACEMENT_CHARACTER;\n        } else if (cp === $.GREATER_THAN_SIGN) {\n            this._err(ERR.abruptDoctypeSystemIdentifier);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this.state = DATA_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this.currentToken.systemId += toChar(cp);\n        }\n    }\n\n    // After DOCTYPE system identifier state\n    //------------------------------------------------------------------\n    [AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {\n        if (isWhitespace(cp)) {\n            return;\n        }\n\n        if (cp === $.GREATER_THAN_SIGN) {\n            this._emitCurrentToken();\n            this.state = DATA_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInDoctype);\n            this.currentToken.forceQuirks = true;\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        } else {\n            this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);\n            this._reconsumeInState(BOGUS_DOCTYPE_STATE);\n        }\n    }\n\n    // Bogus DOCTYPE state\n    //------------------------------------------------------------------\n    [BOGUS_DOCTYPE_STATE](cp) {\n        if (cp === $.GREATER_THAN_SIGN) {\n            this._emitCurrentToken();\n            this.state = DATA_STATE;\n        } else if (cp === $.NULL) {\n            this._err(ERR.unexpectedNullCharacter);\n        } else if (cp === $.EOF) {\n            this._emitCurrentToken();\n            this._emitEOFToken();\n        }\n    }\n\n    // CDATA section state\n    //------------------------------------------------------------------\n    [CDATA_SECTION_STATE](cp) {\n        if (cp === $.RIGHT_SQUARE_BRACKET) {\n            this.state = CDATA_SECTION_BRACKET_STATE;\n        } else if (cp === $.EOF) {\n            this._err(ERR.eofInCdata);\n            this._emitEOFToken();\n        } else {\n            this._emitCodePoint(cp);\n        }\n    }\n\n    // CDATA section bracket state\n    //------------------------------------------------------------------\n    [CDATA_SECTION_BRACKET_STATE](cp) {\n        if (cp === $.RIGHT_SQUARE_BRACKET) {\n            this.state = CDATA_SECTION_END_STATE;\n        } else {\n            this._emitChars(']');\n            this._reconsumeInState(CDATA_SECTION_STATE);\n        }\n    }\n\n    // CDATA section end state\n    //------------------------------------------------------------------\n    [CDATA_SECTION_END_STATE](cp) {\n        if (cp === $.GREATER_THAN_SIGN) {\n            this.state = DATA_STATE;\n        } else if (cp === $.RIGHT_SQUARE_BRACKET) {\n            this._emitChars(']');\n        } else {\n            this._emitChars(']]');\n            this._reconsumeInState(CDATA_SECTION_STATE);\n        }\n    }\n\n    // Character reference state\n    //------------------------------------------------------------------\n    [CHARACTER_REFERENCE_STATE](cp) {\n        this.tempBuff = [$.AMPERSAND];\n\n        if (cp === $.NUMBER_SIGN) {\n            this.tempBuff.push(cp);\n            this.state = NUMERIC_CHARACTER_REFERENCE_STATE;\n        } else if (isAsciiAlphaNumeric(cp)) {\n            this._reconsumeInState(NAMED_CHARACTER_REFERENCE_STATE);\n        } else {\n            this._flushCodePointsConsumedAsCharacterReference();\n            this._reconsumeInState(this.returnState);\n        }\n    }\n\n    // Named character reference state\n    //------------------------------------------------------------------\n    [NAMED_CHARACTER_REFERENCE_STATE](cp) {\n        const matchResult = this._matchNamedCharacterReference(cp);\n\n        //NOTE: matching can be abrupted by hibernation. In that case match\n        //results are no longer valid and we will need to start over.\n        if (this._ensureHibernation()) {\n            this.tempBuff = [$.AMPERSAND];\n        } else if (matchResult) {\n            const withSemicolon = this.tempBuff[this.tempBuff.length - 1] === $.SEMICOLON;\n\n            if (!this._isCharacterReferenceAttributeQuirk(withSemicolon)) {\n                if (!withSemicolon) {\n                    this._errOnNextCodePoint(ERR.missingSemicolonAfterCharacterReference);\n                }\n\n                this.tempBuff = matchResult;\n            }\n\n            this._flushCodePointsConsumedAsCharacterReference();\n            this.state = this.returnState;\n        } else {\n            this._flushCodePointsConsumedAsCharacterReference();\n            this.state = AMBIGUOUS_AMPERSAND_STATE;\n        }\n    }\n\n    // Ambiguos ampersand state\n    //------------------------------------------------------------------\n    [AMBIGUOUS_AMPERSAND_STATE](cp) {\n        if (isAsciiAlphaNumeric(cp)) {\n            if (this._isCharacterReferenceInAttribute()) {\n                this.currentAttr.value += toChar(cp);\n            } else {\n                this._emitCodePoint(cp);\n            }\n        } else {\n            if (cp === $.SEMICOLON) {\n                this._err(ERR.unknownNamedCharacterReference);\n            }\n\n            this._reconsumeInState(this.returnState);\n        }\n    }\n\n    // Numeric character reference state\n    //------------------------------------------------------------------\n    [NUMERIC_CHARACTER_REFERENCE_STATE](cp) {\n        this.charRefCode = 0;\n\n        if (cp === $.LATIN_SMALL_X || cp === $.LATIN_CAPITAL_X) {\n            this.tempBuff.push(cp);\n            this.state = HEXADEMICAL_CHARACTER_REFERENCE_START_STATE;\n        } else {\n            this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_START_STATE);\n        }\n    }\n\n    // Hexademical character reference start state\n    //------------------------------------------------------------------\n    [HEXADEMICAL_CHARACTER_REFERENCE_START_STATE](cp) {\n        if (isAsciiHexDigit(cp)) {\n            this._reconsumeInState(HEXADEMICAL_CHARACTER_REFERENCE_STATE);\n        } else {\n            this._err(ERR.absenceOfDigitsInNumericCharacterReference);\n            this._flushCodePointsConsumedAsCharacterReference();\n            this._reconsumeInState(this.returnState);\n        }\n    }\n\n    // Decimal character reference start state\n    //------------------------------------------------------------------\n    [DECIMAL_CHARACTER_REFERENCE_START_STATE](cp) {\n        if (isAsciiDigit(cp)) {\n            this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_STATE);\n        } else {\n            this._err(ERR.absenceOfDigitsInNumericCharacterReference);\n            this._flushCodePointsConsumedAsCharacterReference();\n            this._reconsumeInState(this.returnState);\n        }\n    }\n\n    // Hexademical character reference state\n    //------------------------------------------------------------------\n    [HEXADEMICAL_CHARACTER_REFERENCE_STATE](cp) {\n        if (isAsciiUpperHexDigit(cp)) {\n            this.charRefCode = this.charRefCode * 16 + cp - 0x37;\n        } else if (isAsciiLowerHexDigit(cp)) {\n            this.charRefCode = this.charRefCode * 16 + cp - 0x57;\n        } else if (isAsciiDigit(cp)) {\n            this.charRefCode = this.charRefCode * 16 + cp - 0x30;\n        } else if (cp === $.SEMICOLON) {\n            this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;\n        } else {\n            this._err(ERR.missingSemicolonAfterCharacterReference);\n            this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);\n        }\n    }\n\n    // Decimal character reference state\n    //------------------------------------------------------------------\n    [DECIMAL_CHARACTER_REFERENCE_STATE](cp) {\n        if (isAsciiDigit(cp)) {\n            this.charRefCode = this.charRefCode * 10 + cp - 0x30;\n        } else if (cp === $.SEMICOLON) {\n            this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;\n        } else {\n            this._err(ERR.missingSemicolonAfterCharacterReference);\n            this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);\n        }\n    }\n\n    // Numeric character reference end state\n    //------------------------------------------------------------------\n    [NUMERIC_CHARACTER_REFERENCE_END_STATE]() {\n        if (this.charRefCode === $.NULL) {\n            this._err(ERR.nullCharacterReference);\n            this.charRefCode = $.REPLACEMENT_CHARACTER;\n        } else if (this.charRefCode > 0x10ffff) {\n            this._err(ERR.characterReferenceOutsideUnicodeRange);\n            this.charRefCode = $.REPLACEMENT_CHARACTER;\n        } else if (unicode.isSurrogate(this.charRefCode)) {\n            this._err(ERR.surrogateCharacterReference);\n            this.charRefCode = $.REPLACEMENT_CHARACTER;\n        } else if (unicode.isUndefinedCodePoint(this.charRefCode)) {\n            this._err(ERR.noncharacterCharacterReference);\n        } else if (unicode.isControlCodePoint(this.charRefCode) || this.charRefCode === $.CARRIAGE_RETURN) {\n            this._err(ERR.controlCharacterReference);\n\n            const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS[this.charRefCode];\n\n            if (replacement) {\n                this.charRefCode = replacement;\n            }\n        }\n\n        this.tempBuff = [this.charRefCode];\n\n        this._flushCodePointsConsumedAsCharacterReference();\n        this._reconsumeInState(this.returnState);\n    }\n}\n\n//Token types\nTokenizer.CHARACTER_TOKEN = 'CHARACTER_TOKEN';\nTokenizer.NULL_CHARACTER_TOKEN = 'NULL_CHARACTER_TOKEN';\nTokenizer.WHITESPACE_CHARACTER_TOKEN = 'WHITESPACE_CHARACTER_TOKEN';\nTokenizer.START_TAG_TOKEN = 'START_TAG_TOKEN';\nTokenizer.END_TAG_TOKEN = 'END_TAG_TOKEN';\nTokenizer.COMMENT_TOKEN = 'COMMENT_TOKEN';\nTokenizer.DOCTYPE_TOKEN = 'DOCTYPE_TOKEN';\nTokenizer.EOF_TOKEN = 'EOF_TOKEN';\nTokenizer.HIBERNATION_TOKEN = 'HIBERNATION_TOKEN';\n\n//Tokenizer initial states for different modes\nTokenizer.MODE = {\n    DATA: DATA_STATE,\n    RCDATA: RCDATA_STATE,\n    RAWTEXT: RAWTEXT_STATE,\n    SCRIPT_DATA: SCRIPT_DATA_STATE,\n    PLAINTEXT: PLAINTEXT_STATE\n};\n\n//Static\nTokenizer.getTokenAttr = function(token, attrName) {\n    for (let i = token.attrs.length - 1; i >= 0; i--) {\n        if (token.attrs[i].name === attrName) {\n            return token.attrs[i].value;\n        }\n    }\n\n    return null;\n};\n\nmodule.exports = Tokenizer;\n","'use strict';\n\n//NOTE: this file contains auto-generated array mapped radix tree that is used for the named entity references consumption\n//(details: https://github.com/inikulin/parse5/tree/master/scripts/generate-named-entity-data/README.md)\nmodule.exports = new Uint16Array([4,52,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,106,303,412,810,1432,1701,1796,1987,2114,2360,2420,2484,3170,3251,4140,4393,4575,4610,5106,5512,5728,6117,6274,6315,6345,6427,6516,7002,7910,8733,9323,9870,10170,10631,10893,11318,11386,11467,12773,13092,14474,14922,15448,15542,16419,17666,18166,18611,19004,19095,19298,19397,4,16,69,77,97,98,99,102,103,108,109,110,111,112,114,115,116,117,140,150,158,169,176,194,199,210,216,222,226,242,256,266,283,294,108,105,103,5,198,1,59,148,1,198,80,5,38,1,59,156,1,38,99,117,116,101,5,193,1,59,167,1,193,114,101,118,101,59,1,258,4,2,105,121,182,191,114,99,5,194,1,59,189,1,194,59,1,1040,114,59,3,55349,56580,114,97,118,101,5,192,1,59,208,1,192,112,104,97,59,1,913,97,99,114,59,1,256,100,59,1,10835,4,2,103,112,232,237,111,110,59,1,260,102,59,3,55349,56632,112,108,121,70,117,110,99,116,105,111,110,59,1,8289,105,110,103,5,197,1,59,264,1,197,4,2,99,115,272,277,114,59,3,55349,56476,105,103,110,59,1,8788,105,108,100,101,5,195,1,59,292,1,195,109,108,5,196,1,59,301,1,196,4,8,97,99,101,102,111,114,115,117,321,350,354,383,388,394,400,405,4,2,99,114,327,336,107,115,108,97,115,104,59,1,8726,4,2,118,119,342,345,59,1,10983,101,100,59,1,8966,121,59,1,1041,4,3,99,114,116,362,369,379,97,117,115,101,59,1,8757,110,111,117,108,108,105,115,59,1,8492,97,59,1,914,114,59,3,55349,56581,112,102,59,3,55349,56633,101,118,101,59,1,728,99,114,59,1,8492,109,112,101,113,59,1,8782,4,14,72,79,97,99,100,101,102,104,105,108,111,114,115,117,442,447,456,504,542,547,569,573,577,616,678,784,790,796,99,121,59,1,1063,80,89,5,169,1,59,454,1,169,4,3,99,112,121,464,470,497,117,116,101,59,1,262,4,2,59,105,476,478,1,8914,116,97,108,68,105,102,102,101,114,101,110,116,105,97,108,68,59,1,8517,108,101,121,115,59,1,8493,4,4,97,101,105,111,514,520,530,535,114,111,110,59,1,268,100,105,108,5,199,1,59,528,1,199,114,99,59,1,264,110,105,110,116,59,1,8752,111,116,59,1,266,4,2,100,110,553,560,105,108,108,97,59,1,184,116,101,114,68,111,116,59,1,183,114,59,1,8493,105,59,1,935,114,99,108,101,4,4,68,77,80,84,591,596,603,609,111,116,59,1,8857,105,110,117,115,59,1,8854,108,117,115,59,1,8853,105,109,101,115,59,1,8855,111,4,2,99,115,623,646,107,119,105,115,101,67,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8754,101,67,117,114,108,121,4,2,68,81,658,671,111,117,98,108,101,81,117,111,116,101,59,1,8221,117,111,116,101,59,1,8217,4,4,108,110,112,117,688,701,736,753,111,110,4,2,59,101,696,698,1,8759,59,1,10868,4,3,103,105,116,709,717,722,114,117,101,110,116,59,1,8801,110,116,59,1,8751,111,117,114,73,110,116,101,103,114,97,108,59,1,8750,4,2,102,114,742,745,59,1,8450,111,100,117,99,116,59,1,8720,110,116,101,114,67,108,111,99,107,119,105,115,101,67,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8755,111,115,115,59,1,10799,99,114,59,3,55349,56478,112,4,2,59,67,803,805,1,8915,97,112,59,1,8781,4,11,68,74,83,90,97,99,101,102,105,111,115,834,850,855,860,865,888,903,916,921,1011,1415,4,2,59,111,840,842,1,8517,116,114,97,104,100,59,1,10513,99,121,59,1,1026,99,121,59,1,1029,99,121,59,1,1039,4,3,103,114,115,873,879,883,103,101,114,59,1,8225,114,59,1,8609,104,118,59,1,10980,4,2,97,121,894,900,114,111,110,59,1,270,59,1,1044,108,4,2,59,116,910,912,1,8711,97,59,1,916,114,59,3,55349,56583,4,2,97,102,927,998,4,2,99,109,933,992,114,105,116,105,99,97,108,4,4,65,68,71,84,950,957,978,985,99,117,116,101,59,1,180,111,4,2,116,117,964,967,59,1,729,98,108,101,65,99,117,116,101,59,1,733,114,97,118,101,59,1,96,105,108,100,101,59,1,732,111,110,100,59,1,8900,102,101,114,101,110,116,105,97,108,68,59,1,8518,4,4,112,116,117,119,1021,1026,1048,1249,102,59,3,55349,56635,4,3,59,68,69,1034,1036,1041,1,168,111,116,59,1,8412,113,117,97,108,59,1,8784,98,108,101,4,6,67,68,76,82,85,86,1065,1082,1101,1189,1211,1236,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8751,111,4,2,116,119,1089,1092,59,1,168,110,65,114,114,111,119,59,1,8659,4,2,101,111,1107,1141,102,116,4,3,65,82,84,1117,1124,1136,114,114,111,119,59,1,8656,105,103,104,116,65,114,114,111,119,59,1,8660,101,101,59,1,10980,110,103,4,2,76,82,1149,1177,101,102,116,4,2,65,82,1158,1165,114,114,111,119,59,1,10232,105,103,104,116,65,114,114,111,119,59,1,10234,105,103,104,116,65,114,114,111,119,59,1,10233,105,103,104,116,4,2,65,84,1199,1206,114,114,111,119,59,1,8658,101,101,59,1,8872,112,4,2,65,68,1218,1225,114,114,111,119,59,1,8657,111,119,110,65,114,114,111,119,59,1,8661,101,114,116,105,99,97,108,66,97,114,59,1,8741,110,4,6,65,66,76,82,84,97,1264,1292,1299,1352,1391,1408,114,114,111,119,4,3,59,66,85,1276,1278,1283,1,8595,97,114,59,1,10515,112,65,114,114,111,119,59,1,8693,114,101,118,101,59,1,785,101,102,116,4,3,82,84,86,1310,1323,1334,105,103,104,116,86,101,99,116,111,114,59,1,10576,101,101,86,101,99,116,111,114,59,1,10590,101,99,116,111,114,4,2,59,66,1345,1347,1,8637,97,114,59,1,10582,105,103,104,116,4,2,84,86,1362,1373,101,101,86,101,99,116,111,114,59,1,10591,101,99,116,111,114,4,2,59,66,1384,1386,1,8641,97,114,59,1,10583,101,101,4,2,59,65,1399,1401,1,8868,114,114,111,119,59,1,8615,114,114,111,119,59,1,8659,4,2,99,116,1421,1426,114,59,3,55349,56479,114,111,107,59,1,272,4,16,78,84,97,99,100,102,103,108,109,111,112,113,115,116,117,120,1466,1470,1478,1489,1515,1520,1525,1536,1544,1593,1609,1617,1650,1664,1668,1677,71,59,1,330,72,5,208,1,59,1476,1,208,99,117,116,101,5,201,1,59,1487,1,201,4,3,97,105,121,1497,1503,1512,114,111,110,59,1,282,114,99,5,202,1,59,1510,1,202,59,1,1069,111,116,59,1,278,114,59,3,55349,56584,114,97,118,101,5,200,1,59,1534,1,200,101,109,101,110,116,59,1,8712,4,2,97,112,1550,1555,99,114,59,1,274,116,121,4,2,83,86,1563,1576,109,97,108,108,83,113,117,97,114,101,59,1,9723,101,114,121,83,109,97,108,108,83,113,117,97,114,101,59,1,9643,4,2,103,112,1599,1604,111,110,59,1,280,102,59,3,55349,56636,115,105,108,111,110,59,1,917,117,4,2,97,105,1624,1640,108,4,2,59,84,1631,1633,1,10869,105,108,100,101,59,1,8770,108,105,98,114,105,117,109,59,1,8652,4,2,99,105,1656,1660,114,59,1,8496,109,59,1,10867,97,59,1,919,109,108,5,203,1,59,1675,1,203,4,2,105,112,1683,1689,115,116,115,59,1,8707,111,110,101,110,116,105,97,108,69,59,1,8519,4,5,99,102,105,111,115,1713,1717,1722,1762,1791,121,59,1,1060,114,59,3,55349,56585,108,108,101,100,4,2,83,86,1732,1745,109,97,108,108,83,113,117,97,114,101,59,1,9724,101,114,121,83,109,97,108,108,83,113,117,97,114,101,59,1,9642,4,3,112,114,117,1770,1775,1781,102,59,3,55349,56637,65,108,108,59,1,8704,114,105,101,114,116,114,102,59,1,8497,99,114,59,1,8497,4,12,74,84,97,98,99,100,102,103,111,114,115,116,1822,1827,1834,1848,1855,1877,1882,1887,1890,1896,1978,1984,99,121,59,1,1027,5,62,1,59,1832,1,62,109,109,97,4,2,59,100,1843,1845,1,915,59,1,988,114,101,118,101,59,1,286,4,3,101,105,121,1863,1869,1874,100,105,108,59,1,290,114,99,59,1,284,59,1,1043,111,116,59,1,288,114,59,3,55349,56586,59,1,8921,112,102,59,3,55349,56638,101,97,116,101,114,4,6,69,70,71,76,83,84,1915,1933,1944,1953,1959,1971,113,117,97,108,4,2,59,76,1925,1927,1,8805,101,115,115,59,1,8923,117,108,108,69,113,117,97,108,59,1,8807,114,101,97,116,101,114,59,1,10914,101,115,115,59,1,8823,108,97,110,116,69,113,117,97,108,59,1,10878,105,108,100,101,59,1,8819,99,114,59,3,55349,56482,59,1,8811,4,8,65,97,99,102,105,111,115,117,2005,2012,2026,2032,2036,2049,2073,2089,82,68,99,121,59,1,1066,4,2,99,116,2018,2023,101,107,59,1,711,59,1,94,105,114,99,59,1,292,114,59,1,8460,108,98,101,114,116,83,112,97,99,101,59,1,8459,4,2,112,114,2055,2059,102,59,1,8461,105,122,111,110,116,97,108,76,105,110,101,59,1,9472,4,2,99,116,2079,2083,114,59,1,8459,114,111,107,59,1,294,109,112,4,2,68,69,2097,2107,111,119,110,72,117,109,112,59,1,8782,113,117,97,108,59,1,8783,4,14,69,74,79,97,99,100,102,103,109,110,111,115,116,117,2144,2149,2155,2160,2171,2189,2194,2198,2209,2245,2307,2329,2334,2341,99,121,59,1,1045,108,105,103,59,1,306,99,121,59,1,1025,99,117,116,101,5,205,1,59,2169,1,205,4,2,105,121,2177,2186,114,99,5,206,1,59,2184,1,206,59,1,1048,111,116,59,1,304,114,59,1,8465,114,97,118,101,5,204,1,59,2207,1,204,4,3,59,97,112,2217,2219,2238,1,8465,4,2,99,103,2225,2229,114,59,1,298,105,110,97,114,121,73,59,1,8520,108,105,101,115,59,1,8658,4,2,116,118,2251,2281,4,2,59,101,2257,2259,1,8748,4,2,103,114,2265,2271,114,97,108,59,1,8747,115,101,99,116,105,111,110,59,1,8898,105,115,105,98,108,101,4,2,67,84,2293,2300,111,109,109,97,59,1,8291,105,109,101,115,59,1,8290,4,3,103,112,116,2315,2320,2325,111,110,59,1,302,102,59,3,55349,56640,97,59,1,921,99,114,59,1,8464,105,108,100,101,59,1,296,4,2,107,109,2347,2352,99,121,59,1,1030,108,5,207,1,59,2358,1,207,4,5,99,102,111,115,117,2372,2386,2391,2397,2414,4,2,105,121,2378,2383,114,99,59,1,308,59,1,1049,114,59,3,55349,56589,112,102,59,3,55349,56641,4,2,99,101,2403,2408,114,59,3,55349,56485,114,99,121,59,1,1032,107,99,121,59,1,1028,4,7,72,74,97,99,102,111,115,2436,2441,2446,2452,2467,2472,2478,99,121,59,1,1061,99,121,59,1,1036,112,112,97,59,1,922,4,2,101,121,2458,2464,100,105,108,59,1,310,59,1,1050,114,59,3,55349,56590,112,102,59,3,55349,56642,99,114,59,3,55349,56486,4,11,74,84,97,99,101,102,108,109,111,115,116,2508,2513,2520,2562,2585,2981,2986,3004,3011,3146,3167,99,121,59,1,1033,5,60,1,59,2518,1,60,4,5,99,109,110,112,114,2532,2538,2544,2548,2558,117,116,101,59,1,313,98,100,97,59,1,923,103,59,1,10218,108,97,99,101,116,114,102,59,1,8466,114,59,1,8606,4,3,97,101,121,2570,2576,2582,114,111,110,59,1,317,100,105,108,59,1,315,59,1,1051,4,2,102,115,2591,2907,116,4,10,65,67,68,70,82,84,85,86,97,114,2614,2663,2672,2728,2735,2760,2820,2870,2888,2895,4,2,110,114,2620,2633,103,108,101,66,114,97,99,107,101,116,59,1,10216,114,111,119,4,3,59,66,82,2644,2646,2651,1,8592,97,114,59,1,8676,105,103,104,116,65,114,114,111,119,59,1,8646,101,105,108,105,110,103,59,1,8968,111,4,2,117,119,2679,2692,98,108,101,66,114,97,99,107,101,116,59,1,10214,110,4,2,84,86,2699,2710,101,101,86,101,99,116,111,114,59,1,10593,101,99,116,111,114,4,2,59,66,2721,2723,1,8643,97,114,59,1,10585,108,111,111,114,59,1,8970,105,103,104,116,4,2,65,86,2745,2752,114,114,111,119,59,1,8596,101,99,116,111,114,59,1,10574,4,2,101,114,2766,2792,101,4,3,59,65,86,2775,2777,2784,1,8867,114,114,111,119,59,1,8612,101,99,116,111,114,59,1,10586,105,97,110,103,108,101,4,3,59,66,69,2806,2808,2813,1,8882,97,114,59,1,10703,113,117,97,108,59,1,8884,112,4,3,68,84,86,2829,2841,2852,111,119,110,86,101,99,116,111,114,59,1,10577,101,101,86,101,99,116,111,114,59,1,10592,101,99,116,111,114,4,2,59,66,2863,2865,1,8639,97,114,59,1,10584,101,99,116,111,114,4,2,59,66,2881,2883,1,8636,97,114,59,1,10578,114,114,111,119,59,1,8656,105,103,104,116,97,114,114,111,119,59,1,8660,115,4,6,69,70,71,76,83,84,2922,2936,2947,2956,2962,2974,113,117,97,108,71,114,101,97,116,101,114,59,1,8922,117,108,108,69,113,117,97,108,59,1,8806,114,101,97,116,101,114,59,1,8822,101,115,115,59,1,10913,108,97,110,116,69,113,117,97,108,59,1,10877,105,108,100,101,59,1,8818,114,59,3,55349,56591,4,2,59,101,2992,2994,1,8920,102,116,97,114,114,111,119,59,1,8666,105,100,111,116,59,1,319,4,3,110,112,119,3019,3110,3115,103,4,4,76,82,108,114,3030,3058,3070,3098,101,102,116,4,2,65,82,3039,3046,114,114,111,119,59,1,10229,105,103,104,116,65,114,114,111,119,59,1,10231,105,103,104,116,65,114,114,111,119,59,1,10230,101,102,116,4,2,97,114,3079,3086,114,114,111,119,59,1,10232,105,103,104,116,97,114,114,111,119,59,1,10234,105,103,104,116,97,114,114,111,119,59,1,10233,102,59,3,55349,56643,101,114,4,2,76,82,3123,3134,101,102,116,65,114,114,111,119,59,1,8601,105,103,104,116,65,114,114,111,119,59,1,8600,4,3,99,104,116,3154,3158,3161,114,59,1,8466,59,1,8624,114,111,107,59,1,321,59,1,8810,4,8,97,99,101,102,105,111,115,117,3188,3192,3196,3222,3227,3237,3243,3248,112,59,1,10501,121,59,1,1052,4,2,100,108,3202,3213,105,117,109,83,112,97,99,101,59,1,8287,108,105,110,116,114,102,59,1,8499,114,59,3,55349,56592,110,117,115,80,108,117,115,59,1,8723,112,102,59,3,55349,56644,99,114,59,1,8499,59,1,924,4,9,74,97,99,101,102,111,115,116,117,3271,3276,3283,3306,3422,3427,4120,4126,4137,99,121,59,1,1034,99,117,116,101,59,1,323,4,3,97,101,121,3291,3297,3303,114,111,110,59,1,327,100,105,108,59,1,325,59,1,1053,4,3,103,115,119,3314,3380,3415,97,116,105,118,101,4,3,77,84,86,3327,3340,3365,101,100,105,117,109,83,112,97,99,101,59,1,8203,104,105,4,2,99,110,3348,3357,107,83,112,97,99,101,59,1,8203,83,112,97,99,101,59,1,8203,101,114,121,84,104,105,110,83,112,97,99,101,59,1,8203,116,101,100,4,2,71,76,3389,3405,114,101,97,116,101,114,71,114,101,97,116,101,114,59,1,8811,101,115,115,76,101,115,115,59,1,8810,76,105,110,101,59,1,10,114,59,3,55349,56593,4,4,66,110,112,116,3437,3444,3460,3464,114,101,97,107,59,1,8288,66,114,101,97,107,105,110,103,83,112,97,99,101,59,1,160,102,59,1,8469,4,13,59,67,68,69,71,72,76,78,80,82,83,84,86,3492,3494,3517,3536,3578,3657,3685,3784,3823,3860,3915,4066,4107,1,10988,4,2,111,117,3500,3510,110,103,114,117,101,110,116,59,1,8802,112,67,97,112,59,1,8813,111,117,98,108,101,86,101,114,116,105,99,97,108,66,97,114,59,1,8742,4,3,108,113,120,3544,3552,3571,101,109,101,110,116,59,1,8713,117,97,108,4,2,59,84,3561,3563,1,8800,105,108,100,101,59,3,8770,824,105,115,116,115,59,1,8708,114,101,97,116,101,114,4,7,59,69,70,71,76,83,84,3600,3602,3609,3621,3631,3637,3650,1,8815,113,117,97,108,59,1,8817,117,108,108,69,113,117,97,108,59,3,8807,824,114,101,97,116,101,114,59,3,8811,824,101,115,115,59,1,8825,108,97,110,116,69,113,117,97,108,59,3,10878,824,105,108,100,101,59,1,8821,117,109,112,4,2,68,69,3666,3677,111,119,110,72,117,109,112,59,3,8782,824,113,117,97,108,59,3,8783,824,101,4,2,102,115,3692,3724,116,84,114,105,97,110,103,108,101,4,3,59,66,69,3709,3711,3717,1,8938,97,114,59,3,10703,824,113,117,97,108,59,1,8940,115,4,6,59,69,71,76,83,84,3739,3741,3748,3757,3764,3777,1,8814,113,117,97,108,59,1,8816,114,101,97,116,101,114,59,1,8824,101,115,115,59,3,8810,824,108,97,110,116,69,113,117,97,108,59,3,10877,824,105,108,100,101,59,1,8820,101,115,116,101,100,4,2,71,76,3795,3812,114,101,97,116,101,114,71,114,101,97,116,101,114,59,3,10914,824,101,115,115,76,101,115,115,59,3,10913,824,114,101,99,101,100,101,115,4,3,59,69,83,3838,3840,3848,1,8832,113,117,97,108,59,3,10927,824,108,97,110,116,69,113,117,97,108,59,1,8928,4,2,101,105,3866,3881,118,101,114,115,101,69,108,101,109,101,110,116,59,1,8716,103,104,116,84,114,105,97,110,103,108,101,4,3,59,66,69,3900,3902,3908,1,8939,97,114,59,3,10704,824,113,117,97,108,59,1,8941,4,2,113,117,3921,3973,117,97,114,101,83,117,4,2,98,112,3933,3952,115,101,116,4,2,59,69,3942,3945,3,8847,824,113,117,97,108,59,1,8930,101,114,115,101,116,4,2,59,69,3963,3966,3,8848,824,113,117,97,108,59,1,8931,4,3,98,99,112,3981,4000,4045,115,101,116,4,2,59,69,3990,3993,3,8834,8402,113,117,97,108,59,1,8840,99,101,101,100,115,4,4,59,69,83,84,4015,4017,4025,4037,1,8833,113,117,97,108,59,3,10928,824,108,97,110,116,69,113,117,97,108,59,1,8929,105,108,100,101,59,3,8831,824,101,114,115,101,116,4,2,59,69,4056,4059,3,8835,8402,113,117,97,108,59,1,8841,105,108,100,101,4,4,59,69,70,84,4080,4082,4089,4100,1,8769,113,117,97,108,59,1,8772,117,108,108,69,113,117,97,108,59,1,8775,105,108,100,101,59,1,8777,101,114,116,105,99,97,108,66,97,114,59,1,8740,99,114,59,3,55349,56489,105,108,100,101,5,209,1,59,4135,1,209,59,1,925,4,14,69,97,99,100,102,103,109,111,112,114,115,116,117,118,4170,4176,4187,4205,4212,4217,4228,4253,4259,4292,4295,4316,4337,4346,108,105,103,59,1,338,99,117,116,101,5,211,1,59,4185,1,211,4,2,105,121,4193,4202,114,99,5,212,1,59,4200,1,212,59,1,1054,98,108,97,99,59,1,336,114,59,3,55349,56594,114,97,118,101,5,210,1,59,4226,1,210,4,3,97,101,105,4236,4241,4246,99,114,59,1,332,103,97,59,1,937,99,114,111,110,59,1,927,112,102,59,3,55349,56646,101,110,67,117,114,108,121,4,2,68,81,4272,4285,111,117,98,108,101,81,117,111,116,101,59,1,8220,117,111,116,101,59,1,8216,59,1,10836,4,2,99,108,4301,4306,114,59,3,55349,56490,97,115,104,5,216,1,59,4314,1,216,105,4,2,108,109,4323,4332,100,101,5,213,1,59,4330,1,213,101,115,59,1,10807,109,108,5,214,1,59,4344,1,214,101,114,4,2,66,80,4354,4380,4,2,97,114,4360,4364,114,59,1,8254,97,99,4,2,101,107,4372,4375,59,1,9182,101,116,59,1,9140,97,114,101,110,116,104,101,115,105,115,59,1,9180,4,9,97,99,102,104,105,108,111,114,115,4413,4422,4426,4431,4435,4438,4448,4471,4561,114,116,105,97,108,68,59,1,8706,121,59,1,1055,114,59,3,55349,56595,105,59,1,934,59,1,928,117,115,77,105,110,117,115,59,1,177,4,2,105,112,4454,4467,110,99,97,114,101,112,108,97,110,101,59,1,8460,102,59,1,8473,4,4,59,101,105,111,4481,4483,4526,4531,1,10939,99,101,100,101,115,4,4,59,69,83,84,4498,4500,4507,4519,1,8826,113,117,97,108,59,1,10927,108,97,110,116,69,113,117,97,108,59,1,8828,105,108,100,101,59,1,8830,109,101,59,1,8243,4,2,100,112,4537,4543,117,99,116,59,1,8719,111,114,116,105,111,110,4,2,59,97,4555,4557,1,8759,108,59,1,8733,4,2,99,105,4567,4572,114,59,3,55349,56491,59,1,936,4,4,85,102,111,115,4585,4594,4599,4604,79,84,5,34,1,59,4592,1,34,114,59,3,55349,56596,112,102,59,1,8474,99,114,59,3,55349,56492,4,12,66,69,97,99,101,102,104,105,111,114,115,117,4636,4642,4650,4681,4704,4763,4767,4771,5047,5069,5081,5094,97,114,114,59,1,10512,71,5,174,1,59,4648,1,174,4,3,99,110,114,4658,4664,4668,117,116,101,59,1,340,103,59,1,10219,114,4,2,59,116,4675,4677,1,8608,108,59,1,10518,4,3,97,101,121,4689,4695,4701,114,111,110,59,1,344,100,105,108,59,1,342,59,1,1056,4,2,59,118,4710,4712,1,8476,101,114,115,101,4,2,69,85,4722,4748,4,2,108,113,4728,4736,101,109,101,110,116,59,1,8715,117,105,108,105,98,114,105,117,109,59,1,8651,112,69,113,117,105,108,105,98,114,105,117,109,59,1,10607,114,59,1,8476,111,59,1,929,103,104,116,4,8,65,67,68,70,84,85,86,97,4792,4840,4849,4905,4912,4972,5022,5040,4,2,110,114,4798,4811,103,108,101,66,114,97,99,107,101,116,59,1,10217,114,111,119,4,3,59,66,76,4822,4824,4829,1,8594,97,114,59,1,8677,101,102,116,65,114,114,111,119,59,1,8644,101,105,108,105,110,103,59,1,8969,111,4,2,117,119,4856,4869,98,108,101,66,114,97,99,107,101,116,59,1,10215,110,4,2,84,86,4876,4887,101,101,86,101,99,116,111,114,59,1,10589,101,99,116,111,114,4,2,59,66,4898,4900,1,8642,97,114,59,1,10581,108,111,111,114,59,1,8971,4,2,101,114,4918,4944,101,4,3,59,65,86,4927,4929,4936,1,8866,114,114,111,119,59,1,8614,101,99,116,111,114,59,1,10587,105,97,110,103,108,101,4,3,59,66,69,4958,4960,4965,1,8883,97,114,59,1,10704,113,117,97,108,59,1,8885,112,4,3,68,84,86,4981,4993,5004,111,119,110,86,101,99,116,111,114,59,1,10575,101,101,86,101,99,116,111,114,59,1,10588,101,99,116,111,114,4,2,59,66,5015,5017,1,8638,97,114,59,1,10580,101,99,116,111,114,4,2,59,66,5033,5035,1,8640,97,114,59,1,10579,114,114,111,119,59,1,8658,4,2,112,117,5053,5057,102,59,1,8477,110,100,73,109,112,108,105,101,115,59,1,10608,105,103,104,116,97,114,114,111,119,59,1,8667,4,2,99,104,5087,5091,114,59,1,8475,59,1,8625,108,101,68,101,108,97,121,101,100,59,1,10740,4,13,72,79,97,99,102,104,105,109,111,113,115,116,117,5134,5150,5157,5164,5198,5203,5259,5265,5277,5283,5374,5380,5385,4,2,67,99,5140,5146,72,99,121,59,1,1065,121,59,1,1064,70,84,99,121,59,1,1068,99,117,116,101,59,1,346,4,5,59,97,101,105,121,5176,5178,5184,5190,5195,1,10940,114,111,110,59,1,352,100,105,108,59,1,350,114,99,59,1,348,59,1,1057,114,59,3,55349,56598,111,114,116,4,4,68,76,82,85,5216,5227,5238,5250,111,119,110,65,114,114,111,119,59,1,8595,101,102,116,65,114,114,111,119,59,1,8592,105,103,104,116,65,114,114,111,119,59,1,8594,112,65,114,114,111,119,59,1,8593,103,109,97,59,1,931,97,108,108,67,105,114,99,108,101,59,1,8728,112,102,59,3,55349,56650,4,2,114,117,5289,5293,116,59,1,8730,97,114,101,4,4,59,73,83,85,5306,5308,5322,5367,1,9633,110,116,101,114,115,101,99,116,105,111,110,59,1,8851,117,4,2,98,112,5329,5347,115,101,116,4,2,59,69,5338,5340,1,8847,113,117,97,108,59,1,8849,101,114,115,101,116,4,2,59,69,5358,5360,1,8848,113,117,97,108,59,1,8850,110,105,111,110,59,1,8852,99,114,59,3,55349,56494,97,114,59,1,8902,4,4,98,99,109,112,5395,5420,5475,5478,4,2,59,115,5401,5403,1,8912,101,116,4,2,59,69,5411,5413,1,8912,113,117,97,108,59,1,8838,4,2,99,104,5426,5468,101,101,100,115,4,4,59,69,83,84,5440,5442,5449,5461,1,8827,113,117,97,108,59,1,10928,108,97,110,116,69,113,117,97,108,59,1,8829,105,108,100,101,59,1,8831,84,104,97,116,59,1,8715,59,1,8721,4,3,59,101,115,5486,5488,5507,1,8913,114,115,101,116,4,2,59,69,5498,5500,1,8835,113,117,97,108,59,1,8839,101,116,59,1,8913,4,11,72,82,83,97,99,102,104,105,111,114,115,5536,5546,5552,5567,5579,5602,5607,5655,5695,5701,5711,79,82,78,5,222,1,59,5544,1,222,65,68,69,59,1,8482,4,2,72,99,5558,5563,99,121,59,1,1035,121,59,1,1062,4,2,98,117,5573,5576,59,1,9,59,1,932,4,3,97,101,121,5587,5593,5599,114,111,110,59,1,356,100,105,108,59,1,354,59,1,1058,114,59,3,55349,56599,4,2,101,105,5613,5631,4,2,114,116,5619,5627,101,102,111,114,101,59,1,8756,97,59,1,920,4,2,99,110,5637,5647,107,83,112,97,99,101,59,3,8287,8202,83,112,97,99,101,59,1,8201,108,100,101,4,4,59,69,70,84,5668,5670,5677,5688,1,8764,113,117,97,108,59,1,8771,117,108,108,69,113,117,97,108,59,1,8773,105,108,100,101,59,1,8776,112,102,59,3,55349,56651,105,112,108,101,68,111,116,59,1,8411,4,2,99,116,5717,5722,114,59,3,55349,56495,114,111,107,59,1,358,4,14,97,98,99,100,102,103,109,110,111,112,114,115,116,117,5758,5789,5805,5823,5830,5835,5846,5852,5921,5937,6089,6095,6101,6108,4,2,99,114,5764,5774,117,116,101,5,218,1,59,5772,1,218,114,4,2,59,111,5781,5783,1,8607,99,105,114,59,1,10569,114,4,2,99,101,5796,5800,121,59,1,1038,118,101,59,1,364,4,2,105,121,5811,5820,114,99,5,219,1,59,5818,1,219,59,1,1059,98,108,97,99,59,1,368,114,59,3,55349,56600,114,97,118,101,5,217,1,59,5844,1,217,97,99,114,59,1,362,4,2,100,105,5858,5905,101,114,4,2,66,80,5866,5892,4,2,97,114,5872,5876,114,59,1,95,97,99,4,2,101,107,5884,5887,59,1,9183,101,116,59,1,9141,97,114,101,110,116,104,101,115,105,115,59,1,9181,111,110,4,2,59,80,5913,5915,1,8899,108,117,115,59,1,8846,4,2,103,112,5927,5932,111,110,59,1,370,102,59,3,55349,56652,4,8,65,68,69,84,97,100,112,115,5955,5985,5996,6009,6026,6033,6044,6075,114,114,111,119,4,3,59,66,68,5967,5969,5974,1,8593,97,114,59,1,10514,111,119,110,65,114,114,111,119,59,1,8645,111,119,110,65,114,114,111,119,59,1,8597,113,117,105,108,105,98,114,105,117,109,59,1,10606,101,101,4,2,59,65,6017,6019,1,8869,114,114,111,119,59,1,8613,114,114,111,119,59,1,8657,111,119,110,97,114,114,111,119,59,1,8661,101,114,4,2,76,82,6052,6063,101,102,116,65,114,114,111,119,59,1,8598,105,103,104,116,65,114,114,111,119,59,1,8599,105,4,2,59,108,6082,6084,1,978,111,110,59,1,933,105,110,103,59,1,366,99,114,59,3,55349,56496,105,108,100,101,59,1,360,109,108,5,220,1,59,6115,1,220,4,9,68,98,99,100,101,102,111,115,118,6137,6143,6148,6152,6166,6250,6255,6261,6267,97,115,104,59,1,8875,97,114,59,1,10987,121,59,1,1042,97,115,104,4,2,59,108,6161,6163,1,8873,59,1,10982,4,2,101,114,6172,6175,59,1,8897,4,3,98,116,121,6183,6188,6238,97,114,59,1,8214,4,2,59,105,6194,6196,1,8214,99,97,108,4,4,66,76,83,84,6209,6214,6220,6231,97,114,59,1,8739,105,110,101,59,1,124,101,112,97,114,97,116,111,114,59,1,10072,105,108,100,101,59,1,8768,84,104,105,110,83,112,97,99,101,59,1,8202,114,59,3,55349,56601,112,102,59,3,55349,56653,99,114,59,3,55349,56497,100,97,115,104,59,1,8874,4,5,99,101,102,111,115,6286,6292,6298,6303,6309,105,114,99,59,1,372,100,103,101,59,1,8896,114,59,3,55349,56602,112,102,59,3,55349,56654,99,114,59,3,55349,56498,4,4,102,105,111,115,6325,6330,6333,6339,114,59,3,55349,56603,59,1,926,112,102,59,3,55349,56655,99,114,59,3,55349,56499,4,9,65,73,85,97,99,102,111,115,117,6365,6370,6375,6380,6391,6405,6410,6416,6422,99,121,59,1,1071,99,121,59,1,1031,99,121,59,1,1070,99,117,116,101,5,221,1,59,6389,1,221,4,2,105,121,6397,6402,114,99,59,1,374,59,1,1067,114,59,3,55349,56604,112,102,59,3,55349,56656,99,114,59,3,55349,56500,109,108,59,1,376,4,8,72,97,99,100,101,102,111,115,6445,6450,6457,6472,6477,6501,6505,6510,99,121,59,1,1046,99,117,116,101,59,1,377,4,2,97,121,6463,6469,114,111,110,59,1,381,59,1,1047,111,116,59,1,379,4,2,114,116,6483,6497,111,87,105,100,116,104,83,112,97,99,101,59,1,8203,97,59,1,918,114,59,1,8488,112,102,59,1,8484,99,114,59,3,55349,56501,4,16,97,98,99,101,102,103,108,109,110,111,112,114,115,116,117,119,6550,6561,6568,6612,6622,6634,6645,6672,6699,6854,6870,6923,6933,6963,6974,6983,99,117,116,101,5,225,1,59,6559,1,225,114,101,118,101,59,1,259,4,6,59,69,100,105,117,121,6582,6584,6588,6591,6600,6609,1,8766,59,3,8766,819,59,1,8767,114,99,5,226,1,59,6598,1,226,116,101,5,180,1,59,6607,1,180,59,1,1072,108,105,103,5,230,1,59,6620,1,230,4,2,59,114,6628,6630,1,8289,59,3,55349,56606,114,97,118,101,5,224,1,59,6643,1,224,4,2,101,112,6651,6667,4,2,102,112,6657,6663,115,121,109,59,1,8501,104,59,1,8501,104,97,59,1,945,4,2,97,112,6678,6692,4,2,99,108,6684,6688,114,59,1,257,103,59,1,10815,5,38,1,59,6697,1,38,4,2,100,103,6705,6737,4,5,59,97,100,115,118,6717,6719,6724,6727,6734,1,8743,110,100,59,1,10837,59,1,10844,108,111,112,101,59,1,10840,59,1,10842,4,7,59,101,108,109,114,115,122,6753,6755,6758,6762,6814,6835,6848,1,8736,59,1,10660,101,59,1,8736,115,100,4,2,59,97,6770,6772,1,8737,4,8,97,98,99,100,101,102,103,104,6790,6793,6796,6799,6802,6805,6808,6811,59,1,10664,59,1,10665,59,1,10666,59,1,10667,59,1,10668,59,1,10669,59,1,10670,59,1,10671,116,4,2,59,118,6821,6823,1,8735,98,4,2,59,100,6830,6832,1,8894,59,1,10653,4,2,112,116,6841,6845,104,59,1,8738,59,1,197,97,114,114,59,1,9084,4,2,103,112,6860,6865,111,110,59,1,261,102,59,3,55349,56658,4,7,59,69,97,101,105,111,112,6886,6888,6891,6897,6900,6904,6908,1,8776,59,1,10864,99,105,114,59,1,10863,59,1,8778,100,59,1,8779,115,59,1,39,114,111,120,4,2,59,101,6917,6919,1,8776,113,59,1,8778,105,110,103,5,229,1,59,6931,1,229,4,3,99,116,121,6941,6946,6949,114,59,3,55349,56502,59,1,42,109,112,4,2,59,101,6957,6959,1,8776,113,59,1,8781,105,108,100,101,5,227,1,59,6972,1,227,109,108,5,228,1,59,6981,1,228,4,2,99,105,6989,6997,111,110,105,110,116,59,1,8755,110,116,59,1,10769,4,16,78,97,98,99,100,101,102,105,107,108,110,111,112,114,115,117,7036,7041,7119,7135,7149,7155,7219,7224,7347,7354,7463,7489,7786,7793,7814,7866,111,116,59,1,10989,4,2,99,114,7047,7094,107,4,4,99,101,112,115,7058,7064,7073,7080,111,110,103,59,1,8780,112,115,105,108,111,110,59,1,1014,114,105,109,101,59,1,8245,105,109,4,2,59,101,7088,7090,1,8765,113,59,1,8909,4,2,118,119,7100,7105,101,101,59,1,8893,101,100,4,2,59,103,7113,7115,1,8965,101,59,1,8965,114,107,4,2,59,116,7127,7129,1,9141,98,114,107,59,1,9142,4,2,111,121,7141,7146,110,103,59,1,8780,59,1,1073,113,117,111,59,1,8222,4,5,99,109,112,114,116,7167,7181,7188,7193,7199,97,117,115,4,2,59,101,7176,7178,1,8757,59,1,8757,112,116,121,118,59,1,10672,115,105,59,1,1014,110,111,117,59,1,8492,4,3,97,104,119,7207,7210,7213,59,1,946,59,1,8502,101,101,110,59,1,8812,114,59,3,55349,56607,103,4,7,99,111,115,116,117,118,119,7241,7262,7288,7305,7328,7335,7340,4,3,97,105,117,7249,7253,7258,112,59,1,8898,114,99,59,1,9711,112,59,1,8899,4,3,100,112,116,7270,7275,7281,111,116,59,1,10752,108,117,115,59,1,10753,105,109,101,115,59,1,10754,4,2,113,116,7294,7300,99,117,112,59,1,10758,97,114,59,1,9733,114,105,97,110,103,108,101,4,2,100,117,7318,7324,111,119,110,59,1,9661,112,59,1,9651,112,108,117,115,59,1,10756,101,101,59,1,8897,101,100,103,101,59,1,8896,97,114,111,119,59,1,10509,4,3,97,107,111,7362,7436,7458,4,2,99,110,7368,7432,107,4,3,108,115,116,7377,7386,7394,111,122,101,110,103,101,59,1,10731,113,117,97,114,101,59,1,9642,114,105,97,110,103,108,101,4,4,59,100,108,114,7411,7413,7419,7425,1,9652,111,119,110,59,1,9662,101,102,116,59,1,9666,105,103,104,116,59,1,9656,107,59,1,9251,4,2,49,51,7442,7454,4,2,50,52,7448,7451,59,1,9618,59,1,9617,52,59,1,9619,99,107,59,1,9608,4,2,101,111,7469,7485,4,2,59,113,7475,7478,3,61,8421,117,105,118,59,3,8801,8421,116,59,1,8976,4,4,112,116,119,120,7499,7504,7517,7523,102,59,3,55349,56659,4,2,59,116,7510,7512,1,8869,111,109,59,1,8869,116,105,101,59,1,8904,4,12,68,72,85,86,98,100,104,109,112,116,117,118,7549,7571,7597,7619,7655,7660,7682,7708,7715,7721,7728,7750,4,4,76,82,108,114,7559,7562,7565,7568,59,1,9559,59,1,9556,59,1,9558,59,1,9555,4,5,59,68,85,100,117,7583,7585,7588,7591,7594,1,9552,59,1,9574,59,1,9577,59,1,9572,59,1,9575,4,4,76,82,108,114,7607,7610,7613,7616,59,1,9565,59,1,9562,59,1,9564,59,1,9561,4,7,59,72,76,82,104,108,114,7635,7637,7640,7643,7646,7649,7652,1,9553,59,1,9580,59,1,9571,59,1,9568,59,1,9579,59,1,9570,59,1,9567,111,120,59,1,10697,4,4,76,82,108,114,7670,7673,7676,7679,59,1,9557,59,1,9554,59,1,9488,59,1,9484,4,5,59,68,85,100,117,7694,7696,7699,7702,7705,1,9472,59,1,9573,59,1,9576,59,1,9516,59,1,9524,105,110,117,115,59,1,8863,108,117,115,59,1,8862,105,109,101,115,59,1,8864,4,4,76,82,108,114,7738,7741,7744,7747,59,1,9563,59,1,9560,59,1,9496,59,1,9492,4,7,59,72,76,82,104,108,114,7766,7768,7771,7774,7777,7780,7783,1,9474,59,1,9578,59,1,9569,59,1,9566,59,1,9532,59,1,9508,59,1,9500,114,105,109,101,59,1,8245,4,2,101,118,7799,7804,118,101,59,1,728,98,97,114,5,166,1,59,7812,1,166,4,4,99,101,105,111,7824,7829,7834,7846,114,59,3,55349,56503,109,105,59,1,8271,109,4,2,59,101,7841,7843,1,8765,59,1,8909,108,4,3,59,98,104,7855,7857,7860,1,92,59,1,10693,115,117,98,59,1,10184,4,2,108,109,7872,7885,108,4,2,59,101,7879,7881,1,8226,116,59,1,8226,112,4,3,59,69,101,7894,7896,7899,1,8782,59,1,10926,4,2,59,113,7905,7907,1,8783,59,1,8783,4,15,97,99,100,101,102,104,105,108,111,114,115,116,117,119,121,7942,8021,8075,8080,8121,8126,8157,8279,8295,8430,8446,8485,8491,8707,8726,4,3,99,112,114,7950,7956,8007,117,116,101,59,1,263,4,6,59,97,98,99,100,115,7970,7972,7977,7984,7998,8003,1,8745,110,100,59,1,10820,114,99,117,112,59,1,10825,4,2,97,117,7990,7994,112,59,1,10827,112,59,1,10823,111,116,59,1,10816,59,3,8745,65024,4,2,101,111,8013,8017,116,59,1,8257,110,59,1,711,4,4,97,101,105,117,8031,8046,8056,8061,4,2,112,114,8037,8041,115,59,1,10829,111,110,59,1,269,100,105,108,5,231,1,59,8054,1,231,114,99,59,1,265,112,115,4,2,59,115,8069,8071,1,10828,109,59,1,10832,111,116,59,1,267,4,3,100,109,110,8088,8097,8104,105,108,5,184,1,59,8095,1,184,112,116,121,118,59,1,10674,116,5,162,2,59,101,8112,8114,1,162,114,100,111,116,59,1,183,114,59,3,55349,56608,4,3,99,101,105,8134,8138,8154,121,59,1,1095,99,107,4,2,59,109,8146,8148,1,10003,97,114,107,59,1,10003,59,1,967,114,4,7,59,69,99,101,102,109,115,8174,8176,8179,8258,8261,8268,8273,1,9675,59,1,10691,4,3,59,101,108,8187,8189,8193,1,710,113,59,1,8791,101,4,2,97,100,8200,8223,114,114,111,119,4,2,108,114,8210,8216,101,102,116,59,1,8634,105,103,104,116,59,1,8635,4,5,82,83,97,99,100,8235,8238,8241,8246,8252,59,1,174,59,1,9416,115,116,59,1,8859,105,114,99,59,1,8858,97,115,104,59,1,8861,59,1,8791,110,105,110,116,59,1,10768,105,100,59,1,10991,99,105,114,59,1,10690,117,98,115,4,2,59,117,8288,8290,1,9827,105,116,59,1,9827,4,4,108,109,110,112,8305,8326,8376,8400,111,110,4,2,59,101,8313,8315,1,58,4,2,59,113,8321,8323,1,8788,59,1,8788,4,2,109,112,8332,8344,97,4,2,59,116,8339,8341,1,44,59,1,64,4,3,59,102,108,8352,8354,8358,1,8705,110,59,1,8728,101,4,2,109,120,8365,8371,101,110,116,59,1,8705,101,115,59,1,8450,4,2,103,105,8382,8395,4,2,59,100,8388,8390,1,8773,111,116,59,1,10861,110,116,59,1,8750,4,3,102,114,121,8408,8412,8417,59,3,55349,56660,111,100,59,1,8720,5,169,2,59,115,8424,8426,1,169,114,59,1,8471,4,2,97,111,8436,8441,114,114,59,1,8629,115,115,59,1,10007,4,2,99,117,8452,8457,114,59,3,55349,56504,4,2,98,112,8463,8474,4,2,59,101,8469,8471,1,10959,59,1,10961,4,2,59,101,8480,8482,1,10960,59,1,10962,100,111,116,59,1,8943,4,7,100,101,108,112,114,118,119,8507,8522,8536,8550,8600,8697,8702,97,114,114,4,2,108,114,8516,8519,59,1,10552,59,1,10549,4,2,112,115,8528,8532,114,59,1,8926,99,59,1,8927,97,114,114,4,2,59,112,8545,8547,1,8630,59,1,10557,4,6,59,98,99,100,111,115,8564,8566,8573,8587,8592,8596,1,8746,114,99,97,112,59,1,10824,4,2,97,117,8579,8583,112,59,1,10822,112,59,1,10826,111,116,59,1,8845,114,59,1,10821,59,3,8746,65024,4,4,97,108,114,118,8610,8623,8663,8672,114,114,4,2,59,109,8618,8620,1,8631,59,1,10556,121,4,3,101,118,119,8632,8651,8656,113,4,2,112,115,8639,8645,114,101,99,59,1,8926,117,99,99,59,1,8927,101,101,59,1,8910,101,100,103,101,59,1,8911,101,110,5,164,1,59,8670,1,164,101,97,114,114,111,119,4,2,108,114,8684,8690,101,102,116,59,1,8630,105,103,104,116,59,1,8631,101,101,59,1,8910,101,100,59,1,8911,4,2,99,105,8713,8721,111,110,105,110,116,59,1,8754,110,116,59,1,8753,108,99,116,121,59,1,9005,4,19,65,72,97,98,99,100,101,102,104,105,106,108,111,114,115,116,117,119,122,8773,8778,8783,8821,8839,8854,8887,8914,8930,8944,9036,9041,9058,9197,9227,9258,9281,9297,9305,114,114,59,1,8659,97,114,59,1,10597,4,4,103,108,114,115,8793,8799,8805,8809,103,101,114,59,1,8224,101,116,104,59,1,8504,114,59,1,8595,104,4,2,59,118,8816,8818,1,8208,59,1,8867,4,2,107,108,8827,8834,97,114,111,119,59,1,10511,97,99,59,1,733,4,2,97,121,8845,8851,114,111,110,59,1,271,59,1,1076,4,3,59,97,111,8862,8864,8880,1,8518,4,2,103,114,8870,8876,103,101,114,59,1,8225,114,59,1,8650,116,115,101,113,59,1,10871,4,3,103,108,109,8895,8902,8907,5,176,1,59,8900,1,176,116,97,59,1,948,112,116,121,118,59,1,10673,4,2,105,114,8920,8926,115,104,116,59,1,10623,59,3,55349,56609,97,114,4,2,108,114,8938,8941,59,1,8643,59,1,8642,4,5,97,101,103,115,118,8956,8986,8989,8996,9001,109,4,3,59,111,115,8965,8967,8983,1,8900,110,100,4,2,59,115,8975,8977,1,8900,117,105,116,59,1,9830,59,1,9830,59,1,168,97,109,109,97,59,1,989,105,110,59,1,8946,4,3,59,105,111,9009,9011,9031,1,247,100,101,5,247,2,59,111,9020,9022,1,247,110,116,105,109,101,115,59,1,8903,110,120,59,1,8903,99,121,59,1,1106,99,4,2,111,114,9048,9053,114,110,59,1,8990,111,112,59,1,8973,4,5,108,112,116,117,119,9070,9076,9081,9130,9144,108,97,114,59,1,36,102,59,3,55349,56661,4,5,59,101,109,112,115,9093,9095,9109,9116,9122,1,729,113,4,2,59,100,9102,9104,1,8784,111,116,59,1,8785,105,110,117,115,59,1,8760,108,117,115,59,1,8724,113,117,97,114,101,59,1,8865,98,108,101,98,97,114,119,101,100,103,101,59,1,8966,110,4,3,97,100,104,9153,9160,9172,114,114,111,119,59,1,8595,111,119,110,97,114,114,111,119,115,59,1,8650,97,114,112,111,111,110,4,2,108,114,9184,9190,101,102,116,59,1,8643,105,103,104,116,59,1,8642,4,2,98,99,9203,9211,107,97,114,111,119,59,1,10512,4,2,111,114,9217,9222,114,110,59,1,8991,111,112,59,1,8972,4,3,99,111,116,9235,9248,9252,4,2,114,121,9241,9245,59,3,55349,56505,59,1,1109,108,59,1,10742,114,111,107,59,1,273,4,2,100,114,9264,9269,111,116,59,1,8945,105,4,2,59,102,9276,9278,1,9663,59,1,9662,4,2,97,104,9287,9292,114,114,59,1,8693,97,114,59,1,10607,97,110,103,108,101,59,1,10662,4,2,99,105,9311,9315,121,59,1,1119,103,114,97,114,114,59,1,10239,4,18,68,97,99,100,101,102,103,108,109,110,111,112,113,114,115,116,117,120,9361,9376,9398,9439,9444,9447,9462,9495,9531,9585,9598,9614,9659,9755,9771,9792,9808,9826,4,2,68,111,9367,9372,111,116,59,1,10871,116,59,1,8785,4,2,99,115,9382,9392,117,116,101,5,233,1,59,9390,1,233,116,101,114,59,1,10862,4,4,97,105,111,121,9408,9414,9430,9436,114,111,110,59,1,283,114,4,2,59,99,9421,9423,1,8790,5,234,1,59,9428,1,234,108,111,110,59,1,8789,59,1,1101,111,116,59,1,279,59,1,8519,4,2,68,114,9453,9458,111,116,59,1,8786,59,3,55349,56610,4,3,59,114,115,9470,9472,9482,1,10906,97,118,101,5,232,1,59,9480,1,232,4,2,59,100,9488,9490,1,10902,111,116,59,1,10904,4,4,59,105,108,115,9505,9507,9515,9518,1,10905,110,116,101,114,115,59,1,9191,59,1,8467,4,2,59,100,9524,9526,1,10901,111,116,59,1,10903,4,3,97,112,115,9539,9544,9564,99,114,59,1,275,116,121,4,3,59,115,118,9554,9556,9561,1,8709,101,116,59,1,8709,59,1,8709,112,4,2,49,59,9571,9583,4,2,51,52,9577,9580,59,1,8196,59,1,8197,1,8195,4,2,103,115,9591,9594,59,1,331,112,59,1,8194,4,2,103,112,9604,9609,111,110,59,1,281,102,59,3,55349,56662,4,3,97,108,115,9622,9635,9640,114,4,2,59,115,9629,9631,1,8917,108,59,1,10723,117,115,59,1,10865,105,4,3,59,108,118,9649,9651,9656,1,949,111,110,59,1,949,59,1,1013,4,4,99,115,117,118,9669,9686,9716,9747,4,2,105,111,9675,9680,114,99,59,1,8790,108,111,110,59,1,8789,4,2,105,108,9692,9696,109,59,1,8770,97,110,116,4,2,103,108,9705,9710,116,114,59,1,10902,101,115,115,59,1,10901,4,3,97,101,105,9724,9729,9734,108,115,59,1,61,115,116,59,1,8799,118,4,2,59,68,9741,9743,1,8801,68,59,1,10872,112,97,114,115,108,59,1,10725,4,2,68,97,9761,9766,111,116,59,1,8787,114,114,59,1,10609,4,3,99,100,105,9779,9783,9788,114,59,1,8495,111,116,59,1,8784,109,59,1,8770,4,2,97,104,9798,9801,59,1,951,5,240,1,59,9806,1,240,4,2,109,114,9814,9822,108,5,235,1,59,9820,1,235,111,59,1,8364,4,3,99,105,112,9834,9838,9843,108,59,1,33,115,116,59,1,8707,4,2,101,111,9849,9859,99,116,97,116,105,111,110,59,1,8496,110,101,110,116,105,97,108,101,59,1,8519,4,12,97,99,101,102,105,106,108,110,111,112,114,115,9896,9910,9914,9921,9954,9960,9967,9989,9994,10027,10036,10164,108,108,105,110,103,100,111,116,115,101,113,59,1,8786,121,59,1,1092,109,97,108,101,59,1,9792,4,3,105,108,114,9929,9935,9950,108,105,103,59,1,64259,4,2,105,108,9941,9945,103,59,1,64256,105,103,59,1,64260,59,3,55349,56611,108,105,103,59,1,64257,108,105,103,59,3,102,106,4,3,97,108,116,9975,9979,9984,116,59,1,9837,105,103,59,1,64258,110,115,59,1,9649,111,102,59,1,402,4,2,112,114,10000,10005,102,59,3,55349,56663,4,2,97,107,10011,10016,108,108,59,1,8704,4,2,59,118,10022,10024,1,8916,59,1,10969,97,114,116,105,110,116,59,1,10765,4,2,97,111,10042,10159,4,2,99,115,10048,10155,4,6,49,50,51,52,53,55,10062,10102,10114,10135,10139,10151,4,6,50,51,52,53,54,56,10076,10083,10086,10093,10096,10099,5,189,1,59,10081,1,189,59,1,8531,5,188,1,59,10091,1,188,59,1,8533,59,1,8537,59,1,8539,4,2,51,53,10108,10111,59,1,8532,59,1,8534,4,3,52,53,56,10122,10129,10132,5,190,1,59,10127,1,190,59,1,8535,59,1,8540,53,59,1,8536,4,2,54,56,10145,10148,59,1,8538,59,1,8541,56,59,1,8542,108,59,1,8260,119,110,59,1,8994,99,114,59,3,55349,56507,4,17,69,97,98,99,100,101,102,103,105,106,108,110,111,114,115,116,118,10206,10217,10247,10254,10268,10273,10358,10363,10374,10380,10385,10406,10458,10464,10470,10497,10610,4,2,59,108,10212,10214,1,8807,59,1,10892,4,3,99,109,112,10225,10231,10244,117,116,101,59,1,501,109,97,4,2,59,100,10239,10241,1,947,59,1,989,59,1,10886,114,101,118,101,59,1,287,4,2,105,121,10260,10265,114,99,59,1,285,59,1,1075,111,116,59,1,289,4,4,59,108,113,115,10283,10285,10288,10308,1,8805,59,1,8923,4,3,59,113,115,10296,10298,10301,1,8805,59,1,8807,108,97,110,116,59,1,10878,4,4,59,99,100,108,10318,10320,10324,10345,1,10878,99,59,1,10921,111,116,4,2,59,111,10332,10334,1,10880,4,2,59,108,10340,10342,1,10882,59,1,10884,4,2,59,101,10351,10354,3,8923,65024,115,59,1,10900,114,59,3,55349,56612,4,2,59,103,10369,10371,1,8811,59,1,8921,109,101,108,59,1,8503,99,121,59,1,1107,4,4,59,69,97,106,10395,10397,10400,10403,1,8823,59,1,10898,59,1,10917,59,1,10916,4,4,69,97,101,115,10416,10419,10434,10453,59,1,8809,112,4,2,59,112,10426,10428,1,10890,114,111,120,59,1,10890,4,2,59,113,10440,10442,1,10888,4,2,59,113,10448,10450,1,10888,59,1,8809,105,109,59,1,8935,112,102,59,3,55349,56664,97,118,101,59,1,96,4,2,99,105,10476,10480,114,59,1,8458,109,4,3,59,101,108,10489,10491,10494,1,8819,59,1,10894,59,1,10896,5,62,6,59,99,100,108,113,114,10512,10514,10527,10532,10538,10545,1,62,4,2,99,105,10520,10523,59,1,10919,114,59,1,10874,111,116,59,1,8919,80,97,114,59,1,10645,117,101,115,116,59,1,10876,4,5,97,100,101,108,115,10557,10574,10579,10599,10605,4,2,112,114,10563,10570,112,114,111,120,59,1,10886,114,59,1,10616,111,116,59,1,8919,113,4,2,108,113,10586,10592,101,115,115,59,1,8923,108,101,115,115,59,1,10892,101,115,115,59,1,8823,105,109,59,1,8819,4,2,101,110,10616,10626,114,116,110,101,113,113,59,3,8809,65024,69,59,3,8809,65024,4,10,65,97,98,99,101,102,107,111,115,121,10653,10658,10713,10718,10724,10760,10765,10786,10850,10875,114,114,59,1,8660,4,4,105,108,109,114,10668,10674,10678,10684,114,115,112,59,1,8202,102,59,1,189,105,108,116,59,1,8459,4,2,100,114,10690,10695,99,121,59,1,1098,4,3,59,99,119,10703,10705,10710,1,8596,105,114,59,1,10568,59,1,8621,97,114,59,1,8463,105,114,99,59,1,293,4,3,97,108,114,10732,10748,10754,114,116,115,4,2,59,117,10741,10743,1,9829,105,116,59,1,9829,108,105,112,59,1,8230,99,111,110,59,1,8889,114,59,3,55349,56613,115,4,2,101,119,10772,10779,97,114,111,119,59,1,10533,97,114,111,119,59,1,10534,4,5,97,109,111,112,114,10798,10803,10809,10839,10844,114,114,59,1,8703,116,104,116,59,1,8763,107,4,2,108,114,10816,10827,101,102,116,97,114,114,111,119,59,1,8617,105,103,104,116,97,114,114,111,119,59,1,8618,102,59,3,55349,56665,98,97,114,59,1,8213,4,3,99,108,116,10858,10863,10869,114,59,3,55349,56509,97,115,104,59,1,8463,114,111,107,59,1,295,4,2,98,112,10881,10887,117,108,108,59,1,8259,104,101,110,59,1,8208,4,15,97,99,101,102,103,105,106,109,110,111,112,113,115,116,117,10925,10936,10958,10977,10990,11001,11039,11045,11101,11192,11220,11226,11237,11285,11299,99,117,116,101,5,237,1,59,10934,1,237,4,3,59,105,121,10944,10946,10955,1,8291,114,99,5,238,1,59,10953,1,238,59,1,1080,4,2,99,120,10964,10968,121,59,1,1077,99,108,5,161,1,59,10975,1,161,4,2,102,114,10983,10986,59,1,8660,59,3,55349,56614,114,97,118,101,5,236,1,59,10999,1,236,4,4,59,105,110,111,11011,11013,11028,11034,1,8520,4,2,105,110,11019,11024,110,116,59,1,10764,116,59,1,8749,102,105,110,59,1,10716,116,97,59,1,8489,108,105,103,59,1,307,4,3,97,111,112,11053,11092,11096,4,3,99,103,116,11061,11065,11088,114,59,1,299,4,3,101,108,112,11073,11076,11082,59,1,8465,105,110,101,59,1,8464,97,114,116,59,1,8465,104,59,1,305,102,59,1,8887,101,100,59,1,437,4,5,59,99,102,111,116,11113,11115,11121,11136,11142,1,8712,97,114,101,59,1,8453,105,110,4,2,59,116,11129,11131,1,8734,105,101,59,1,10717,100,111,116,59,1,305,4,5,59,99,101,108,112,11154,11156,11161,11179,11186,1,8747,97,108,59,1,8890,4,2,103,114,11167,11173,101,114,115,59,1,8484,99,97,108,59,1,8890,97,114,104,107,59,1,10775,114,111,100,59,1,10812,4,4,99,103,112,116,11202,11206,11211,11216,121,59,1,1105,111,110,59,1,303,102,59,3,55349,56666,97,59,1,953,114,111,100,59,1,10812,117,101,115,116,5,191,1,59,11235,1,191,4,2,99,105,11243,11248,114,59,3,55349,56510,110,4,5,59,69,100,115,118,11261,11263,11266,11271,11282,1,8712,59,1,8953,111,116,59,1,8949,4,2,59,118,11277,11279,1,8948,59,1,8947,59,1,8712,4,2,59,105,11291,11293,1,8290,108,100,101,59,1,297,4,2,107,109,11305,11310,99,121,59,1,1110,108,5,239,1,59,11316,1,239,4,6,99,102,109,111,115,117,11332,11346,11351,11357,11363,11380,4,2,105,121,11338,11343,114,99,59,1,309,59,1,1081,114,59,3,55349,56615,97,116,104,59,1,567,112,102,59,3,55349,56667,4,2,99,101,11369,11374,114,59,3,55349,56511,114,99,121,59,1,1112,107,99,121,59,1,1108,4,8,97,99,102,103,104,106,111,115,11404,11418,11433,11438,11445,11450,11455,11461,112,112,97,4,2,59,118,11413,11415,1,954,59,1,1008,4,2,101,121,11424,11430,100,105,108,59,1,311,59,1,1082,114,59,3,55349,56616,114,101,101,110,59,1,312,99,121,59,1,1093,99,121,59,1,1116,112,102,59,3,55349,56668,99,114,59,3,55349,56512,4,23,65,66,69,72,97,98,99,100,101,102,103,104,106,108,109,110,111,112,114,115,116,117,118,11515,11538,11544,11555,11560,11721,11780,11818,11868,12136,12160,12171,12203,12208,12246,12275,12327,12509,12523,12569,12641,12732,12752,4,3,97,114,116,11523,11528,11532,114,114,59,1,8666,114,59,1,8656,97,105,108,59,1,10523,97,114,114,59,1,10510,4,2,59,103,11550,11552,1,8806,59,1,10891,97,114,59,1,10594,4,9,99,101,103,109,110,112,113,114,116,11580,11586,11594,11600,11606,11624,11627,11636,11694,117,116,101,59,1,314,109,112,116,121,118,59,1,10676,114,97,110,59,1,8466,98,100,97,59,1,955,103,4,3,59,100,108,11615,11617,11620,1,10216,59,1,10641,101,59,1,10216,59,1,10885,117,111,5,171,1,59,11634,1,171,114,4,8,59,98,102,104,108,112,115,116,11655,11657,11669,11673,11677,11681,11685,11690,1,8592,4,2,59,102,11663,11665,1,8676,115,59,1,10527,115,59,1,10525,107,59,1,8617,112,59,1,8619,108,59,1,10553,105,109,59,1,10611,108,59,1,8610,4,3,59,97,101,11702,11704,11709,1,10923,105,108,59,1,10521,4,2,59,115,11715,11717,1,10925,59,3,10925,65024,4,3,97,98,114,11729,11734,11739,114,114,59,1,10508,114,107,59,1,10098,4,2,97,107,11745,11758,99,4,2,101,107,11752,11755,59,1,123,59,1,91,4,2,101,115,11764,11767,59,1,10635,108,4,2,100,117,11774,11777,59,1,10639,59,1,10637,4,4,97,101,117,121,11790,11796,11811,11815,114,111,110,59,1,318,4,2,100,105,11802,11807,105,108,59,1,316,108,59,1,8968,98,59,1,123,59,1,1083,4,4,99,113,114,115,11828,11832,11845,11864,97,59,1,10550,117,111,4,2,59,114,11840,11842,1,8220,59,1,8222,4,2,100,117,11851,11857,104,97,114,59,1,10599,115,104,97,114,59,1,10571,104,59,1,8626,4,5,59,102,103,113,115,11880,11882,12008,12011,12031,1,8804,116,4,5,97,104,108,114,116,11895,11913,11935,11947,11996,114,114,111,119,4,2,59,116,11905,11907,1,8592,97,105,108,59,1,8610,97,114,112,111,111,110,4,2,100,117,11925,11931,111,119,110,59,1,8637,112,59,1,8636,101,102,116,97,114,114,111,119,115,59,1,8647,105,103,104,116,4,3,97,104,115,11959,11974,11984,114,114,111,119,4,2,59,115,11969,11971,1,8596,59,1,8646,97,114,112,111,111,110,115,59,1,8651,113,117,105,103,97,114,114,111,119,59,1,8621,104,114,101,101,116,105,109,101,115,59,1,8907,59,1,8922,4,3,59,113,115,12019,12021,12024,1,8804,59,1,8806,108,97,110,116,59,1,10877,4,5,59,99,100,103,115,12043,12045,12049,12070,12083,1,10877,99,59,1,10920,111,116,4,2,59,111,12057,12059,1,10879,4,2,59,114,12065,12067,1,10881,59,1,10883,4,2,59,101,12076,12079,3,8922,65024,115,59,1,10899,4,5,97,100,101,103,115,12095,12103,12108,12126,12131,112,112,114,111,120,59,1,10885,111,116,59,1,8918,113,4,2,103,113,12115,12120,116,114,59,1,8922,103,116,114,59,1,10891,116,114,59,1,8822,105,109,59,1,8818,4,3,105,108,114,12144,12150,12156,115,104,116,59,1,10620,111,111,114,59,1,8970,59,3,55349,56617,4,2,59,69,12166,12168,1,8822,59,1,10897,4,2,97,98,12177,12198,114,4,2,100,117,12184,12187,59,1,8637,4,2,59,108,12193,12195,1,8636,59,1,10602,108,107,59,1,9604,99,121,59,1,1113,4,5,59,97,99,104,116,12220,12222,12227,12235,12241,1,8810,114,114,59,1,8647,111,114,110,101,114,59,1,8990,97,114,100,59,1,10603,114,105,59,1,9722,4,2,105,111,12252,12258,100,111,116,59,1,320,117,115,116,4,2,59,97,12267,12269,1,9136,99,104,101,59,1,9136,4,4,69,97,101,115,12285,12288,12303,12322,59,1,8808,112,4,2,59,112,12295,12297,1,10889,114,111,120,59,1,10889,4,2,59,113,12309,12311,1,10887,4,2,59,113,12317,12319,1,10887,59,1,8808,105,109,59,1,8934,4,8,97,98,110,111,112,116,119,122,12345,12359,12364,12421,12446,12467,12474,12490,4,2,110,114,12351,12355,103,59,1,10220,114,59,1,8701,114,107,59,1,10214,103,4,3,108,109,114,12373,12401,12409,101,102,116,4,2,97,114,12382,12389,114,114,111,119,59,1,10229,105,103,104,116,97,114,114,111,119,59,1,10231,97,112,115,116,111,59,1,10236,105,103,104,116,97,114,114,111,119,59,1,10230,112,97,114,114,111,119,4,2,108,114,12433,12439,101,102,116,59,1,8619,105,103,104,116,59,1,8620,4,3,97,102,108,12454,12458,12462,114,59,1,10629,59,3,55349,56669,117,115,59,1,10797,105,109,101,115,59,1,10804,4,2,97,98,12480,12485,115,116,59,1,8727,97,114,59,1,95,4,3,59,101,102,12498,12500,12506,1,9674,110,103,101,59,1,9674,59,1,10731,97,114,4,2,59,108,12517,12519,1,40,116,59,1,10643,4,5,97,99,104,109,116,12535,12540,12548,12561,12564,114,114,59,1,8646,111,114,110,101,114,59,1,8991,97,114,4,2,59,100,12556,12558,1,8651,59,1,10605,59,1,8206,114,105,59,1,8895,4,6,97,99,104,105,113,116,12583,12589,12594,12597,12614,12635,113,117,111,59,1,8249,114,59,3,55349,56513,59,1,8624,109,4,3,59,101,103,12606,12608,12611,1,8818,59,1,10893,59,1,10895,4,2,98,117,12620,12623,59,1,91,111,4,2,59,114,12630,12632,1,8216,59,1,8218,114,111,107,59,1,322,5,60,8,59,99,100,104,105,108,113,114,12660,12662,12675,12680,12686,12692,12698,12705,1,60,4,2,99,105,12668,12671,59,1,10918,114,59,1,10873,111,116,59,1,8918,114,101,101,59,1,8907,109,101,115,59,1,8905,97,114,114,59,1,10614,117,101,115,116,59,1,10875,4,2,80,105,12711,12716,97,114,59,1,10646,4,3,59,101,102,12724,12726,12729,1,9667,59,1,8884,59,1,9666,114,4,2,100,117,12739,12746,115,104,97,114,59,1,10570,104,97,114,59,1,10598,4,2,101,110,12758,12768,114,116,110,101,113,113,59,3,8808,65024,69,59,3,8808,65024,4,14,68,97,99,100,101,102,104,105,108,110,111,112,115,117,12803,12809,12893,12908,12914,12928,12933,12937,13011,13025,13032,13049,13052,13069,68,111,116,59,1,8762,4,4,99,108,112,114,12819,12827,12849,12887,114,5,175,1,59,12825,1,175,4,2,101,116,12833,12836,59,1,9794,4,2,59,101,12842,12844,1,10016,115,101,59,1,10016,4,2,59,115,12855,12857,1,8614,116,111,4,4,59,100,108,117,12869,12871,12877,12883,1,8614,111,119,110,59,1,8615,101,102,116,59,1,8612,112,59,1,8613,107,101,114,59,1,9646,4,2,111,121,12899,12905,109,109,97,59,1,10793,59,1,1084,97,115,104,59,1,8212,97,115,117,114,101,100,97,110,103,108,101,59,1,8737,114,59,3,55349,56618,111,59,1,8487,4,3,99,100,110,12945,12954,12985,114,111,5,181,1,59,12952,1,181,4,4,59,97,99,100,12964,12966,12971,12976,1,8739,115,116,59,1,42,105,114,59,1,10992,111,116,5,183,1,59,12983,1,183,117,115,4,3,59,98,100,12995,12997,13000,1,8722,59,1,8863,4,2,59,117,13006,13008,1,8760,59,1,10794,4,2,99,100,13017,13021,112,59,1,10971,114,59,1,8230,112,108,117,115,59,1,8723,4,2,100,112,13038,13044,101,108,115,59,1,8871,102,59,3,55349,56670,59,1,8723,4,2,99,116,13058,13063,114,59,3,55349,56514,112,111,115,59,1,8766,4,3,59,108,109,13077,13079,13087,1,956,116,105,109,97,112,59,1,8888,97,112,59,1,8888,4,24,71,76,82,86,97,98,99,100,101,102,103,104,105,106,108,109,111,112,114,115,116,117,118,119,13142,13165,13217,13229,13247,13330,13359,13414,13420,13508,13513,13579,13602,13626,13631,13762,13767,13855,13936,13995,14214,14285,14312,14432,4,2,103,116,13148,13152,59,3,8921,824,4,2,59,118,13158,13161,3,8811,8402,59,3,8811,824,4,3,101,108,116,13173,13200,13204,102,116,4,2,97,114,13181,13188,114,114,111,119,59,1,8653,105,103,104,116,97,114,114,111,119,59,1,8654,59,3,8920,824,4,2,59,118,13210,13213,3,8810,8402,59,3,8810,824,105,103,104,116,97,114,114,111,119,59,1,8655,4,2,68,100,13235,13241,97,115,104,59,1,8879,97,115,104,59,1,8878,4,5,98,99,110,112,116,13259,13264,13270,13275,13308,108,97,59,1,8711,117,116,101,59,1,324,103,59,3,8736,8402,4,5,59,69,105,111,112,13287,13289,13293,13298,13302,1,8777,59,3,10864,824,100,59,3,8779,824,115,59,1,329,114,111,120,59,1,8777,117,114,4,2,59,97,13316,13318,1,9838,108,4,2,59,115,13325,13327,1,9838,59,1,8469,4,2,115,117,13336,13344,112,5,160,1,59,13342,1,160,109,112,4,2,59,101,13352,13355,3,8782,824,59,3,8783,824,4,5,97,101,111,117,121,13371,13385,13391,13407,13411,4,2,112,114,13377,13380,59,1,10819,111,110,59,1,328,100,105,108,59,1,326,110,103,4,2,59,100,13399,13401,1,8775,111,116,59,3,10861,824,112,59,1,10818,59,1,1085,97,115,104,59,1,8211,4,7,59,65,97,100,113,115,120,13436,13438,13443,13466,13472,13478,13494,1,8800,114,114,59,1,8663,114,4,2,104,114,13450,13454,107,59,1,10532,4,2,59,111,13460,13462,1,8599,119,59,1,8599,111,116,59,3,8784,824,117,105,118,59,1,8802,4,2,101,105,13484,13489,97,114,59,1,10536,109,59,3,8770,824,105,115,116,4,2,59,115,13503,13505,1,8708,59,1,8708,114,59,3,55349,56619,4,4,69,101,115,116,13523,13527,13563,13568,59,3,8807,824,4,3,59,113,115,13535,13537,13559,1,8817,4,3,59,113,115,13545,13547,13551,1,8817,59,3,8807,824,108,97,110,116,59,3,10878,824,59,3,10878,824,105,109,59,1,8821,4,2,59,114,13574,13576,1,8815,59,1,8815,4,3,65,97,112,13587,13592,13597,114,114,59,1,8654,114,114,59,1,8622,97,114,59,1,10994,4,3,59,115,118,13610,13612,13623,1,8715,4,2,59,100,13618,13620,1,8956,59,1,8954,59,1,8715,99,121,59,1,1114,4,7,65,69,97,100,101,115,116,13647,13652,13656,13661,13665,13737,13742,114,114,59,1,8653,59,3,8806,824,114,114,59,1,8602,114,59,1,8229,4,4,59,102,113,115,13675,13677,13703,13725,1,8816,116,4,2,97,114,13684,13691,114,114,111,119,59,1,8602,105,103,104,116,97,114,114,111,119,59,1,8622,4,3,59,113,115,13711,13713,13717,1,8816,59,3,8806,824,108,97,110,116,59,3,10877,824,4,2,59,115,13731,13734,3,10877,824,59,1,8814,105,109,59,1,8820,4,2,59,114,13748,13750,1,8814,105,4,2,59,101,13757,13759,1,8938,59,1,8940,105,100,59,1,8740,4,2,112,116,13773,13778,102,59,3,55349,56671,5,172,3,59,105,110,13787,13789,13829,1,172,110,4,4,59,69,100,118,13800,13802,13806,13812,1,8713,59,3,8953,824,111,116,59,3,8949,824,4,3,97,98,99,13820,13823,13826,59,1,8713,59,1,8951,59,1,8950,105,4,2,59,118,13836,13838,1,8716,4,3,97,98,99,13846,13849,13852,59,1,8716,59,1,8958,59,1,8957,4,3,97,111,114,13863,13892,13899,114,4,4,59,97,115,116,13874,13876,13883,13888,1,8742,108,108,101,108,59,1,8742,108,59,3,11005,8421,59,3,8706,824,108,105,110,116,59,1,10772,4,3,59,99,101,13907,13909,13914,1,8832,117,101,59,1,8928,4,2,59,99,13920,13923,3,10927,824,4,2,59,101,13929,13931,1,8832,113,59,3,10927,824,4,4,65,97,105,116,13946,13951,13971,13982,114,114,59,1,8655,114,114,4,3,59,99,119,13961,13963,13967,1,8603,59,3,10547,824,59,3,8605,824,103,104,116,97,114,114,111,119,59,1,8603,114,105,4,2,59,101,13990,13992,1,8939,59,1,8941,4,7,99,104,105,109,112,113,117,14011,14036,14060,14080,14085,14090,14106,4,4,59,99,101,114,14021,14023,14028,14032,1,8833,117,101,59,1,8929,59,3,10928,824,59,3,55349,56515,111,114,116,4,2,109,112,14045,14050,105,100,59,1,8740,97,114,97,108,108,101,108,59,1,8742,109,4,2,59,101,14067,14069,1,8769,4,2,59,113,14075,14077,1,8772,59,1,8772,105,100,59,1,8740,97,114,59,1,8742,115,117,4,2,98,112,14098,14102,101,59,1,8930,101,59,1,8931,4,3,98,99,112,14114,14157,14171,4,4,59,69,101,115,14124,14126,14130,14133,1,8836,59,3,10949,824,59,1,8840,101,116,4,2,59,101,14141,14144,3,8834,8402,113,4,2,59,113,14151,14153,1,8840,59,3,10949,824,99,4,2,59,101,14164,14166,1,8833,113,59,3,10928,824,4,4,59,69,101,115,14181,14183,14187,14190,1,8837,59,3,10950,824,59,1,8841,101,116,4,2,59,101,14198,14201,3,8835,8402,113,4,2,59,113,14208,14210,1,8841,59,3,10950,824,4,4,103,105,108,114,14224,14228,14238,14242,108,59,1,8825,108,100,101,5,241,1,59,14236,1,241,103,59,1,8824,105,97,110,103,108,101,4,2,108,114,14254,14269,101,102,116,4,2,59,101,14263,14265,1,8938,113,59,1,8940,105,103,104,116,4,2,59,101,14279,14281,1,8939,113,59,1,8941,4,2,59,109,14291,14293,1,957,4,3,59,101,115,14301,14303,14308,1,35,114,111,59,1,8470,112,59,1,8199,4,9,68,72,97,100,103,105,108,114,115,14332,14338,14344,14349,14355,14369,14376,14408,14426,97,115,104,59,1,8877,97,114,114,59,1,10500,112,59,3,8781,8402,97,115,104,59,1,8876,4,2,101,116,14361,14365,59,3,8805,8402,59,3,62,8402,110,102,105,110,59,1,10718,4,3,65,101,116,14384,14389,14393,114,114,59,1,10498,59,3,8804,8402,4,2,59,114,14399,14402,3,60,8402,105,101,59,3,8884,8402,4,2,65,116,14414,14419,114,114,59,1,10499,114,105,101,59,3,8885,8402,105,109,59,3,8764,8402,4,3,65,97,110,14440,14445,14468,114,114,59,1,8662,114,4,2,104,114,14452,14456,107,59,1,10531,4,2,59,111,14462,14464,1,8598,119,59,1,8598,101,97,114,59,1,10535,4,18,83,97,99,100,101,102,103,104,105,108,109,111,112,114,115,116,117,118,14512,14515,14535,14560,14597,14603,14618,14643,14657,14662,14701,14741,14747,14769,14851,14877,14907,14916,59,1,9416,4,2,99,115,14521,14531,117,116,101,5,243,1,59,14529,1,243,116,59,1,8859,4,2,105,121,14541,14557,114,4,2,59,99,14548,14550,1,8858,5,244,1,59,14555,1,244,59,1,1086,4,5,97,98,105,111,115,14572,14577,14583,14587,14591,115,104,59,1,8861,108,97,99,59,1,337,118,59,1,10808,116,59,1,8857,111,108,100,59,1,10684,108,105,103,59,1,339,4,2,99,114,14609,14614,105,114,59,1,10687,59,3,55349,56620,4,3,111,114,116,14626,14630,14640,110,59,1,731,97,118,101,5,242,1,59,14638,1,242,59,1,10689,4,2,98,109,14649,14654,97,114,59,1,10677,59,1,937,110,116,59,1,8750,4,4,97,99,105,116,14672,14677,14693,14698,114,114,59,1,8634,4,2,105,114,14683,14687,114,59,1,10686,111,115,115,59,1,10683,110,101,59,1,8254,59,1,10688,4,3,97,101,105,14709,14714,14719,99,114,59,1,333,103,97,59,1,969,4,3,99,100,110,14727,14733,14736,114,111,110,59,1,959,59,1,10678,117,115,59,1,8854,112,102,59,3,55349,56672,4,3,97,101,108,14755,14759,14764,114,59,1,10679,114,112,59,1,10681,117,115,59,1,8853,4,7,59,97,100,105,111,115,118,14785,14787,14792,14831,14837,14841,14848,1,8744,114,114,59,1,8635,4,4,59,101,102,109,14802,14804,14817,14824,1,10845,114,4,2,59,111,14811,14813,1,8500,102,59,1,8500,5,170,1,59,14822,1,170,5,186,1,59,14829,1,186,103,111,102,59,1,8886,114,59,1,10838,108,111,112,101,59,1,10839,59,1,10843,4,3,99,108,111,14859,14863,14873,114,59,1,8500,97,115,104,5,248,1,59,14871,1,248,108,59,1,8856,105,4,2,108,109,14884,14893,100,101,5,245,1,59,14891,1,245,101,115,4,2,59,97,14901,14903,1,8855,115,59,1,10806,109,108,5,246,1,59,14914,1,246,98,97,114,59,1,9021,4,12,97,99,101,102,104,105,108,109,111,114,115,117,14948,14992,14996,15033,15038,15068,15090,15189,15192,15222,15427,15441,114,4,4,59,97,115,116,14959,14961,14976,14989,1,8741,5,182,2,59,108,14968,14970,1,182,108,101,108,59,1,8741,4,2,105,108,14982,14986,109,59,1,10995,59,1,11005,59,1,8706,121,59,1,1087,114,4,5,99,105,109,112,116,15009,15014,15019,15024,15027,110,116,59,1,37,111,100,59,1,46,105,108,59,1,8240,59,1,8869,101,110,107,59,1,8241,114,59,3,55349,56621,4,3,105,109,111,15046,15057,15063,4,2,59,118,15052,15054,1,966,59,1,981,109,97,116,59,1,8499,110,101,59,1,9742,4,3,59,116,118,15076,15078,15087,1,960,99,104,102,111,114,107,59,1,8916,59,1,982,4,2,97,117,15096,15119,110,4,2,99,107,15103,15115,107,4,2,59,104,15110,15112,1,8463,59,1,8462,118,59,1,8463,115,4,9,59,97,98,99,100,101,109,115,116,15140,15142,15148,15151,15156,15168,15171,15179,15184,1,43,99,105,114,59,1,10787,59,1,8862,105,114,59,1,10786,4,2,111,117,15162,15165,59,1,8724,59,1,10789,59,1,10866,110,5,177,1,59,15177,1,177,105,109,59,1,10790,119,111,59,1,10791,59,1,177,4,3,105,112,117,15200,15208,15213,110,116,105,110,116,59,1,10773,102,59,3,55349,56673,110,100,5,163,1,59,15220,1,163,4,10,59,69,97,99,101,105,110,111,115,117,15244,15246,15249,15253,15258,15334,15347,15367,15416,15421,1,8826,59,1,10931,112,59,1,10935,117,101,59,1,8828,4,2,59,99,15264,15266,1,10927,4,6,59,97,99,101,110,115,15280,15282,15290,15299,15303,15329,1,8826,112,112,114,111,120,59,1,10935,117,114,108,121,101,113,59,1,8828,113,59,1,10927,4,3,97,101,115,15311,15319,15324,112,112,114,111,120,59,1,10937,113,113,59,1,10933,105,109,59,1,8936,105,109,59,1,8830,109,101,4,2,59,115,15342,15344,1,8242,59,1,8473,4,3,69,97,115,15355,15358,15362,59,1,10933,112,59,1,10937,105,109,59,1,8936,4,3,100,102,112,15375,15378,15404,59,1,8719,4,3,97,108,115,15386,15392,15398,108,97,114,59,1,9006,105,110,101,59,1,8978,117,114,102,59,1,8979,4,2,59,116,15410,15412,1,8733,111,59,1,8733,105,109,59,1,8830,114,101,108,59,1,8880,4,2,99,105,15433,15438,114,59,3,55349,56517,59,1,968,110,99,115,112,59,1,8200,4,6,102,105,111,112,115,117,15462,15467,15472,15478,15485,15491,114,59,3,55349,56622,110,116,59,1,10764,112,102,59,3,55349,56674,114,105,109,101,59,1,8279,99,114,59,3,55349,56518,4,3,97,101,111,15499,15520,15534,116,4,2,101,105,15506,15515,114,110,105,111,110,115,59,1,8461,110,116,59,1,10774,115,116,4,2,59,101,15528,15530,1,63,113,59,1,8799,116,5,34,1,59,15540,1,34,4,21,65,66,72,97,98,99,100,101,102,104,105,108,109,110,111,112,114,115,116,117,120,15586,15609,15615,15620,15796,15855,15893,15931,15977,16001,16039,16183,16204,16222,16228,16285,16312,16318,16363,16408,16416,4,3,97,114,116,15594,15599,15603,114,114,59,1,8667,114,59,1,8658,97,105,108,59,1,10524,97,114,114,59,1,10511,97,114,59,1,10596,4,7,99,100,101,110,113,114,116,15636,15651,15656,15664,15687,15696,15770,4,2,101,117,15642,15646,59,3,8765,817,116,101,59,1,341,105,99,59,1,8730,109,112,116,121,118,59,1,10675,103,4,4,59,100,101,108,15675,15677,15680,15683,1,10217,59,1,10642,59,1,10661,101,59,1,10217,117,111,5,187,1,59,15694,1,187,114,4,11,59,97,98,99,102,104,108,112,115,116,119,15721,15723,15727,15739,15742,15746,15750,15754,15758,15763,15767,1,8594,112,59,1,10613,4,2,59,102,15733,15735,1,8677,115,59,1,10528,59,1,10547,115,59,1,10526,107,59,1,8618,112,59,1,8620,108,59,1,10565,105,109,59,1,10612,108,59,1,8611,59,1,8605,4,2,97,105,15776,15781,105,108,59,1,10522,111,4,2,59,110,15788,15790,1,8758,97,108,115,59,1,8474,4,3,97,98,114,15804,15809,15814,114,114,59,1,10509,114,107,59,1,10099,4,2,97,107,15820,15833,99,4,2,101,107,15827,15830,59,1,125,59,1,93,4,2,101,115,15839,15842,59,1,10636,108,4,2,100,117,15849,15852,59,1,10638,59,1,10640,4,4,97,101,117,121,15865,15871,15886,15890,114,111,110,59,1,345,4,2,100,105,15877,15882,105,108,59,1,343,108,59,1,8969,98,59,1,125,59,1,1088,4,4,99,108,113,115,15903,15907,15914,15927,97,59,1,10551,100,104,97,114,59,1,10601,117,111,4,2,59,114,15922,15924,1,8221,59,1,8221,104,59,1,8627,4,3,97,99,103,15939,15966,15970,108,4,4,59,105,112,115,15950,15952,15957,15963,1,8476,110,101,59,1,8475,97,114,116,59,1,8476,59,1,8477,116,59,1,9645,5,174,1,59,15975,1,174,4,3,105,108,114,15985,15991,15997,115,104,116,59,1,10621,111,111,114,59,1,8971,59,3,55349,56623,4,2,97,111,16007,16028,114,4,2,100,117,16014,16017,59,1,8641,4,2,59,108,16023,16025,1,8640,59,1,10604,4,2,59,118,16034,16036,1,961,59,1,1009,4,3,103,110,115,16047,16167,16171,104,116,4,6,97,104,108,114,115,116,16063,16081,16103,16130,16143,16155,114,114,111,119,4,2,59,116,16073,16075,1,8594,97,105,108,59,1,8611,97,114,112,111,111,110,4,2,100,117,16093,16099,111,119,110,59,1,8641,112,59,1,8640,101,102,116,4,2,97,104,16112,16120,114,114,111,119,115,59,1,8644,97,114,112,111,111,110,115,59,1,8652,105,103,104,116,97,114,114,111,119,115,59,1,8649,113,117,105,103,97,114,114,111,119,59,1,8605,104,114,101,101,116,105,109,101,115,59,1,8908,103,59,1,730,105,110,103,100,111,116,115,101,113,59,1,8787,4,3,97,104,109,16191,16196,16201,114,114,59,1,8644,97,114,59,1,8652,59,1,8207,111,117,115,116,4,2,59,97,16214,16216,1,9137,99,104,101,59,1,9137,109,105,100,59,1,10990,4,4,97,98,112,116,16238,16252,16257,16278,4,2,110,114,16244,16248,103,59,1,10221,114,59,1,8702,114,107,59,1,10215,4,3,97,102,108,16265,16269,16273,114,59,1,10630,59,3,55349,56675,117,115,59,1,10798,105,109,101,115,59,1,10805,4,2,97,112,16291,16304,114,4,2,59,103,16298,16300,1,41,116,59,1,10644,111,108,105,110,116,59,1,10770,97,114,114,59,1,8649,4,4,97,99,104,113,16328,16334,16339,16342,113,117,111,59,1,8250,114,59,3,55349,56519,59,1,8625,4,2,98,117,16348,16351,59,1,93,111,4,2,59,114,16358,16360,1,8217,59,1,8217,4,3,104,105,114,16371,16377,16383,114,101,101,59,1,8908,109,101,115,59,1,8906,105,4,4,59,101,102,108,16394,16396,16399,16402,1,9657,59,1,8885,59,1,9656,116,114,105,59,1,10702,108,117,104,97,114,59,1,10600,59,1,8478,4,19,97,98,99,100,101,102,104,105,108,109,111,112,113,114,115,116,117,119,122,16459,16466,16472,16572,16590,16672,16687,16746,16844,16850,16924,16963,16988,17115,17121,17154,17206,17614,17656,99,117,116,101,59,1,347,113,117,111,59,1,8218,4,10,59,69,97,99,101,105,110,112,115,121,16494,16496,16499,16513,16518,16531,16536,16556,16564,16569,1,8827,59,1,10932,4,2,112,114,16505,16508,59,1,10936,111,110,59,1,353,117,101,59,1,8829,4,2,59,100,16524,16526,1,10928,105,108,59,1,351,114,99,59,1,349,4,3,69,97,115,16544,16547,16551,59,1,10934,112,59,1,10938,105,109,59,1,8937,111,108,105,110,116,59,1,10771,105,109,59,1,8831,59,1,1089,111,116,4,3,59,98,101,16582,16584,16587,1,8901,59,1,8865,59,1,10854,4,7,65,97,99,109,115,116,120,16606,16611,16634,16642,16646,16652,16668,114,114,59,1,8664,114,4,2,104,114,16618,16622,107,59,1,10533,4,2,59,111,16628,16630,1,8600,119,59,1,8600,116,5,167,1,59,16640,1,167,105,59,1,59,119,97,114,59,1,10537,109,4,2,105,110,16659,16665,110,117,115,59,1,8726,59,1,8726,116,59,1,10038,114,4,2,59,111,16679,16682,3,55349,56624,119,110,59,1,8994,4,4,97,99,111,121,16697,16702,16716,16739,114,112,59,1,9839,4,2,104,121,16708,16713,99,121,59,1,1097,59,1,1096,114,116,4,2,109,112,16724,16729,105,100,59,1,8739,97,114,97,108,108,101,108,59,1,8741,5,173,1,59,16744,1,173,4,2,103,109,16752,16770,109,97,4,3,59,102,118,16762,16764,16767,1,963,59,1,962,59,1,962,4,8,59,100,101,103,108,110,112,114,16788,16790,16795,16806,16817,16828,16832,16838,1,8764,111,116,59,1,10858,4,2,59,113,16801,16803,1,8771,59,1,8771,4,2,59,69,16812,16814,1,10910,59,1,10912,4,2,59,69,16823,16825,1,10909,59,1,10911,101,59,1,8774,108,117,115,59,1,10788,97,114,114,59,1,10610,97,114,114,59,1,8592,4,4,97,101,105,116,16860,16883,16891,16904,4,2,108,115,16866,16878,108,115,101,116,109,105,110,117,115,59,1,8726,104,112,59,1,10803,112,97,114,115,108,59,1,10724,4,2,100,108,16897,16900,59,1,8739,101,59,1,8995,4,2,59,101,16910,16912,1,10922,4,2,59,115,16918,16920,1,10924,59,3,10924,65024,4,3,102,108,112,16932,16938,16958,116,99,121,59,1,1100,4,2,59,98,16944,16946,1,47,4,2,59,97,16952,16954,1,10692,114,59,1,9023,102,59,3,55349,56676,97,4,2,100,114,16970,16985,101,115,4,2,59,117,16978,16980,1,9824,105,116,59,1,9824,59,1,8741,4,3,99,115,117,16996,17028,17089,4,2,97,117,17002,17015,112,4,2,59,115,17009,17011,1,8851,59,3,8851,65024,112,4,2,59,115,17022,17024,1,8852,59,3,8852,65024,117,4,2,98,112,17035,17062,4,3,59,101,115,17043,17045,17048,1,8847,59,1,8849,101,116,4,2,59,101,17056,17058,1,8847,113,59,1,8849,4,3,59,101,115,17070,17072,17075,1,8848,59,1,8850,101,116,4,2,59,101,17083,17085,1,8848,113,59,1,8850,4,3,59,97,102,17097,17099,17112,1,9633,114,4,2,101,102,17106,17109,59,1,9633,59,1,9642,59,1,9642,97,114,114,59,1,8594,4,4,99,101,109,116,17131,17136,17142,17148,114,59,3,55349,56520,116,109,110,59,1,8726,105,108,101,59,1,8995,97,114,102,59,1,8902,4,2,97,114,17160,17172,114,4,2,59,102,17167,17169,1,9734,59,1,9733,4,2,97,110,17178,17202,105,103,104,116,4,2,101,112,17188,17197,112,115,105,108,111,110,59,1,1013,104,105,59,1,981,115,59,1,175,4,5,98,99,109,110,112,17218,17351,17420,17423,17427,4,9,59,69,100,101,109,110,112,114,115,17238,17240,17243,17248,17261,17267,17279,17285,17291,1,8834,59,1,10949,111,116,59,1,10941,4,2,59,100,17254,17256,1,8838,111,116,59,1,10947,117,108,116,59,1,10945,4,2,69,101,17273,17276,59,1,10955,59,1,8842,108,117,115,59,1,10943,97,114,114,59,1,10617,4,3,101,105,117,17299,17335,17339,116,4,3,59,101,110,17308,17310,17322,1,8834,113,4,2,59,113,17317,17319,1,8838,59,1,10949,101,113,4,2,59,113,17330,17332,1,8842,59,1,10955,109,59,1,10951,4,2,98,112,17345,17348,59,1,10965,59,1,10963,99,4,6,59,97,99,101,110,115,17366,17368,17376,17385,17389,17415,1,8827,112,112,114,111,120,59,1,10936,117,114,108,121,101,113,59,1,8829,113,59,1,10928,4,3,97,101,115,17397,17405,17410,112,112,114,111,120,59,1,10938,113,113,59,1,10934,105,109,59,1,8937,105,109,59,1,8831,59,1,8721,103,59,1,9834,4,13,49,50,51,59,69,100,101,104,108,109,110,112,115,17455,17462,17469,17476,17478,17481,17496,17509,17524,17530,17536,17548,17554,5,185,1,59,17460,1,185,5,178,1,59,17467,1,178,5,179,1,59,17474,1,179,1,8835,59,1,10950,4,2,111,115,17487,17491,116,59,1,10942,117,98,59,1,10968,4,2,59,100,17502,17504,1,8839,111,116,59,1,10948,115,4,2,111,117,17516,17520,108,59,1,10185,98,59,1,10967,97,114,114,59,1,10619,117,108,116,59,1,10946,4,2,69,101,17542,17545,59,1,10956,59,1,8843,108,117,115,59,1,10944,4,3,101,105,117,17562,17598,17602,116,4,3,59,101,110,17571,17573,17585,1,8835,113,4,2,59,113,17580,17582,1,8839,59,1,10950,101,113,4,2,59,113,17593,17595,1,8843,59,1,10956,109,59,1,10952,4,2,98,112,17608,17611,59,1,10964,59,1,10966,4,3,65,97,110,17622,17627,17650,114,114,59,1,8665,114,4,2,104,114,17634,17638,107,59,1,10534,4,2,59,111,17644,17646,1,8601,119,59,1,8601,119,97,114,59,1,10538,108,105,103,5,223,1,59,17664,1,223,4,13,97,98,99,100,101,102,104,105,111,112,114,115,119,17694,17709,17714,17737,17742,17749,17754,17860,17905,17957,17964,18090,18122,4,2,114,117,17700,17706,103,101,116,59,1,8982,59,1,964,114,107,59,1,9140,4,3,97,101,121,17722,17728,17734,114,111,110,59,1,357,100,105,108,59,1,355,59,1,1090,111,116,59,1,8411,108,114,101,99,59,1,8981,114,59,3,55349,56625,4,4,101,105,107,111,17764,17805,17836,17851,4,2,114,116,17770,17786,101,4,2,52,102,17777,17780,59,1,8756,111,114,101,59,1,8756,97,4,3,59,115,118,17795,17797,17802,1,952,121,109,59,1,977,59,1,977,4,2,99,110,17811,17831,107,4,2,97,115,17818,17826,112,112,114,111,120,59,1,8776,105,109,59,1,8764,115,112,59,1,8201,4,2,97,115,17842,17846,112,59,1,8776,105,109,59,1,8764,114,110,5,254,1,59,17858,1,254,4,3,108,109,110,17868,17873,17901,100,101,59,1,732,101,115,5,215,3,59,98,100,17884,17886,17898,1,215,4,2,59,97,17892,17894,1,8864,114,59,1,10801,59,1,10800,116,59,1,8749,4,3,101,112,115,17913,17917,17953,97,59,1,10536,4,4,59,98,99,102,17927,17929,17934,17939,1,8868,111,116,59,1,9014,105,114,59,1,10993,4,2,59,111,17945,17948,3,55349,56677,114,107,59,1,10970,97,59,1,10537,114,105,109,101,59,1,8244,4,3,97,105,112,17972,17977,18082,100,101,59,1,8482,4,7,97,100,101,109,112,115,116,17993,18051,18056,18059,18066,18072,18076,110,103,108,101,4,5,59,100,108,113,114,18009,18011,18017,18032,18035,1,9653,111,119,110,59,1,9663,101,102,116,4,2,59,101,18026,18028,1,9667,113,59,1,8884,59,1,8796,105,103,104,116,4,2,59,101,18045,18047,1,9657,113,59,1,8885,111,116,59,1,9708,59,1,8796,105,110,117,115,59,1,10810,108,117,115,59,1,10809,98,59,1,10701,105,109,101,59,1,10811,101,122,105,117,109,59,1,9186,4,3,99,104,116,18098,18111,18116,4,2,114,121,18104,18108,59,3,55349,56521,59,1,1094,99,121,59,1,1115,114,111,107,59,1,359,4,2,105,111,18128,18133,120,116,59,1,8812,104,101,97,100,4,2,108,114,18143,18154,101,102,116,97,114,114,111,119,59,1,8606,105,103,104,116,97,114,114,111,119,59,1,8608,4,18,65,72,97,98,99,100,102,103,104,108,109,111,112,114,115,116,117,119,18204,18209,18214,18234,18250,18268,18292,18308,18319,18343,18379,18397,18413,18504,18547,18553,18584,18603,114,114,59,1,8657,97,114,59,1,10595,4,2,99,114,18220,18230,117,116,101,5,250,1,59,18228,1,250,114,59,1,8593,114,4,2,99,101,18241,18245,121,59,1,1118,118,101,59,1,365,4,2,105,121,18256,18265,114,99,5,251,1,59,18263,1,251,59,1,1091,4,3,97,98,104,18276,18281,18287,114,114,59,1,8645,108,97,99,59,1,369,97,114,59,1,10606,4,2,105,114,18298,18304,115,104,116,59,1,10622,59,3,55349,56626,114,97,118,101,5,249,1,59,18317,1,249,4,2,97,98,18325,18338,114,4,2,108,114,18332,18335,59,1,8639,59,1,8638,108,107,59,1,9600,4,2,99,116,18349,18374,4,2,111,114,18355,18369,114,110,4,2,59,101,18363,18365,1,8988,114,59,1,8988,111,112,59,1,8975,114,105,59,1,9720,4,2,97,108,18385,18390,99,114,59,1,363,5,168,1,59,18395,1,168,4,2,103,112,18403,18408,111,110,59,1,371,102,59,3,55349,56678,4,6,97,100,104,108,115,117,18427,18434,18445,18470,18475,18494,114,114,111,119,59,1,8593,111,119,110,97,114,114,111,119,59,1,8597,97,114,112,111,111,110,4,2,108,114,18457,18463,101,102,116,59,1,8639,105,103,104,116,59,1,8638,117,115,59,1,8846,105,4,3,59,104,108,18484,18486,18489,1,965,59,1,978,111,110,59,1,965,112,97,114,114,111,119,115,59,1,8648,4,3,99,105,116,18512,18537,18542,4,2,111,114,18518,18532,114,110,4,2,59,101,18526,18528,1,8989,114,59,1,8989,111,112,59,1,8974,110,103,59,1,367,114,105,59,1,9721,99,114,59,3,55349,56522,4,3,100,105,114,18561,18566,18572,111,116,59,1,8944,108,100,101,59,1,361,105,4,2,59,102,18579,18581,1,9653,59,1,9652,4,2,97,109,18590,18595,114,114,59,1,8648,108,5,252,1,59,18601,1,252,97,110,103,108,101,59,1,10663,4,15,65,66,68,97,99,100,101,102,108,110,111,112,114,115,122,18643,18648,18661,18667,18847,18851,18857,18904,18909,18915,18931,18937,18943,18949,18996,114,114,59,1,8661,97,114,4,2,59,118,18656,18658,1,10984,59,1,10985,97,115,104,59,1,8872,4,2,110,114,18673,18679,103,114,116,59,1,10652,4,7,101,107,110,112,114,115,116,18695,18704,18711,18720,18742,18754,18810,112,115,105,108,111,110,59,1,1013,97,112,112,97,59,1,1008,111,116,104,105,110,103,59,1,8709,4,3,104,105,114,18728,18732,18735,105,59,1,981,59,1,982,111,112,116,111,59,1,8733,4,2,59,104,18748,18750,1,8597,111,59,1,1009,4,2,105,117,18760,18766,103,109,97,59,1,962,4,2,98,112,18772,18791,115,101,116,110,101,113,4,2,59,113,18784,18787,3,8842,65024,59,3,10955,65024,115,101,116,110,101,113,4,2,59,113,18803,18806,3,8843,65024,59,3,10956,65024,4,2,104,114,18816,18822,101,116,97,59,1,977,105,97,110,103,108,101,4,2,108,114,18834,18840,101,102,116,59,1,8882,105,103,104,116,59,1,8883,121,59,1,1074,97,115,104,59,1,8866,4,3,101,108,114,18865,18884,18890,4,3,59,98,101,18873,18875,18880,1,8744,97,114,59,1,8891,113,59,1,8794,108,105,112,59,1,8942,4,2,98,116,18896,18901,97,114,59,1,124,59,1,124,114,59,3,55349,56627,116,114,105,59,1,8882,115,117,4,2,98,112,18923,18927,59,3,8834,8402,59,3,8835,8402,112,102,59,3,55349,56679,114,111,112,59,1,8733,116,114,105,59,1,8883,4,2,99,117,18955,18960,114,59,3,55349,56523,4,2,98,112,18966,18981,110,4,2,69,101,18973,18977,59,3,10955,65024,59,3,8842,65024,110,4,2,69,101,18988,18992,59,3,10956,65024,59,3,8843,65024,105,103,122,97,103,59,1,10650,4,7,99,101,102,111,112,114,115,19020,19026,19061,19066,19072,19075,19089,105,114,99,59,1,373,4,2,100,105,19032,19055,4,2,98,103,19038,19043,97,114,59,1,10847,101,4,2,59,113,19050,19052,1,8743,59,1,8793,101,114,112,59,1,8472,114,59,3,55349,56628,112,102,59,3,55349,56680,59,1,8472,4,2,59,101,19081,19083,1,8768,97,116,104,59,1,8768,99,114,59,3,55349,56524,4,14,99,100,102,104,105,108,109,110,111,114,115,117,118,119,19125,19146,19152,19157,19173,19176,19192,19197,19202,19236,19252,19269,19286,19291,4,3,97,105,117,19133,19137,19142,112,59,1,8898,114,99,59,1,9711,112,59,1,8899,116,114,105,59,1,9661,114,59,3,55349,56629,4,2,65,97,19163,19168,114,114,59,1,10234,114,114,59,1,10231,59,1,958,4,2,65,97,19182,19187,114,114,59,1,10232,114,114,59,1,10229,97,112,59,1,10236,105,115,59,1,8955,4,3,100,112,116,19210,19215,19230,111,116,59,1,10752,4,2,102,108,19221,19225,59,3,55349,56681,117,115,59,1,10753,105,109,101,59,1,10754,4,2,65,97,19242,19247,114,114,59,1,10233,114,114,59,1,10230,4,2,99,113,19258,19263,114,59,3,55349,56525,99,117,112,59,1,10758,4,2,112,116,19275,19281,108,117,115,59,1,10756,114,105,59,1,9651,101,101,59,1,8897,101,100,103,101,59,1,8896,4,8,97,99,101,102,105,111,115,117,19316,19335,19349,19357,19362,19367,19373,19379,99,4,2,117,121,19323,19332,116,101,5,253,1,59,19330,1,253,59,1,1103,4,2,105,121,19341,19346,114,99,59,1,375,59,1,1099,110,5,165,1,59,19355,1,165,114,59,3,55349,56630,99,121,59,1,1111,112,102,59,3,55349,56682,99,114,59,3,55349,56526,4,2,99,109,19385,19389,121,59,1,1102,108,5,255,1,59,19395,1,255,4,10,97,99,100,101,102,104,105,111,115,119,19419,19426,19441,19446,19462,19467,19472,19480,19486,19492,99,117,116,101,59,1,378,4,2,97,121,19432,19438,114,111,110,59,1,382,59,1,1079,111,116,59,1,380,4,2,101,116,19452,19458,116,114,102,59,1,8488,97,59,1,950,114,59,3,55349,56631,99,121,59,1,1078,103,114,97,114,114,59,1,8669,112,102,59,3,55349,56683,99,114,59,3,55349,56527,4,2,106,110,19498,19501,59,1,8205,106,59,1,8204]);","'use strict';\n\nconst unicode = require('../common/unicode');\nconst ERR = require('../common/error-codes');\n\n//Aliases\nconst $ = unicode.CODE_POINTS;\n\n//Const\nconst DEFAULT_BUFFER_WATERLINE = 1 << 16;\n\n//Preprocessor\n//NOTE: HTML input preprocessing\n//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream)\nclass Preprocessor {\n    constructor() {\n        this.html = null;\n\n        this.pos = -1;\n        this.lastGapPos = -1;\n        this.lastCharPos = -1;\n\n        this.gapStack = [];\n\n        this.skipNextNewLine = false;\n\n        this.lastChunkWritten = false;\n        this.endOfChunkHit = false;\n        this.bufferWaterline = DEFAULT_BUFFER_WATERLINE;\n    }\n\n    _err() {\n        // NOTE: err reporting is noop by default. Enabled by mixin.\n    }\n\n    _addGap() {\n        this.gapStack.push(this.lastGapPos);\n        this.lastGapPos = this.pos;\n    }\n\n    _processSurrogate(cp) {\n        //NOTE: try to peek a surrogate pair\n        if (this.pos !== this.lastCharPos) {\n            const nextCp = this.html.charCodeAt(this.pos + 1);\n\n            if (unicode.isSurrogatePair(nextCp)) {\n                //NOTE: we have a surrogate pair. Peek pair character and recalculate code point.\n                this.pos++;\n\n                //NOTE: add gap that should be avoided during retreat\n                this._addGap();\n\n                return unicode.getSurrogatePairCodePoint(cp, nextCp);\n            }\n        }\n\n        //NOTE: we are at the end of a chunk, therefore we can't infer surrogate pair yet.\n        else if (!this.lastChunkWritten) {\n            this.endOfChunkHit = true;\n            return $.EOF;\n        }\n\n        //NOTE: isolated surrogate\n        this._err(ERR.surrogateInInputStream);\n\n        return cp;\n    }\n\n    dropParsedChunk() {\n        if (this.pos > this.bufferWaterline) {\n            this.lastCharPos -= this.pos;\n            this.html = this.html.substring(this.pos);\n            this.pos = 0;\n            this.lastGapPos = -1;\n            this.gapStack = [];\n        }\n    }\n\n    write(chunk, isLastChunk) {\n        if (this.html) {\n            this.html += chunk;\n        } else {\n            this.html = chunk;\n        }\n\n        this.lastCharPos = this.html.length - 1;\n        this.endOfChunkHit = false;\n        this.lastChunkWritten = isLastChunk;\n    }\n\n    insertHtmlAtCurrentPos(chunk) {\n        this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1, this.html.length);\n\n        this.lastCharPos = this.html.length - 1;\n        this.endOfChunkHit = false;\n    }\n\n    advance() {\n        this.pos++;\n\n        if (this.pos > this.lastCharPos) {\n            this.endOfChunkHit = !this.lastChunkWritten;\n            return $.EOF;\n        }\n\n        let cp = this.html.charCodeAt(this.pos);\n\n        //NOTE: any U+000A LINE FEED (LF) characters that immediately follow a U+000D CARRIAGE RETURN (CR) character\n        //must be ignored.\n        if (this.skipNextNewLine && cp === $.LINE_FEED) {\n            this.skipNextNewLine = false;\n            this._addGap();\n            return this.advance();\n        }\n\n        //NOTE: all U+000D CARRIAGE RETURN (CR) characters must be converted to U+000A LINE FEED (LF) characters\n        if (cp === $.CARRIAGE_RETURN) {\n            this.skipNextNewLine = true;\n            return $.LINE_FEED;\n        }\n\n        this.skipNextNewLine = false;\n\n        if (unicode.isSurrogate(cp)) {\n            cp = this._processSurrogate(cp);\n        }\n\n        //OPTIMIZATION: first check if code point is in the common allowed\n        //range (ASCII alphanumeric, whitespaces, big chunk of BMP)\n        //before going into detailed performance cost validation.\n        const isCommonValidRange =\n            (cp > 0x1f && cp < 0x7f) || cp === $.LINE_FEED || cp === $.CARRIAGE_RETURN || (cp > 0x9f && cp < 0xfdd0);\n\n        if (!isCommonValidRange) {\n            this._checkForProblematicCharacters(cp);\n        }\n\n        return cp;\n    }\n\n    _checkForProblematicCharacters(cp) {\n        if (unicode.isControlCodePoint(cp)) {\n            this._err(ERR.controlCharacterInInputStream);\n        } else if (unicode.isUndefinedCodePoint(cp)) {\n            this._err(ERR.noncharacterInInputStream);\n        }\n    }\n\n    retreat() {\n        if (this.pos === this.lastGapPos) {\n            this.lastGapPos = this.gapStack.pop();\n            this.pos--;\n        }\n\n        this.pos--;\n    }\n}\n\nmodule.exports = Preprocessor;\n","'use strict';\n\nconst { DOCUMENT_MODE } = require('../common/html');\n\n//Node construction\nexports.createDocument = function() {\n    return {\n        nodeName: '#document',\n        mode: DOCUMENT_MODE.NO_QUIRKS,\n        childNodes: []\n    };\n};\n\nexports.createDocumentFragment = function() {\n    return {\n        nodeName: '#document-fragment',\n        childNodes: []\n    };\n};\n\nexports.createElement = function(tagName, namespaceURI, attrs) {\n    return {\n        nodeName: tagName,\n        tagName: tagName,\n        attrs: attrs,\n        namespaceURI: namespaceURI,\n        childNodes: [],\n        parentNode: null\n    };\n};\n\nexports.createCommentNode = function(data) {\n    return {\n        nodeName: '#comment',\n        data: data,\n        parentNode: null\n    };\n};\n\nconst createTextNode = function(value) {\n    return {\n        nodeName: '#text',\n        value: value,\n        parentNode: null\n    };\n};\n\n//Tree mutation\nconst appendChild = (exports.appendChild = function(parentNode, newNode) {\n    parentNode.childNodes.push(newNode);\n    newNode.parentNode = parentNode;\n});\n\nconst insertBefore = (exports.insertBefore = function(parentNode, newNode, referenceNode) {\n    const insertionIdx = parentNode.childNodes.indexOf(referenceNode);\n\n    parentNode.childNodes.splice(insertionIdx, 0, newNode);\n    newNode.parentNode = parentNode;\n});\n\nexports.setTemplateContent = function(templateElement, contentElement) {\n    templateElement.content = contentElement;\n};\n\nexports.getTemplateContent = function(templateElement) {\n    return templateElement.content;\n};\n\nexports.setDocumentType = function(document, name, publicId, systemId) {\n    let doctypeNode = null;\n\n    for (let i = 0; i < document.childNodes.length; i++) {\n        if (document.childNodes[i].nodeName === '#documentType') {\n            doctypeNode = document.childNodes[i];\n            break;\n        }\n    }\n\n    if (doctypeNode) {\n        doctypeNode.name = name;\n        doctypeNode.publicId = publicId;\n        doctypeNode.systemId = systemId;\n    } else {\n        appendChild(document, {\n            nodeName: '#documentType',\n            name: name,\n            publicId: publicId,\n            systemId: systemId\n        });\n    }\n};\n\nexports.setDocumentMode = function(document, mode) {\n    document.mode = mode;\n};\n\nexports.getDocumentMode = function(document) {\n    return document.mode;\n};\n\nexports.detachNode = function(node) {\n    if (node.parentNode) {\n        const idx = node.parentNode.childNodes.indexOf(node);\n\n        node.parentNode.childNodes.splice(idx, 1);\n        node.parentNode = null;\n    }\n};\n\nexports.insertText = function(parentNode, text) {\n    if (parentNode.childNodes.length) {\n        const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];\n\n        if (prevNode.nodeName === '#text') {\n            prevNode.value += text;\n            return;\n        }\n    }\n\n    appendChild(parentNode, createTextNode(text));\n};\n\nexports.insertTextBefore = function(parentNode, text, referenceNode) {\n    const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];\n\n    if (prevNode && prevNode.nodeName === '#text') {\n        prevNode.value += text;\n    } else {\n        insertBefore(parentNode, createTextNode(text), referenceNode);\n    }\n};\n\nexports.adoptAttributes = function(recipient, attrs) {\n    const recipientAttrsMap = [];\n\n    for (let i = 0; i < recipient.attrs.length; i++) {\n        recipientAttrsMap.push(recipient.attrs[i].name);\n    }\n\n    for (let j = 0; j < attrs.length; j++) {\n        if (recipientAttrsMap.indexOf(attrs[j].name) === -1) {\n            recipient.attrs.push(attrs[j]);\n        }\n    }\n};\n\n//Tree traversing\nexports.getFirstChild = function(node) {\n    return node.childNodes[0];\n};\n\nexports.getChildNodes = function(node) {\n    return node.childNodes;\n};\n\nexports.getParentNode = function(node) {\n    return node.parentNode;\n};\n\nexports.getAttrList = function(element) {\n    return element.attrs;\n};\n\n//Node data\nexports.getTagName = function(element) {\n    return element.tagName;\n};\n\nexports.getNamespaceURI = function(element) {\n    return element.namespaceURI;\n};\n\nexports.getTextNodeContent = function(textNode) {\n    return textNode.value;\n};\n\nexports.getCommentNodeContent = function(commentNode) {\n    return commentNode.data;\n};\n\nexports.getDocumentTypeNodeName = function(doctypeNode) {\n    return doctypeNode.name;\n};\n\nexports.getDocumentTypeNodePublicId = function(doctypeNode) {\n    return doctypeNode.publicId;\n};\n\nexports.getDocumentTypeNodeSystemId = function(doctypeNode) {\n    return doctypeNode.systemId;\n};\n\n//Node types\nexports.isTextNode = function(node) {\n    return node.nodeName === '#text';\n};\n\nexports.isCommentNode = function(node) {\n    return node.nodeName === '#comment';\n};\n\nexports.isDocumentTypeNode = function(node) {\n    return node.nodeName === '#documentType';\n};\n\nexports.isElementNode = function(node) {\n    return !!node.tagName;\n};\n\n// Source code location\nexports.setNodeSourceCodeLocation = function(node, location) {\n    node.sourceCodeLocation = location;\n};\n\nexports.getNodeSourceCodeLocation = function(node) {\n    return node.sourceCodeLocation;\n};\n\nexports.updateNodeSourceCodeLocation = function(node, endLocation) {\n    node.sourceCodeLocation = Object.assign(node.sourceCodeLocation, endLocation);\n};\n","'use strict';\n\nmodule.exports = function mergeOptions(defaults, options) {\n    options = options || Object.create(null);\n\n    return [defaults, options].reduce((merged, optObj) => {\n        Object.keys(optObj).forEach(key => {\n            merged[key] = optObj[key];\n        });\n\n        return merged;\n    }, Object.create(null));\n};\n","'use strict';\n\nclass Mixin {\n    constructor(host) {\n        const originalMethods = {};\n        const overriddenMethods = this._getOverriddenMethods(this, originalMethods);\n\n        for (const key of Object.keys(overriddenMethods)) {\n            if (typeof overriddenMethods[key] === 'function') {\n                originalMethods[key] = host[key];\n                host[key] = overriddenMethods[key];\n            }\n        }\n    }\n\n    _getOverriddenMethods() {\n        throw new Error('Not implemented');\n    }\n}\n\nMixin.install = function(host, Ctor, opts) {\n    if (!host.__mixins) {\n        host.__mixins = [];\n    }\n\n    for (let i = 0; i < host.__mixins.length; i++) {\n        if (host.__mixins[i].constructor === Ctor) {\n            return host.__mixins[i];\n        }\n    }\n\n    const mixin = new Ctor(host, opts);\n\n    host.__mixins.push(mixin);\n\n    return mixin;\n};\n\nmodule.exports = Mixin;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","/**\n * @license React\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var b=Symbol.for(\"react.element\"),c=Symbol.for(\"react.portal\"),d=Symbol.for(\"react.fragment\"),e=Symbol.for(\"react.strict_mode\"),f=Symbol.for(\"react.profiler\"),g=Symbol.for(\"react.provider\"),h=Symbol.for(\"react.context\"),k=Symbol.for(\"react.server_context\"),l=Symbol.for(\"react.forward_ref\"),m=Symbol.for(\"react.suspense\"),n=Symbol.for(\"react.suspense_list\"),p=Symbol.for(\"react.memo\"),q=Symbol.for(\"react.lazy\"),t=Symbol.for(\"react.offscreen\"),u;u=Symbol.for(\"react.module.reference\");\nfunction v(a){if(\"object\"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}exports.ContextConsumer=h;exports.ContextProvider=g;exports.Element=b;exports.ForwardRef=l;exports.Fragment=d;exports.Lazy=q;exports.Memo=p;exports.Portal=c;exports.Profiler=f;exports.StrictMode=e;exports.Suspense=m;\nexports.SuspenseList=n;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return v(a)===h};exports.isContextProvider=function(a){return v(a)===g};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return v(a)===l};exports.isFragment=function(a){return v(a)===d};exports.isLazy=function(a){return v(a)===q};exports.isMemo=function(a){return v(a)===p};\nexports.isPortal=function(a){return v(a)===c};exports.isProfiler=function(a){return v(a)===f};exports.isStrictMode=function(a){return v(a)===e};exports.isSuspense=function(a){return v(a)===m};exports.isSuspenseList=function(a){return v(a)===n};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||\"object\"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};exports.typeOf=v;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","/**\n * @license React\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}\nfunction g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D=\"function\"===typeof setTimeout?setTimeout:null,E=\"function\"===typeof clearTimeout?clearTimeout:null,F=\"undefined\"!==typeof setImmediate?setImmediate:null;\n\"undefined\"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}\nfunction J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if(\"function\"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;\nfunction M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a)}finally{b?S():(N=!1,O=null)}}else N=!1}var S;if(\"function\"===typeof F)S=function(){F(R)};else if(\"undefined\"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null)}}else S=function(){D(R,0)};function I(a){O=a;N||(N=!0,S())}function K(a,b){L=D(function(){a(exports.unstable_now())},b)}\nexports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J))};\nexports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):P=0<a?Math.floor(1E3/a):5};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y}var c=y;y=b;try{return a()}finally{y=c}};exports.unstable_pauseExecution=function(){};\nexports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=y;y=a;try{return b()}finally{y=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};\nexports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n  module.exports = require('./cjs/scheduler.development.js');\n}\n","var parse = require('inline-style-parser');\n\n/**\n * Parses inline style to object.\n *\n * @example\n * // returns { 'line-height': '42' }\n * StyleToObject('line-height: 42;');\n *\n * @param  {String}      style      - The inline style.\n * @param  {Function}    [iterator] - The iterator function.\n * @return {null|Object}\n */\nfunction StyleToObject(style, iterator) {\n  var output = null;\n  if (!style || typeof style !== 'string') {\n    return output;\n  }\n\n  var declaration;\n  var declarations = parse(style);\n  var hasIterator = typeof iterator === 'function';\n  var property;\n  var value;\n\n  for (var i = 0, len = declarations.length; i < len; i++) {\n    declaration = declarations[i];\n    property = declaration.property;\n    value = declaration.value;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      output || (output = {});\n      output[property] = value;\n    }\n  }\n\n  return output;\n}\n\nmodule.exports = StyleToObject;\n","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n  return arr2;\n}\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\nmodule.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}\nmodule.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\nmodule.exports = _classCallCheck, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nvar isNativeReflectConstruct = require(\"./isNativeReflectConstruct.js\");\nfunction _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    module.exports = _construct = Reflect.construct.bind(), module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  } else {\n    module.exports = _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n  return _construct.apply(null, arguments);\n}\nmodule.exports = _construct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\nmodule.exports = _createClass, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nfunction _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (!it) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      var F = function F() {};\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n  var normalCompletion = true,\n    didErr = false,\n    err;\n  return {\n    s: function s() {\n      it = it.call(o);\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}\nmodule.exports = _createForOfIteratorHelper, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var getPrototypeOf = require(\"./getPrototypeOf.js\");\nvar isNativeReflectConstruct = require(\"./isNativeReflectConstruct.js\");\nvar possibleConstructorReturn = require(\"./possibleConstructorReturn.js\");\nfunction _createSuper(Derived) {\n  var hasNativeReflectConstruct = isNativeReflectConstruct();\n  return function _createSuperInternal() {\n    var Super = getPrototypeOf(Derived),\n      result;\n    if (hasNativeReflectConstruct) {\n      var NewTarget = getPrototypeOf(this).constructor;\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n    return possibleConstructorReturn(this, result);\n  };\n}\nmodule.exports = _createSuper, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var superPropBase = require(\"./superPropBase.js\");\nfunction _get() {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    module.exports = _get = Reflect.get.bind(), module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  } else {\n    module.exports = _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n      if (desc.get) {\n        return desc.get.call(arguments.length < 3 ? target : receiver);\n      }\n      return desc.value;\n    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n  return _get.apply(this, arguments);\n}\nmodule.exports = _get, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _getPrototypeOf(o);\n}\nmodule.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}\nmodule.exports = _isNativeFunction, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\nmodule.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _s, _e;\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n  return _arr;\n}\nmodule.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableRest, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return assertThisInitialized(self);\n}\nmodule.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _setPrototypeOf(o, p);\n}\nmodule.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableRest = require(\"./nonIterableRest.js\");\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\nmodule.exports = _slicedToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var getPrototypeOf = require(\"./getPrototypeOf.js\");\nfunction _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n  return object;\n}\nmodule.exports = _superPropBase, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var getPrototypeOf = require(\"./getPrototypeOf.js\");\nvar setPrototypeOf = require(\"./setPrototypeOf.js\");\nvar isNativeFunction = require(\"./isNativeFunction.js\");\nvar construct = require(\"./construct.js\");\nfunction _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n  module.exports = _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !isNativeFunction(Class)) return Class;\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n      _cache.set(Class, Wrapper);\n    }\n    function Wrapper() {\n      return construct(Class, arguments, getPrototypeOf(this).constructor);\n    }\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return setPrototypeOf(Wrapper, Class);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _wrapNativeSuper(Class);\n}\nmodule.exports = _wrapNativeSuper, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n  return arr2;\n}","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}","import _typeof from \"./typeof.js\";\nimport assertThisInitialized from \"./assertThisInitialized.js\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return assertThisInitialized(self);\n}","import getPrototypeOf from \"./getPrototypeOf.js\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.js\";\nimport possibleConstructorReturn from \"./possibleConstructorReturn.js\";\nexport default function _createSuper(Derived) {\n  var hasNativeReflectConstruct = isNativeReflectConstruct();\n  return function _createSuperInternal() {\n    var Super = getPrototypeOf(Derived),\n      result;\n    if (hasNativeReflectConstruct) {\n      var NewTarget = getPrototypeOf(this).constructor;\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n    return possibleConstructorReturn(this, result);\n  };\n}","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}","export default function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}","export default function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n  return _setPrototypeOf(o, p);\n}","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","/**\n * @typedef {Object} StringifyOptions\n * @property {boolean} [padLeft=true] Whether to pad a space before a token (`boolean`, default: `true`).\n * @property {boolean} [padRight=false] Whether to pad a space after a token (`boolean`, default: `false`).\n */\n\n/**\n * Parse comma separated tokens to an array.\n *\n * @param {string} value\n * @returns {Array.<string>}\n */\nexport function parse(value) {\n  /** @type {Array.<string>} */\n  var tokens = []\n  var input = String(value || '')\n  var index = input.indexOf(',')\n  var start = 0\n  /** @type {boolean} */\n  var end\n  /** @type {string} */\n  var token\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    token = input.slice(start, index).trim()\n\n    if (token || !end) {\n      tokens.push(token)\n    }\n\n    start = index + 1\n    index = input.indexOf(',', start)\n  }\n\n  return tokens\n}\n\n/**\n * Serialize an array of strings to comma separated tokens.\n *\n * @param {Array.<string|number>} values\n * @param {StringifyOptions} [options]\n * @returns {string}\n */\nexport function stringify(values, options) {\n  var settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  if (values[values.length - 1] === '') {\n    values = values.concat('')\n  }\n\n  return values\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n","/// <reference lib=\"dom\" />\n\n/* eslint-env browser */\n\nconst element = document.createElement('i')\n\n/**\n * @param {string} value\n * @returns {string|false}\n */\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';'\n  element.innerHTML = characterReference\n  const char = element.textContent\n\n  // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  return char === characterReference ? false : char\n}\n","/**\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n */\n\nvar search = /[#.]/g\n\n/**\n * Create a hast element from a simple CSS selector.\n *\n * @param selector A simple CSS selector.\n *   Can contain a tag-name (`foo`), classes (`.bar`), and an ID (`#baz`).\n *   Multiple classes are allowed.\n *   Uses the last ID if multiple IDs are found.\n * @param [defaultTagName='div'] Tag name to use if `selector` does not specify one.\n */\nexport const parseSelector =\n  /**\n   * @type {(\n   *  <Selector extends string, DefaultTagName extends string = 'div'>(selector?: Selector, defaultTagName?: DefaultTagName) => Element & {tagName: import('./extract.js').ExtractTagName<Selector, DefaultTagName>}\n   * )}\n   */\n  (\n    /**\n     * @param {string} [selector]\n     * @param {string} [defaultTagName='div']\n     * @returns {Element}\n     */\n    function (selector, defaultTagName = 'div') {\n      var value = selector || ''\n      /** @type {Properties} */\n      var props = {}\n      var start = 0\n      /** @type {string} */\n      var subvalue\n      /** @type {string} */\n      var previous\n      /** @type {RegExpMatchArray} */\n      var match\n\n      while (start < value.length) {\n        search.lastIndex = start\n        match = search.exec(value)\n        subvalue = value.slice(start, match ? match.index : value.length)\n\n        if (subvalue) {\n          if (!previous) {\n            defaultTagName = subvalue\n          } else if (previous === '#') {\n            props.id = subvalue\n          } else if (Array.isArray(props.className)) {\n            props.className.push(subvalue)\n          } else {\n            props.className = [subvalue]\n          }\n\n          start += subvalue.length\n        }\n\n        if (match) {\n          previous = match[0]\n          start++\n        }\n      }\n\n      return {\n        type: 'element',\n        tagName: defaultTagName,\n        properties: props,\n        children: []\n      }\n    }\n  )\n","/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {Root['children'][number]} Child\n * @typedef {Child|Root} Node\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n *\n * @typedef {Root|Element} HResult\n * @typedef {string|number} HStyleValue\n * @typedef {Record<string, HStyleValue>} HStyle\n * @typedef {string|number|boolean|null|undefined} HPrimitiveValue\n * @typedef {Array<string|number>} HArrayValue\n * @typedef {HPrimitiveValue|HArrayValue} HPropertyValue\n * @typedef {{[property: string]: HPropertyValue|HStyle}} HProperties\n *   Acceptable properties value.\n *\n * @typedef {string|number|null|undefined} HPrimitiveChild\n * @typedef {Array<Node|HPrimitiveChild>} HArrayChild\n * @typedef {Node|HPrimitiveChild|HArrayChild} HChild\n *   Acceptable child value\n */\n\nimport {find, normalize} from 'property-information'\nimport {parseSelector} from 'hast-util-parse-selector'\nimport {parse as spaces} from 'space-separated-tokens'\nimport {parse as commas} from 'comma-separated-tokens'\n\nconst buttonTypes = new Set(['menu', 'submit', 'reset', 'button'])\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Schema} schema\n * @param {string} defaultTagName\n * @param {Array<string>} [caseSensitive]\n */\nexport function core(schema, defaultTagName, caseSensitive) {\n  const adjust = caseSensitive && createAdjustMap(caseSensitive)\n\n  const h =\n    /**\n     * @type {{\n     *   (): Root\n     *   (selector: null|undefined, ...children: Array<HChild>): Root\n     *   (selector: string, properties?: HProperties, ...children: Array<HChild>): Element\n     *   (selector: string, ...children: Array<HChild>): Element\n     * }}\n     */\n    (\n      /**\n       * Hyperscript compatible DSL for creating virtual hast trees.\n       *\n       * @param {string|null} [selector]\n       * @param {HProperties|HChild} [properties]\n       * @param {Array<HChild>} children\n       * @returns {HResult}\n       */\n      function (selector, properties, ...children) {\n        let index = -1\n        /** @type {HResult} */\n        let node\n\n        if (selector === undefined || selector === null) {\n          node = {type: 'root', children: []}\n          // @ts-expect-error Properties are not supported for roots.\n          children.unshift(properties)\n        } else {\n          node = parseSelector(selector, defaultTagName)\n          // Normalize the name.\n          node.tagName = node.tagName.toLowerCase()\n          if (adjust && own.call(adjust, node.tagName)) {\n            node.tagName = adjust[node.tagName]\n          }\n\n          // Handle props.\n          if (isProperties(properties, node.tagName)) {\n            /** @type {string} */\n            let key\n\n            for (key in properties) {\n              if (own.call(properties, key)) {\n                // @ts-expect-error `node.properties` is set.\n                addProperty(schema, node.properties, key, properties[key])\n              }\n            }\n          } else {\n            children.unshift(properties)\n          }\n        }\n\n        // Handle children.\n        while (++index < children.length) {\n          addChild(node.children, children[index])\n        }\n\n        if (node.type === 'element' && node.tagName === 'template') {\n          node.content = {type: 'root', children: node.children}\n          node.children = []\n        }\n\n        return node\n      }\n    )\n\n  return h\n}\n\n/**\n * @param {HProperties|HChild} value\n * @param {string} name\n * @returns {value is HProperties}\n */\nfunction isProperties(value, name) {\n  if (\n    value === null ||\n    value === undefined ||\n    typeof value !== 'object' ||\n    Array.isArray(value)\n  ) {\n    return false\n  }\n\n  if (name === 'input' || !value.type || typeof value.type !== 'string') {\n    return true\n  }\n\n  if ('children' in value && Array.isArray(value.children)) {\n    return false\n  }\n\n  if (name === 'button') {\n    return buttonTypes.has(value.type.toLowerCase())\n  }\n\n  return !('value' in value)\n}\n\n/**\n * @param {Schema} schema\n * @param {Properties} properties\n * @param {string} key\n * @param {HStyle|HPropertyValue} value\n * @returns {void}\n */\nfunction addProperty(schema, properties, key, value) {\n  const info = find(schema, key)\n  let index = -1\n  /** @type {HPropertyValue} */\n  let result\n\n  // Ignore nullish and NaN values.\n  if (value === undefined || value === null) return\n\n  if (typeof value === 'number') {\n    // Ignore NaN.\n    if (Number.isNaN(value)) return\n\n    result = value\n  }\n  // Booleans.\n  else if (typeof value === 'boolean') {\n    result = value\n  }\n  // Handle list values.\n  else if (typeof value === 'string') {\n    if (info.spaceSeparated) {\n      result = spaces(value)\n    } else if (info.commaSeparated) {\n      result = commas(value)\n    } else if (info.commaOrSpaceSeparated) {\n      result = spaces(commas(value).join(' '))\n    } else {\n      result = parsePrimitive(info, info.property, value)\n    }\n  } else if (Array.isArray(value)) {\n    result = value.concat()\n  } else {\n    result = info.property === 'style' ? style(value) : String(value)\n  }\n\n  if (Array.isArray(result)) {\n    /** @type {Array<string|number>} */\n    const finalResult = []\n\n    while (++index < result.length) {\n      // @ts-expect-error Assume no booleans in array.\n      finalResult[index] = parsePrimitive(info, info.property, result[index])\n    }\n\n    result = finalResult\n  }\n\n  // Class names (which can be added both on the `selector` and here).\n  if (info.property === 'className' && Array.isArray(properties.className)) {\n    // @ts-expect-error Assume no booleans in `className`.\n    result = properties.className.concat(result)\n  }\n\n  properties[info.property] = result\n}\n\n/**\n * @param {Array<Child>} nodes\n * @param {HChild} value\n * @returns {void}\n */\nfunction addChild(nodes, value) {\n  let index = -1\n\n  if (value === undefined || value === null) {\n    // Empty.\n  } else if (typeof value === 'string' || typeof value === 'number') {\n    nodes.push({type: 'text', value: String(value)})\n  } else if (Array.isArray(value)) {\n    while (++index < value.length) {\n      addChild(nodes, value[index])\n    }\n  } else if (typeof value === 'object' && 'type' in value) {\n    if (value.type === 'root') {\n      addChild(nodes, value.children)\n    } else {\n      nodes.push(value)\n    }\n  } else {\n    throw new Error('Expected node, nodes, or string, got `' + value + '`')\n  }\n}\n\n/**\n * Parse a single primitives.\n *\n * @param {Info} info\n * @param {string} name\n * @param {HPrimitiveValue} value\n * @returns {HPrimitiveValue}\n */\nfunction parsePrimitive(info, name, value) {\n  if (typeof value === 'string') {\n    if (info.number && value && !Number.isNaN(Number(value))) {\n      return Number(value)\n    }\n\n    if (\n      (info.boolean || info.overloadedBoolean) &&\n      (value === '' || normalize(value) === normalize(name))\n    ) {\n      return true\n    }\n  }\n\n  return value\n}\n\n/**\n * @param {HStyle} value\n * @returns {string}\n */\nfunction style(value) {\n  /** @type {Array<string>} */\n  const result = []\n  /** @type {string} */\n  let key\n\n  for (key in value) {\n    if (own.call(value, key)) {\n      result.push([key, value[key]].join(': '))\n    }\n  }\n\n  return result.join('; ')\n}\n\n/**\n * @param {Array<string>} values\n * @returns {Record<string, string>}\n */\nfunction createAdjustMap(values) {\n  /** @type {Record<string, string>} */\n  const result = {}\n  let index = -1\n\n  while (++index < values.length) {\n    result[values[index].toLowerCase()] = values[index]\n  }\n\n  return result\n}\n","/**\n * @typedef {import('./core.js').HChild} Child Acceptable child value\n * @typedef {import('./core.js').HProperties} Properties Acceptable properties value.\n *\n * @typedef {import('./jsx-classic').Element} h.JSX.Element\n * @typedef {import('./jsx-classic').IntrinsicAttributes} h.JSX.IntrinsicAttributes\n * @typedef {import('./jsx-classic').IntrinsicElements} h.JSX.IntrinsicElements\n * @typedef {import('./jsx-classic').ElementChildrenAttribute} h.JSX.ElementChildrenAttribute\n */\n\nimport {html} from 'property-information'\nimport {core} from './core.js'\n\nexport const h = core(html, 'div')\n","/**\n * List of legacy HTML named character references that don’t need a trailing semicolon.\n *\n * @type {Array<string>}\n */\nexport const characterEntitiesLegacy = [\n  'AElig',\n  'AMP',\n  'Aacute',\n  'Acirc',\n  'Agrave',\n  'Aring',\n  'Atilde',\n  'Auml',\n  'COPY',\n  'Ccedil',\n  'ETH',\n  'Eacute',\n  'Ecirc',\n  'Egrave',\n  'Euml',\n  'GT',\n  'Iacute',\n  'Icirc',\n  'Igrave',\n  'Iuml',\n  'LT',\n  'Ntilde',\n  'Oacute',\n  'Ocirc',\n  'Ograve',\n  'Oslash',\n  'Otilde',\n  'Ouml',\n  'QUOT',\n  'REG',\n  'THORN',\n  'Uacute',\n  'Ucirc',\n  'Ugrave',\n  'Uuml',\n  'Yacute',\n  'aacute',\n  'acirc',\n  'acute',\n  'aelig',\n  'agrave',\n  'amp',\n  'aring',\n  'atilde',\n  'auml',\n  'brvbar',\n  'ccedil',\n  'cedil',\n  'cent',\n  'copy',\n  'curren',\n  'deg',\n  'divide',\n  'eacute',\n  'ecirc',\n  'egrave',\n  'eth',\n  'euml',\n  'frac12',\n  'frac14',\n  'frac34',\n  'gt',\n  'iacute',\n  'icirc',\n  'iexcl',\n  'igrave',\n  'iquest',\n  'iuml',\n  'laquo',\n  'lt',\n  'macr',\n  'micro',\n  'middot',\n  'nbsp',\n  'not',\n  'ntilde',\n  'oacute',\n  'ocirc',\n  'ograve',\n  'ordf',\n  'ordm',\n  'oslash',\n  'otilde',\n  'ouml',\n  'para',\n  'plusmn',\n  'pound',\n  'quot',\n  'raquo',\n  'reg',\n  'sect',\n  'shy',\n  'sup1',\n  'sup2',\n  'sup3',\n  'szlig',\n  'thorn',\n  'times',\n  'uacute',\n  'ucirc',\n  'ugrave',\n  'uml',\n  'uuml',\n  'yacute',\n  'yen',\n  'yuml'\n]\n","/**\n * Map of invalid numeric character references to their replacements, according to HTML.\n *\n * @type {Record<number, string>}\n */\nexport const characterReferenceInvalid = {\n  0: '�',\n  128: '€',\n  130: '‚',\n  131: 'ƒ',\n  132: '„',\n  133: '…',\n  134: '†',\n  135: '‡',\n  136: 'ˆ',\n  137: '‰',\n  138: 'Š',\n  139: '‹',\n  140: 'Œ',\n  142: 'Ž',\n  145: '‘',\n  146: '’',\n  147: '“',\n  148: '”',\n  149: '•',\n  150: '–',\n  151: '—',\n  152: '˜',\n  153: '™',\n  154: 'š',\n  155: '›',\n  156: 'œ',\n  158: 'ž',\n  159: 'Ÿ'\n}\n","/**\n * Check if the given character code, or the character code at the first\n * character, is decimal.\n *\n * @param {string|number} character\n * @returns {boolean} Whether `character` is a decimal\n */\nexport function isDecimal(character) {\n  const code =\n    typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return code >= 48 && code <= 57 /* 0-9 */\n}\n","/**\n * Check if the given character code, or the character code at the first\n * character, is hexadecimal.\n *\n * @param {string|number} character\n * @returns {boolean} Whether `character` is hexadecimal\n */\nexport function isHexadecimal(character) {\n  const code =\n    typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return (\n    (code >= 97 /* a */ && code <= 102) /* z */ ||\n    (code >= 65 /* A */ && code <= 70) /* Z */ ||\n    (code >= 48 /* A */ && code <= 57) /* Z */\n  )\n}\n","import {isAlphabetical} from 'is-alphabetical'\nimport {isDecimal} from 'is-decimal'\n\n/**\n * Check if the given character code, or the character code at the first\n * character, is alphanumerical.\n *\n * @param {string|number} character\n * @returns {boolean} Whether `character` is alphanumerical.\n */\nexport function isAlphanumerical(character) {\n  return isAlphabetical(character) || isDecimal(character)\n}\n","/**\n * Check if the given character code, or the character code at the first\n * character, is alphabetical.\n *\n * @param {string|number} character\n * @returns {boolean} Whether `character` is alphabetical.\n */\nexport function isAlphabetical(character) {\n  const code =\n    typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return (\n    (code >= 97 && code <= 122) /* a-z */ ||\n    (code >= 65 && code <= 90) /* A-Z */\n  )\n}\n","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\nimport {characterEntitiesLegacy} from 'character-entities-legacy'\nimport {characterReferenceInvalid} from 'character-reference-invalid'\nimport {isDecimal} from 'is-decimal'\nimport {isHexadecimal} from 'is-hexadecimal'\nimport {isAlphanumerical} from 'is-alphanumerical'\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\n\nconst fromCharCode = String.fromCharCode\n\n// Warning messages.\nconst messages = [\n  '',\n  /* 1: Non terminated (named) */\n  'Named character references must be terminated by a semicolon',\n  /* 2: Non terminated (numeric) */\n  'Numeric character references must be terminated by a semicolon',\n  /* 3: Empty (named) */\n  'Named character references cannot be empty',\n  /* 4: Empty (numeric) */\n  'Numeric character references cannot be empty',\n  /* 5: Unknown (named) */\n  'Named character references must be known',\n  /* 6: Disallowed (numeric) */\n  'Numeric character references cannot be disallowed',\n  /* 7: Prohibited (numeric) */\n  'Numeric character references cannot be outside the permissible Unicode range'\n]\n\n/**\n * Parse HTML character references.\n *\n * @param {string} value\n * @param {import('../index.js').Options} [options={}]\n */\nexport function parseEntities(value, options = {}) {\n  const additional =\n    typeof options.additional === 'string'\n      ? options.additional.charCodeAt(0)\n      : options.additional\n  /** @type {string[]} */\n  const result = []\n  let index = 0\n  let lines = -1\n  let queue = ''\n  /** @type {Point|undefined} */\n  let point\n  /** @type {number[]|undefined} */\n  let indent\n\n  if (options.position) {\n    if ('start' in options.position || 'indent' in options.position) {\n      indent = options.position.indent\n      point = options.position.start\n    } else {\n      point = options.position\n    }\n  }\n\n  let line = (point ? point.line : 0) || 1\n  let column = (point ? point.column : 0) || 1\n\n  // Cache the current point.\n  let previous = now()\n  /** @type {number|undefined} */\n  let character\n\n  // Ensure the algorithm walks over the first character (inclusive).\n  index--\n\n  while (++index <= value.length) {\n    // If the previous character was a newline.\n    if (character === 10 /* `\\n` */) {\n      column = (indent ? indent[lines] : 0) || 1\n    }\n\n    character = value.charCodeAt(index)\n\n    if (character === 38 /* `&` */) {\n      const following = value.charCodeAt(index + 1)\n\n      // The behavior depends on the identity of the next character.\n      if (\n        following === 9 /* `\\t` */ ||\n        following === 10 /* `\\n` */ ||\n        following === 12 /* `\\f` */ ||\n        following === 32 /* ` ` */ ||\n        following === 38 /* `&` */ ||\n        following === 60 /* `<` */ ||\n        Number.isNaN(following) ||\n        (additional && following === additional)\n      ) {\n        // Not a character reference.\n        // No characters are consumed, and nothing is returned.\n        // This is not an error, either.\n        queue += fromCharCode(character)\n        column++\n        continue\n      }\n\n      const start = index + 1\n      let begin = start\n      let end = start\n      /** @type {string} */\n      let type\n\n      if (following === 35 /* `#` */) {\n        // Numerical reference.\n        end = ++begin\n\n        // The behavior further depends on the next character.\n        const following = value.charCodeAt(end)\n\n        if (following === 88 /* `X` */ || following === 120 /* `x` */) {\n          // ASCII hexadecimal digits.\n          type = 'hexadecimal'\n          end = ++begin\n        } else {\n          // ASCII decimal digits.\n          type = 'decimal'\n        }\n      } else {\n        // Named reference.\n        type = 'named'\n      }\n\n      let characterReferenceCharacters = ''\n      let characterReference = ''\n      let characters = ''\n      // Each type of character reference accepts different characters.\n      // This test is used to detect whether a reference has ended (as the semicolon\n      // is not strictly needed).\n      const test =\n        type === 'named'\n          ? isAlphanumerical\n          : type === 'decimal'\n          ? isDecimal\n          : isHexadecimal\n\n      end--\n\n      while (++end <= value.length) {\n        const following = value.charCodeAt(end)\n\n        if (!test(following)) {\n          break\n        }\n\n        characters += fromCharCode(following)\n\n        // Check if we can match a legacy named reference.\n        // If so, we cache that as the last viable named reference.\n        // This ensures we do not need to walk backwards later.\n        if (type === 'named' && characterEntitiesLegacy.includes(characters)) {\n          characterReferenceCharacters = characters\n          // @ts-expect-error: always able to decode.\n          characterReference = decodeNamedCharacterReference(characters)\n        }\n      }\n\n      let terminated = value.charCodeAt(end) === 59 /* `;` */\n\n      if (terminated) {\n        end++\n\n        const namedReference =\n          type === 'named' ? decodeNamedCharacterReference(characters) : false\n\n        if (namedReference) {\n          characterReferenceCharacters = characters\n          characterReference = namedReference\n        }\n      }\n\n      let diff = 1 + end - start\n      let reference = ''\n\n      if (!terminated && options.nonTerminated === false) {\n        // Empty.\n      } else if (!characters) {\n        // An empty (possible) reference is valid, unless it’s numeric (thus an\n        // ampersand followed by an octothorp).\n        if (type !== 'named') {\n          warning(4 /* Empty (numeric) */, diff)\n        }\n      } else if (type === 'named') {\n        // An ampersand followed by anything unknown, and not terminated, is\n        // invalid.\n        if (terminated && !characterReference) {\n          warning(5 /* Unknown (named) */, 1)\n        } else {\n          // If there’s something after an named reference which is not known,\n          // cap the reference.\n          if (characterReferenceCharacters !== characters) {\n            end = begin + characterReferenceCharacters.length\n            diff = 1 + end - begin\n            terminated = false\n          }\n\n          // If the reference is not terminated, warn.\n          if (!terminated) {\n            const reason = characterReferenceCharacters\n              ? 1 /* Non terminated (named) */\n              : 3 /* Empty (named) */\n\n            if (options.attribute) {\n              const following = value.charCodeAt(end)\n\n              if (following === 61 /* `=` */) {\n                warning(reason, diff)\n                characterReference = ''\n              } else if (isAlphanumerical(following)) {\n                characterReference = ''\n              } else {\n                warning(reason, diff)\n              }\n            } else {\n              warning(reason, diff)\n            }\n          }\n        }\n\n        reference = characterReference\n      } else {\n        if (!terminated) {\n          // All nonterminated numeric references are not rendered, and emit a\n          // warning.\n          warning(2 /* Non terminated (numeric) */, diff)\n        }\n\n        // When terminated and numerical, parse as either hexadecimal or\n        // decimal.\n        let referenceCode = Number.parseInt(\n          characters,\n          type === 'hexadecimal' ? 16 : 10\n        )\n\n        // Emit a warning when the parsed number is prohibited, and replace with\n        // replacement character.\n        if (prohibited(referenceCode)) {\n          warning(7 /* Prohibited (numeric) */, diff)\n          reference = fromCharCode(65533 /* `�` */)\n        } else if (referenceCode in characterReferenceInvalid) {\n          // Emit a warning when the parsed number is disallowed, and replace by\n          // an alternative.\n          warning(6 /* Disallowed (numeric) */, diff)\n          reference = characterReferenceInvalid[referenceCode]\n        } else {\n          // Parse the number.\n          let output = ''\n\n          // Emit a warning when the parsed number should not be used.\n          if (disallowed(referenceCode)) {\n            warning(6 /* Disallowed (numeric) */, diff)\n          }\n\n          // Serialize the number.\n          if (referenceCode > 0xffff) {\n            referenceCode -= 0x10000\n            output += fromCharCode((referenceCode >>> (10 & 0x3ff)) | 0xd800)\n            referenceCode = 0xdc00 | (referenceCode & 0x3ff)\n          }\n\n          reference = output + fromCharCode(referenceCode)\n        }\n      }\n\n      // Found it!\n      // First eat the queued characters as normal text, then eat a reference.\n      if (reference) {\n        flush()\n\n        previous = now()\n        index = end - 1\n        column += end - start + 1\n        result.push(reference)\n        const next = now()\n        next.offset++\n\n        if (options.reference) {\n          options.reference.call(\n            options.referenceContext,\n            reference,\n            {start: previous, end: next},\n            value.slice(start - 1, end)\n          )\n        }\n\n        previous = next\n      } else {\n        // If we could not find a reference, queue the checked characters (as\n        // normal characters), and move the pointer to their end.\n        // This is possible because we can be certain neither newlines nor\n        // ampersands are included.\n        characters = value.slice(start - 1, end)\n        queue += characters\n        column += characters.length\n        index = end - 1\n      }\n    } else {\n      // Handle anything other than an ampersand, including newlines and EOF.\n      if (character === 10 /* `\\n` */) {\n        line++\n        lines++\n        column = 0\n      }\n\n      if (Number.isNaN(character)) {\n        flush()\n      } else {\n        queue += fromCharCode(character)\n        column++\n      }\n    }\n  }\n\n  // Return the reduced nodes.\n  return result.join('')\n\n  // Get current position.\n  function now() {\n    return {\n      line,\n      column,\n      offset: index + ((point ? point.offset : 0) || 0)\n    }\n  }\n\n  /**\n   * Handle the warning.\n   *\n   * @param {1|2|3|4|5|6|7} code\n   * @param {number} offset\n   */\n  function warning(code, offset) {\n    /** @type {ReturnType<now>} */\n    let position\n\n    if (options.warning) {\n      position = now()\n      position.column += offset\n      position.offset += offset\n\n      options.warning.call(\n        options.warningContext,\n        messages[code],\n        position,\n        code\n      )\n    }\n  }\n\n  /**\n   * Flush `queue` (normal text).\n   * Macro invoked before each reference and at the end of `value`.\n   * Does nothing when `queue` is empty.\n   */\n  function flush() {\n    if (queue) {\n      result.push(queue)\n\n      if (options.text) {\n        options.text.call(options.textContext, queue, {\n          start: previous,\n          end: now()\n        })\n      }\n\n      queue = ''\n    }\n  }\n}\n\n/**\n * Check if `character` is outside the permissible unicode range.\n *\n * @param {number} code\n * @returns {boolean}\n */\nfunction prohibited(code) {\n  return (code >= 0xd800 && code <= 0xdfff) || code > 0x10ffff\n}\n\n/**\n * Check if `character` is disallowed.\n *\n * @param {number} code\n * @returns {boolean}\n */\nfunction disallowed(code) {\n  return (\n    (code >= 0x0001 && code <= 0x0008) ||\n    code === 0x000b ||\n    (code >= 0x000d && code <= 0x001f) ||\n    (code >= 0x007f && code <= 0x009f) ||\n    (code >= 0xfdd0 && code <= 0xfdef) ||\n    (code & 0xffff) === 0xffff ||\n    (code & 0xffff) === 0xfffe\n  )\n}\n","/**\n * @typedef {import('./info.js').Info} Info\n * @typedef {Record<string, Info>} Properties\n * @typedef {Record<string, string>} Normal\n */\n\nexport class Schema {\n  /**\n   * @constructor\n   * @param {Properties} property\n   * @param {Normal} normal\n   * @param {string} [space]\n   */\n  constructor(property, normal, space) {\n    this.property = property\n    this.normal = normal\n    if (space) {\n      this.space = space\n    }\n  }\n}\n\n/** @type {Properties} */\nSchema.prototype.property = {}\n/** @type {Normal} */\nSchema.prototype.normal = {}\n/** @type {string|null} */\nSchema.prototype.space = null\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n */\n\nimport {Schema} from './schema.js'\n\n/**\n * @param {Schema[]} definitions\n * @param {string} [space]\n * @returns {Schema}\n */\nexport function merge(definitions, space) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  let index = -1\n\n  while (++index < definitions.length) {\n    Object.assign(property, definitions[index].property)\n    Object.assign(normal, definitions[index].normal)\n  }\n\n  return new Schema(property, normal, space)\n}\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n *\n * @typedef {Record<string, string>} Attributes\n *\n * @typedef {Object} Definition\n * @property {Record<string, number|null>} properties\n * @property {(attributes: Attributes, property: string) => string} transform\n * @property {string} [space]\n * @property {Attributes} [attributes]\n * @property {Array<string>} [mustUseProperty]\n */\n\nimport {normalize} from '../normalize.js'\nimport {Schema} from './schema.js'\nimport {DefinedInfo} from './defined-info.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Definition} definition\n * @returns {Schema}\n */\nexport function create(definition) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  /** @type {string} */\n  let prop\n\n  for (prop in definition.properties) {\n    if (own.call(definition.properties, prop)) {\n      const value = definition.properties[prop]\n      const info = new DefinedInfo(\n        prop,\n        definition.transform(definition.attributes || {}, prop),\n        value,\n        definition.space\n      )\n\n      if (\n        definition.mustUseProperty &&\n        definition.mustUseProperty.includes(prop)\n      ) {\n        info.mustUseProperty = true\n      }\n\n      property[prop] = info\n\n      normal[normalize(prop)] = prop\n      normal[normalize(info.attribute)] = prop\n    }\n  }\n\n  return new Schema(property, normal, definition.space)\n}\n","import {create} from './util/create.js'\n\nexport const xlink = create({\n  space: 'xlink',\n  transform(_, prop) {\n    return 'xlink:' + prop.slice(5).toLowerCase()\n  },\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n})\n","import {create} from './util/create.js'\n\nexport const xml = create({\n  space: 'xml',\n  transform(_, prop) {\n    return 'xml:' + prop.slice(3).toLowerCase()\n  },\n  properties: {xmlLang: null, xmlBase: null, xmlSpace: null}\n})\n","/**\n * @param {Record<string, string>} attributes\n * @param {string} attribute\n * @returns {string}\n */\nexport function caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute\n}\n","import {caseSensitiveTransform} from './case-sensitive-transform.js'\n\n/**\n * @param {Record<string, string>} attributes\n * @param {string} property\n * @returns {string}\n */\nexport function caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase())\n}\n","import {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const xmlns = create({\n  space: 'xmlns',\n  attributes: {xmlnsxlink: 'xmlns:xlink'},\n  transform: caseInsensitiveTransform,\n  properties: {xmlns: null, xmlnsXLink: null}\n})\n","import {booleanish, number, spaceSeparated} from './util/types.js'\nimport {create} from './util/create.js'\n\nexport const aria = create({\n  transform(_, prop) {\n    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()\n  },\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n})\n","import {\n  boolean,\n  overloadedBoolean,\n  booleanish,\n  number,\n  spaceSeparated,\n  commaSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const html = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    capture: boolean,\n    charSet: null,\n    checked: boolean,\n    cite: null,\n    className: spaceSeparated,\n    cols: number,\n    colSpan: null,\n    content: null,\n    contentEditable: booleanish,\n    controls: boolean,\n    controlsList: spaceSeparated,\n    coords: number | commaSeparated,\n    crossOrigin: null,\n    data: null,\n    dateTime: null,\n    decoding: null,\n    default: boolean,\n    defer: boolean,\n    dir: null,\n    dirName: null,\n    disabled: boolean,\n    download: overloadedBoolean,\n    draggable: booleanish,\n    encType: null,\n    enterKeyHint: null,\n    form: null,\n    formAction: null,\n    formEncType: null,\n    formMethod: null,\n    formNoValidate: boolean,\n    formTarget: null,\n    headers: spaceSeparated,\n    height: number,\n    hidden: boolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: null,\n    inputMode: null,\n    integrity: null,\n    is: null,\n    isMap: boolean,\n    itemId: null,\n    itemProp: spaceSeparated,\n    itemRef: spaceSeparated,\n    itemScope: boolean,\n    itemType: spaceSeparated,\n    kind: null,\n    label: null,\n    lang: null,\n    language: null,\n    list: null,\n    loading: null,\n    loop: boolean,\n    low: number,\n    manifest: null,\n    max: null,\n    maxLength: number,\n    media: null,\n    method: null,\n    min: null,\n    minLength: number,\n    multiple: boolean,\n    muted: boolean,\n    name: null,\n    nonce: null,\n    noModule: boolean,\n    noValidate: boolean,\n    onAbort: null,\n    onAfterPrint: null,\n    onAuxClick: null,\n    onBeforePrint: null,\n    onBeforeUnload: null,\n    onBlur: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onContextLost: null,\n    onContextMenu: null,\n    onContextRestored: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFormData: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLanguageChange: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadEnd: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMessageError: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRejectionHandled: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSecurityPolicyViolation: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onSlotChange: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnhandledRejection: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onWheel: null,\n    open: boolean,\n    optimum: number,\n    pattern: null,\n    ping: spaceSeparated,\n    placeholder: null,\n    playsInline: boolean,\n    poster: null,\n    preload: null,\n    readOnly: boolean,\n    referrerPolicy: null,\n    rel: spaceSeparated,\n    required: boolean,\n    reversed: boolean,\n    rows: number,\n    rowSpan: number,\n    sandbox: spaceSeparated,\n    scope: null,\n    scoped: boolean,\n    seamless: boolean,\n    selected: boolean,\n    shape: null,\n    size: number,\n    sizes: null,\n    slot: null,\n    span: number,\n    spellCheck: booleanish,\n    src: null,\n    srcDoc: null,\n    srcLang: null,\n    srcSet: null,\n    start: number,\n    step: null,\n    style: null,\n    tabIndex: number,\n    target: null,\n    title: null,\n    translate: null,\n    type: null,\n    typeMustMatch: boolean,\n    useMap: null,\n    value: booleanish,\n    width: number,\n    wrap: null,\n\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null, // Several. Use CSS `text-align` instead,\n    aLink: null, // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated, // `<object>`. List of URIs to archives\n    axis: null, // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null, // `<body>`. Use CSS `background-image` instead\n    bgColor: null, // `<body>` and table elements. Use CSS `background-color` instead\n    border: number, // `<table>`. Use CSS `border-width` instead,\n    borderColor: null, // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number, // `<body>`\n    cellPadding: null, // `<table>`\n    cellSpacing: null, // `<table>`\n    char: null, // Several table elements. When `align=char`, sets the character to align on\n    charOff: null, // Several table elements. When `char`, offsets the alignment\n    classId: null, // `<object>`\n    clear: null, // `<br>`. Use CSS `clear` instead\n    code: null, // `<object>`\n    codeBase: null, // `<object>`\n    codeType: null, // `<object>`\n    color: null, // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean, // Lists. Use CSS to reduce space between items instead\n    declare: boolean, // `<object>`\n    event: null, // `<script>`\n    face: null, // `<font>`. Use CSS instead\n    frame: null, // `<table>`\n    frameBorder: null, // `<iframe>`. Use CSS `border` instead\n    hSpace: number, // `<img>` and `<object>`\n    leftMargin: number, // `<body>`\n    link: null, // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null, // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null, // `<img>`. Use a `<picture>`\n    marginHeight: number, // `<body>`\n    marginWidth: number, // `<body>`\n    noResize: boolean, // `<frame>`\n    noHref: boolean, // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean, // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean, // `<td>` and `<th>`\n    object: null, // `<applet>`\n    profile: null, // `<head>`\n    prompt: null, // `<isindex>`\n    rev: null, // `<link>`\n    rightMargin: number, // `<body>`\n    rules: null, // `<table>`\n    scheme: null, // `<meta>`\n    scrolling: booleanish, // `<frame>`. Use overflow in the child context\n    standby: null, // `<object>`\n    summary: null, // `<table>`\n    text: null, // `<body>`. Use CSS `color` instead\n    topMargin: number, // `<body>`\n    valueType: null, // `<param>`\n    version: null, // `<html>`. Use a doctype.\n    vAlign: null, // Several. Use CSS `vertical-align` instead\n    vLink: null, // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number, // `<img>` and `<object>`\n\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  }\n})\n","import {\n  boolean,\n  number,\n  spaceSeparated,\n  commaSeparated,\n  commaOrSpaceSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseSensitiveTransform} from './util/case-sensitive-transform.js'\n\nexport const svg = create({\n  space: 'svg',\n  attributes: {\n    accentHeight: 'accent-height',\n    alignmentBaseline: 'alignment-baseline',\n    arabicForm: 'arabic-form',\n    baselineShift: 'baseline-shift',\n    capHeight: 'cap-height',\n    className: 'class',\n    clipPath: 'clip-path',\n    clipRule: 'clip-rule',\n    colorInterpolation: 'color-interpolation',\n    colorInterpolationFilters: 'color-interpolation-filters',\n    colorProfile: 'color-profile',\n    colorRendering: 'color-rendering',\n    crossOrigin: 'crossorigin',\n    dataType: 'datatype',\n    dominantBaseline: 'dominant-baseline',\n    enableBackground: 'enable-background',\n    fillOpacity: 'fill-opacity',\n    fillRule: 'fill-rule',\n    floodColor: 'flood-color',\n    floodOpacity: 'flood-opacity',\n    fontFamily: 'font-family',\n    fontSize: 'font-size',\n    fontSizeAdjust: 'font-size-adjust',\n    fontStretch: 'font-stretch',\n    fontStyle: 'font-style',\n    fontVariant: 'font-variant',\n    fontWeight: 'font-weight',\n    glyphName: 'glyph-name',\n    glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n    glyphOrientationVertical: 'glyph-orientation-vertical',\n    hrefLang: 'hreflang',\n    horizAdvX: 'horiz-adv-x',\n    horizOriginX: 'horiz-origin-x',\n    horizOriginY: 'horiz-origin-y',\n    imageRendering: 'image-rendering',\n    letterSpacing: 'letter-spacing',\n    lightingColor: 'lighting-color',\n    markerEnd: 'marker-end',\n    markerMid: 'marker-mid',\n    markerStart: 'marker-start',\n    navDown: 'nav-down',\n    navDownLeft: 'nav-down-left',\n    navDownRight: 'nav-down-right',\n    navLeft: 'nav-left',\n    navNext: 'nav-next',\n    navPrev: 'nav-prev',\n    navRight: 'nav-right',\n    navUp: 'nav-up',\n    navUpLeft: 'nav-up-left',\n    navUpRight: 'nav-up-right',\n    onAbort: 'onabort',\n    onActivate: 'onactivate',\n    onAfterPrint: 'onafterprint',\n    onBeforePrint: 'onbeforeprint',\n    onBegin: 'onbegin',\n    onCancel: 'oncancel',\n    onCanPlay: 'oncanplay',\n    onCanPlayThrough: 'oncanplaythrough',\n    onChange: 'onchange',\n    onClick: 'onclick',\n    onClose: 'onclose',\n    onCopy: 'oncopy',\n    onCueChange: 'oncuechange',\n    onCut: 'oncut',\n    onDblClick: 'ondblclick',\n    onDrag: 'ondrag',\n    onDragEnd: 'ondragend',\n    onDragEnter: 'ondragenter',\n    onDragExit: 'ondragexit',\n    onDragLeave: 'ondragleave',\n    onDragOver: 'ondragover',\n    onDragStart: 'ondragstart',\n    onDrop: 'ondrop',\n    onDurationChange: 'ondurationchange',\n    onEmptied: 'onemptied',\n    onEnd: 'onend',\n    onEnded: 'onended',\n    onError: 'onerror',\n    onFocus: 'onfocus',\n    onFocusIn: 'onfocusin',\n    onFocusOut: 'onfocusout',\n    onHashChange: 'onhashchange',\n    onInput: 'oninput',\n    onInvalid: 'oninvalid',\n    onKeyDown: 'onkeydown',\n    onKeyPress: 'onkeypress',\n    onKeyUp: 'onkeyup',\n    onLoad: 'onload',\n    onLoadedData: 'onloadeddata',\n    onLoadedMetadata: 'onloadedmetadata',\n    onLoadStart: 'onloadstart',\n    onMessage: 'onmessage',\n    onMouseDown: 'onmousedown',\n    onMouseEnter: 'onmouseenter',\n    onMouseLeave: 'onmouseleave',\n    onMouseMove: 'onmousemove',\n    onMouseOut: 'onmouseout',\n    onMouseOver: 'onmouseover',\n    onMouseUp: 'onmouseup',\n    onMouseWheel: 'onmousewheel',\n    onOffline: 'onoffline',\n    onOnline: 'ononline',\n    onPageHide: 'onpagehide',\n    onPageShow: 'onpageshow',\n    onPaste: 'onpaste',\n    onPause: 'onpause',\n    onPlay: 'onplay',\n    onPlaying: 'onplaying',\n    onPopState: 'onpopstate',\n    onProgress: 'onprogress',\n    onRateChange: 'onratechange',\n    onRepeat: 'onrepeat',\n    onReset: 'onreset',\n    onResize: 'onresize',\n    onScroll: 'onscroll',\n    onSeeked: 'onseeked',\n    onSeeking: 'onseeking',\n    onSelect: 'onselect',\n    onShow: 'onshow',\n    onStalled: 'onstalled',\n    onStorage: 'onstorage',\n    onSubmit: 'onsubmit',\n    onSuspend: 'onsuspend',\n    onTimeUpdate: 'ontimeupdate',\n    onToggle: 'ontoggle',\n    onUnload: 'onunload',\n    onVolumeChange: 'onvolumechange',\n    onWaiting: 'onwaiting',\n    onZoom: 'onzoom',\n    overlinePosition: 'overline-position',\n    overlineThickness: 'overline-thickness',\n    paintOrder: 'paint-order',\n    panose1: 'panose-1',\n    pointerEvents: 'pointer-events',\n    referrerPolicy: 'referrerpolicy',\n    renderingIntent: 'rendering-intent',\n    shapeRendering: 'shape-rendering',\n    stopColor: 'stop-color',\n    stopOpacity: 'stop-opacity',\n    strikethroughPosition: 'strikethrough-position',\n    strikethroughThickness: 'strikethrough-thickness',\n    strokeDashArray: 'stroke-dasharray',\n    strokeDashOffset: 'stroke-dashoffset',\n    strokeLineCap: 'stroke-linecap',\n    strokeLineJoin: 'stroke-linejoin',\n    strokeMiterLimit: 'stroke-miterlimit',\n    strokeOpacity: 'stroke-opacity',\n    strokeWidth: 'stroke-width',\n    tabIndex: 'tabindex',\n    textAnchor: 'text-anchor',\n    textDecoration: 'text-decoration',\n    textRendering: 'text-rendering',\n    typeOf: 'typeof',\n    underlinePosition: 'underline-position',\n    underlineThickness: 'underline-thickness',\n    unicodeBidi: 'unicode-bidi',\n    unicodeRange: 'unicode-range',\n    unitsPerEm: 'units-per-em',\n    vAlphabetic: 'v-alphabetic',\n    vHanging: 'v-hanging',\n    vIdeographic: 'v-ideographic',\n    vMathematical: 'v-mathematical',\n    vectorEffect: 'vector-effect',\n    vertAdvY: 'vert-adv-y',\n    vertOriginX: 'vert-origin-x',\n    vertOriginY: 'vert-origin-y',\n    wordSpacing: 'word-spacing',\n    writingMode: 'writing-mode',\n    xHeight: 'x-height',\n    // These were camelcased in Tiny. Now lowercased in SVG 2\n    playbackOrder: 'playbackorder',\n    timelineBegin: 'timelinebegin'\n  },\n  transform: caseSensitiveTransform,\n  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null, // SEMI_COLON_SEPARATED\n    keySplines: null, // SEMI_COLON_SEPARATED\n    keyTimes: null, // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    u1: null,\n    u2: null,\n    underlinePosition: number,\n    underlineThickness: number,\n    unicode: null,\n    unicodeBidi: null,\n    unicodeRange: null,\n    unitsPerEm: number,\n    values: null,\n    vAlphabetic: number,\n    vMathematical: number,\n    vectorEffect: null,\n    vHanging: number,\n    vIdeographic: number,\n    version: null,\n    vertAdvY: number,\n    vertOriginX: number,\n    vertOriginY: number,\n    viewBox: null,\n    viewTarget: null,\n    visibility: null,\n    width: null,\n    widths: null,\n    wordSpacing: null,\n    writingMode: null,\n    x: null,\n    x1: null,\n    x2: null,\n    xChannelSelector: null,\n    xHeight: number,\n    y: null,\n    y1: null,\n    y2: null,\n    yChannelSelector: null,\n    z: null,\n    zoomAndPan: null\n  }\n})\n","/**\n * @typedef {import('./lib/util/info.js').Info} Info\n * @typedef {import('./lib/util/schema.js').Schema} Schema\n */\n\nimport {merge} from './lib/util/merge.js'\nimport {xlink} from './lib/xlink.js'\nimport {xml} from './lib/xml.js'\nimport {xmlns} from './lib/xmlns.js'\nimport {aria} from './lib/aria.js'\nimport {html as htmlBase} from './lib/html.js'\nimport {svg as svgBase} from './lib/svg.js'\n\nexport {find} from './lib/find.js'\nexport {hastToReact} from './lib/hast-to-react.js'\nexport {normalize} from './lib/normalize.js'\nexport const html = merge([xml, xlink, xmlns, aria, htmlBase], 'html')\nexport const svg = merge([xml, xlink, xmlns, aria, svgBase], 'svg')\n","/**\n * @typedef {import('./util/schema.js').Schema} Schema\n */\n\nimport {normalize} from './normalize.js'\nimport {DefinedInfo} from './util/defined-info.js'\nimport {Info} from './util/info.js'\n\nconst valid = /^data[-\\w.:]+$/i\nconst dash = /-[a-z]/g\nconst cap = /[A-Z]/g\n\n/**\n * @param {Schema} schema\n * @param {string} value\n * @returns {Info}\n */\nexport function find(schema, value) {\n  const normal = normalize(value)\n  let prop = value\n  let Type = Info\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]]\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase)\n      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1)\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4)\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab)\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes\n        }\n\n        value = 'data' + dashes\n      }\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(prop, value)\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n","/**\n * @param {string} value\n * @returns {string}\n */\nexport function normalize(value) {\n  return value.toLowerCase()\n}\n","import {Info} from './info.js'\nimport * as types from './types.js'\n\n/** @type {Array<keyof types>} */\n// @ts-expect-error: hush.\nconst checks = Object.keys(types)\n\nexport class DefinedInfo extends Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   * @param {number|null} [mask]\n   * @param {string} [space]\n   */\n  constructor(property, attribute, mask, space) {\n    let index = -1\n\n    super(property, attribute)\n\n    mark(this, 'space', space)\n\n    if (typeof mask === 'number') {\n      while (++index < checks.length) {\n        const check = checks[index]\n        mark(this, checks[index], (mask & types[check]) === types[check])\n      }\n    }\n  }\n}\n\nDefinedInfo.prototype.defined = true\n\n/**\n * @param {DefinedInfo} values\n * @param {string} key\n * @param {unknown} value\n */\nfunction mark(values, key, value) {\n  if (value) {\n    // @ts-expect-error: assume `value` matches the expected value of `key`.\n    values[key] = value\n  }\n}\n","export class Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   */\n  constructor(property, attribute) {\n    /** @type {string} */\n    this.property = property\n    /** @type {string} */\n    this.attribute = attribute\n  }\n}\n\n/** @type {string|null} */\nInfo.prototype.space = null\nInfo.prototype.boolean = false\nInfo.prototype.booleanish = false\nInfo.prototype.overloadedBoolean = false\nInfo.prototype.number = false\nInfo.prototype.commaSeparated = false\nInfo.prototype.spaceSeparated = false\nInfo.prototype.commaOrSpaceSeparated = false\nInfo.prototype.mustUseProperty = false\nInfo.prototype.defined = false\n","let powers = 0\n\nexport const boolean = increment()\nexport const booleanish = increment()\nexport const overloadedBoolean = increment()\nexport const number = increment()\nexport const spaceSeparated = increment()\nexport const commaSeparated = increment()\nexport const commaOrSpaceSeparated = increment()\n\nfunction increment() {\n  return 2 ** ++powers\n}\n","/**\n * Parse space separated tokens to an array of strings.\n *\n * @param {string} value Space separated tokens\n * @returns {Array.<string>} Tokens\n */\nexport function parse(value) {\n  const input = String(value || '').trim()\n  return input ? input.split(/[ \\t\\n\\r\\f]+/g) : []\n}\n\n/**\n * Serialize an array of strings as space separated tokens.\n *\n * @param {Array.<string|number>} values Tokens\n * @returns {string} Space separated tokens\n */\nexport function stringify(values) {\n  return values.join(' ').trim()\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","var deferred = [];\n__webpack_require__.O = function(result, chunkIds, fn, priority) {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar chunkIds = deferred[i][0];\n\t\tvar fn = deferred[i][1];\n\t\tvar priority = deferred[i][2];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every(function(key) { return __webpack_require__.O[key](chunkIds[j]); })) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(exports) {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.p = \"./\";","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t179: 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n__webpack_require__.O.j = function(chunkId) { return installedChunks[chunkId] === 0; };\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = function(parentChunkLoadingFunction, data) {\n\tvar chunkIds = data[0];\n\tvar moreModules = data[1];\n\tvar runtime = data[2];\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some(function(id) { return installedChunks[id] !== 0; })) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\treturn __webpack_require__.O(result);\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunk_uiw_react_markdown_preview\"] = self[\"webpackChunk_uiw_react_markdown_preview\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","// startup\n// Load entry module and return exports\n// This entry module depends on other loaded chunks and execution need to be delayed\nvar __webpack_exports__ = __webpack_require__.O(undefined, [269,264], function() { return __webpack_require__(9232); })\n__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n"],"names":["_arrayWithHoles","arr","Array","isArray","_nonIterableRest","TypeError","_slicedToArray","i","_i","Symbol","iterator","_s","_e","_arr","_n","_d","call","next","done","push","value","length","err","unsupportedIterableToArray","_extends","Object","assign","bind","target","arguments","source","key","prototype","hasOwnProperty","apply","this","_objectWithoutPropertiesLoose","excluded","sourceKeys","keys","indexOf","_construct","Parent","args","Class","isNativeReflectConstruct","Reflect","construct","a","instance","Function","setPrototypeOf","_wrapNativeSuper","_cache","Map","undefined","fn","toString","has","get","set","Wrapper","getPrototypeOf","constructor","create","enumerable","writable","configurable","GITHUB_CORNERS_TEMPLATE","document","createElement","innerHTML","GithubCorners","right","shadow","attachShadow","mode","appendChild","ownerDocument","importNode","content","update","name","svg","querySelector","test","toLocaleLowerCase","lastElementChild","setAttribute","firstElementChild","style","getAttributeNames","forEach","getAttribute","setAttr","oldValue","newValue","HTMLElement","customElements","define","githubCorners","props","size","fixed","bottom","zIndex","bgColor","color","position","otherProps","styl","left","transform","top","_jsx","width","height","href","fill","Container","render","children","React","map","child","Component","Base","defaultState","forceState","getUrl","state","_jsxs","alt","src","defaultProps","platform","base","Issue","type","property","user","repo","label","join","Size","path","Activity","total","tag","baseData","interval","variant","version","branch","Version","typePath","License","Analysis","query","Social","Github","Issues","Downloads","scope","packageName","dependency","dependencyScope","registryUri","url","concat","format","Npm","warpperStyle","visibility","opacity","transition","cursor","userSelect","svgStyle","display","circleStyle","childStyle","alignItems","justifyContent","fontSize","documentElement","BackToUp","className","prefixCls","element","strokeWidth","smooth","hideProgress","others","$dom","useRef","cls","filter","Boolean","center","useMemo","radius","dasharray","Math","PI","useState","progress","setProgress","handleScroll","ev","clientHeight","scrollHeight","scrollTop","current","useEffect","scrollElement","addEventListener","passive","removeEventListener","ref","onClick","scrollTo","behavior","viewBox","focusable","stroke","r","cx","cy","strokeDasharray","strokeDashoffset","_defineProperty","obj","defineProperty","ownKeys","object","enumerableOnly","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","_objectSpread2","getOwnPropertyDescriptors","defineProperties","stringifyPosition","point","index","line","column","pos","start","end","VFileMessage","reason","place","origin","parts","slice","message","stack","fatal","ruleId","actual","expected","file","note","Error","basename","ext","assertPath","seenNonSlash","charCodeAt","firstNonSlashEnd","extIndex","dirname","unmatchedSlash","extname","startPart","startDot","preDotState","code","joined","segments","normalize","sep","absolute","allowAboveRoot","lastSlashIndex","result","lastSegmentLength","lastSlash","dots","lastIndexOf","normalizeString","JSON","stringify","proc","cwd","isUrl","fileURLOrPath","urlToPath","URL","error","protocol","hostname","pathname","third","decodeURIComponent","getPathFromURLPosix","order","VFile","options","buffer","data","messages","history","stored","prop","includes","assertNonEmpty","assertPart","stem","encoding","part","_toArray","iterableToArray","bail","isPlainObject","toStringTag","wrap","middleware","callback","called","parameters","fnExpectsCallback","exception","Promise","then","output","unified","frozen","transformers","fns","pipeline","run","values","middlewareIndex","pop","use","middelware","trough","attachers","namespace","freezeIndex","processor","assertUnfrozen","own","Parser","Compiler","freeze","attacher","transformer","Number","POSITIVE_INFINITY","settings","addPlugin","addList","addPreset","add","plugin","plugins","entry","isPlainObj","extend","parse","doc","vfile","assertParser","newable","String","node","assertCompiler","assertNode","compile","executor","resolve","reject","tree","runSync","complete","assertDone","process","isBuffer","processSync","destination","asyncName","looksLikeAVFile","includeImageAlt","one","all","splice","list","remove","items","chunkStart","from","unshift","combineExtensions","extensions","syntaxExtension","extension","hook","constructs","existing","before","asciiAlpha","regexCheck","asciiDigit","asciiHexDigit","asciiAlphanumeric","asciiPunctuation","asciiAtext","asciiControl","markdownLineEndingOrSpace","markdownLineEnding","markdownSpace","unicodeWhitespace","unicodePunctuation","regex","fromCharCode","factorySpace","effects","ok","max","limit","enter","prefix","consume","exit","tokenize","previous","contentStart","attempt","parser","contentInitial","lineStart","token","contentType","childFlow","childToken","lineStartOffset","self","continued","item","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","events","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","offset","containerContinue","flow","_tokenizer","flowContinue","writeToChild","eof","stream","sliceStream","defineSkip","write","seen","nok","disable","null","blankLine","partial","subtokenize","event","lineIndex","otherIndex","otherEvent","subevents","more","jumps","_isInFirstContentOfListItem","subcontent","_container","eventIndex","context","startPosition","startPositions","tokenizer","childEvents","gaps","adjust","breaks","_gfmTasklistFirstContentOfListItem","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","initial","flowInitial","afterConstruct","resolver","resolveAll","createResolver","string","initializeFactory","text","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","bufferIndex","tabs","chunk","_index","_bufferIndex","createTokenizer","initialize","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","constructFactory","info","addResult","onsuccessfulcheck","expandTabs","atTab","serializeChunks","main","view","startIndex","startBufferIndex","endIndex","endBufferIndex","sliceChunks","chunkIndex","go","_","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","def","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","resolveTo","thematicBreak","marker","sequence","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","notBlank","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","open","after","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","factoryLabel","markerType","labelEscape","factoryTitle","atFirstTitleBreak","atTitleBreak","title","titleEscape","factoryWhitespace","normalizeIdentifier","replace","toLowerCase","toUpperCase","definition","identifier","labelAfter","titleConstruct","defined","codeIndented","afterStartPrefix","afterPrefix","indentedContent","headingAtx","fenceOpenInside","headingBreak","setextUnderline","paragraph","closingSequence","closingSequenceEnd","heading","htmlBlockNames","htmlRawNames","htmlFlow","startTag","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","htmlLineEnd","continuationRawEndTag","codeFenced","closingFenceConstruct","closingSequenceStart","sizeOpen","nonLazyLine","initialPrefix","sequenceOpen","infoOpen","openAfter","infoAfter","meta","characterReference","numeric","decodeNamedCharacterReference","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","close","media","group","insideSpan","destinationAfter","between","afterLabel","labelStartImage","classifyCharacter","attention","attentionMarkers","_open","_close","openingSequence","nextEvents","movePoint","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","declaration","commentStart","commentStartDash","comment","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","labelStartLink","hardBreakEscape","codeText","gap","tailExitIndex","headEnterIndex","resolveText","search","decodeNumericCharacterReference","parseInt","characterEscapeOrReference","decodeString","decode","$0","$1","$2","head","hex","fromMarkdown","config","configure","transforms","canContainEols","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","html","htmlFlowData","htmlTextData","image","listItem","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","mdastExtensions","tokenStack","listStack","resume","setData","getData","prepareList","handler","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","d","and","errorHandler","onExitError","lang","depth","parent","referenceType","ancestor","fragment","ordered","spread","checked","compiler","postprocess","defaultConstructs","atCarriageReturn","match","endPosition","lastIndex","exec","ceil","preprocess","combined","u","convert","castFactory","typeFactory","anyFactory","propsFactory","tests","checks","SKIP","EXIT","visitParents","visitor","reverse","is","step","factory","parents","visit","subresult","grandparents","toResult","pointStart","pointEnd","clean","unknown","h","augment","handlers","passThrough","returnNode","unknownHandler","nodes","normalizeUri","skip","encodeURIComponent","loose","footnoteReference","counter","id","safeId","footnoteOrder","footnoteCounts","reuseCounter","clobberPrefix","dataFootnoteRef","ariaDescribedBy","revert","subtype","suffix","contents","listItemLoose","trimLine","codePointAt","blockquote","break","delete","footnote","footnoteById","no","dangerous","imageReference","inlineCode","linkReference","listLoose","wrapped","disabled","properties","root","table","rows","align","row","out","cellIndex","cell","last","lines","trimLines","toml","ignore","yaml","footnoteDefinition","allowDangerousHtml","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","footnoteBackLabel","cache","definitions","hName","hProperties","hChildren","ctx","toHast","foot","listItems","referenceIndex","backReferences","backReference","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","footer","bridge","mutate","rehypeFilter","allowedElements","disallowedElements","allowElement","parent_","unwrapDisallowed","protocols","whitespace","thing","hastToReact","classId","dataType","itemId","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","typeOf","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xmlnsXLink","tableElements","Set","childrenToReact","childIndex","toReact","skipHtml","parentSchema","schema","space","addProperty","listDepth","component","components","basic","ReactIs","linkTarget","transformLinkUri","inline","level","charAt","transformImageUri","input","getInputElement","getElementsBeforeCount","textAlign","isHeader","sourcePos","rawSourcePos","sourcePosition","includeElementIndex","siblingCount","count","find","commaSeparated","commas","spaces","v","k","styleReplacer","parseStyle","attribute","deprecated","to","renderers","astPlugins","escapeHtml","allowNode","allowedTypes","disallowedTypes","includeNodeIndex","ReactMarkdown","deprecation","console","warn","remarkParse","remarkPlugins","remarkRehype","remarkRehypeOptions","rehypePlugins","hastNode","uri","trim","first","colon","propTypes","PropTypes","www","w2","w3","dot","domain","hasUnderscoreInLastSegment","hasUnderscoreInLastLastSegment","namedCharacterReference","punctuationContinuation","punctuation","inPath","continuedPunctuation","parenAtPathEnd","pathEnd","trailingPunctuation","wwwAutolink","previousWww","previousUnbalanced","httpAutolink","previousHttp","t1","t2","p","s","slash1","slash2","emailAutolink","hasDot","hasDigitInLastSegment","gfmAtext","previousEmail","atext","dotContinuation","dashOrUnderscoreContinuation","afterDashOrUnderscore","gfmAutolinkLiteral","_gfmAutolinkLiteralWalkedInto","indent","gfmFootnote","tokenizeDefinitionStart","tokenizeDefinitionContinuation","gfmFootnoteDefinitionEnd","tokenizeGfmFootnoteCall","tokenizePotentialGfmFootnoteCall","resolveToPotentialGfmFootnoteCall","gfmFootnotes","replacement","callStart","callData","callEscape","gfmStrikethrough","single","singleTilde","tokenizeStrikethrough","resolveAllStrikethrough","strikethrough","gfmTable","seenDelimiter","hasDash","tableHeaderCount","_align","cellDividerHead","inCellContentHead","cellBreakHead","originalInterrupt","tokenizeRowEnd","atDelimiterRowBreak","atRowEndHead","inWhitespaceHead","inCellContentEscapeHead","rowEndDelimiter","inWhitespaceDelimiter","inFillerDelimiter","afterLeftAlignment","afterRightAlignment","tableClose","nextPrefixedOrBlank","bodyStart","rowStartBody","cellDividerBody","inCellContentBody","cellBreakBody","tableBodyClose","atRowEndBody","inWhitespaceBody","inCellContentEscapeBody","inHead","inDelimiterRow","inRow","cellStart","seenCellInRow","tasklistCheck","spaceThenNonSpace","gfmTaskListItem","gfm","ccount","character","findAndReplace","RegExp","ignored","pairs","toExpression","toFunction","toPairs","pairIndex","grandparent","change","matchObject","global","escape","inConstruct","notInConstruct","gfmAutolinkLiteralFromMarkdown","findUrl","findEmail","literalAutolink","literalAutolinkEmail","enterLiteralAutolinkValue","literalAutolinkHttp","literalAutolinkWww","gfmAutolinkLiteralToMarkdown","unsafe","split","isCorrectDomain","closingParenIndex","openingParens","closingParens","trail","trailExec","splitUrl","email","association","track","options_","lineShift","move","shift","containerFlow","safeOptions","indexStack","tracker","results","handle","bulletLastUsed","repeat","eol","indentLines","patternCompile","pattern","_compiled","patternInScope","listInScope","none","safe","positions","infos","expression","sort","numerical","escapeBackslashes","encode","b","whole","gfmFootnoteToMarkdown","peek","subexit","blank","containerPhrasing","gfmStrikethroughFromMarkdown","gfmStrikethroughToMarkdown","handleDelete","serialize","defaultStringLength","toAlignment","gfmTableFromMarkdown","tableData","enterCell","tableHeader","tableRow","gfmTableToMarkdown","padding","tableCellPadding","alignDelimiters","tablePipeAlign","stringLength","around","serializeData","handleTableRowAsData","handleTableAsData","tableCell","handleTableCell","matrix","alignments","cellMatrix","sizeMatrix","longestCellByColumn","mostCellsPerRow","rowIndex","sizes","columnIndex","delimiterStart","delimiterEnd","markdownTable","listItemIndent","checkListItemIndent","bullet","bulletCurrent","checkBullet","incrementListMarker","gfmTaskListItemFromMarkdown","taskListCheckValueChecked","exitCheck","taskListCheckValueUnchecked","firstParaghraph","siblings","sibling","gfmTaskListItemToMarkdown","checkable","checkbox","gfmFromMarkdown","gfmFootnoteDefinition","gfmFootnoteDefinitionLabelString","gfmFootnoteCall","gfmFootnoteCallString","gfmToMarkdown","remarkGfm","core","webNamespaces","mathml","xlink","xml","xmlns","ast","nodeName","namespaceURI","childNodes","sourceCodeLocation","location","endTag","verbose","attrs","opening","closing","createLocation","quirksMode","loc","indices","toPoint","toOffset","isNaN","startLine","startCol","startOffset","endLine","endCol","endOffset","isFile","ns","toH","react","_isVue","vue","vd","vdom","hyperscript","attributes","addAttribute","subprop","boolean","mustUseProperty","zwitch","invalid","p5","patch","parentNode","doctype","publicId","systemId","htmlVoidElements","endTagToken","parseOptions","sourceCodeLocationInfo","scriptingEnabled","raw","stitches","preprocessor","posTracker","locationTracker","resetTokenizer","_processToken","createParse5Location","chars","forceQuirks","lastGapPos","lastCharPos","gapStack","skipNextNewLine","lastChunkWritten","endOfChunkHit","isEol","lineStartPos","droppedBufferSize","col","currentAttrLocation","ctLoc","_runParsingLoop","_consume","stitch","fromParse5","documentMode","treeAdapter","createDocument","_bootstrap","__mixins","mock","_pushTmplInsertionMode","_initTokenizerForFragmentParsing","_insertFakeRootElement","_resetInsertionMode","_findFormInFragmentContext","_adoptNodes","currentCharacterToken","tokenQueue","charRefCode","tempBuff","lastStartTagName","consumedAfterSnapshot","active","currentToken","currentAttr","selfClosing","toParse5","rehypeRaw","hasProperty","headingRank","slugs","Slugger","rehypeSlug","reset","slug","isElement","convertElement","tagNameFactory","contentDefaults","rehypeAutolinkHeadings","method","behaviour","ariaHidden","tabIndex","inject","toChildren","grouping","toNode","nextChild","nextNode","getCommentObject","param","reduce","keyName","propertiesHandle","defaultAttrs","rehyp","defaultOptions","opts","firstChild","prevChild","attr","openDelimiter","closeDelimiter","rehypePrismGenerator","refractor","refractorRoot","startLineNum","c","classListItem","rootLang","highlight","ignoreMissing","addNodePosition","numLines","entries","initialLineNum","shouldHighlightLine","RE","parsedMeta","str","strlineNumbers","lineNumbers","rangeParser","startingLineNumber","groups","codeLineArray","number","falseShowLineNumbersStr","treeExtract","cascade","preorder","showLineNumbers","some","substring","rehypePrismAll","refractorCommon","refractorAll","ltrRange","rtl","ltr","enterState","dirInferred","found","language","currentDirection","direction","editableOrEditingHost","xmlLang","dir","dirProperty","contentEditable","dirBidi","noop","nestingOperator","shallow","descendant","indexedSearch","nest","_1","_2","firstElementOnly","elementsBefore","elements","elementsByTypeBefore","types","delayed","elementIndex","typeIndex","elementCount","typeCount","tags","ranges","cast","matches","rightIndex","range","leftIndex","extendedFilter","any","someChildren","_3","empty","enabled","assertDeep","scopeElements","selector","selectors","rule","pseudos","appendScope","not","optional","required","readWrite","pseudo","needsIndex","operator","normalizeValue","classNames","collector","Collector","collectAll","ruleSet","collect","ZERO","NINE","nthCheck","formula","parsed","boolbase","absA","abs","bMod","idx","sign","readSign","readNumber","skipWhitespace","fauxEsmNthCheck","nth","CssSelectorParser","valueType","selectAll","registerAttrEqualityMods","registerSelectorPseudos","registerNestingOperators","getCodeString","rewrite","selected","octiconLink","fillRule","reservedMeta","disableCopy","onScroll","onMouseOver","pluginsFilter","rehypeRewrite","warpperElement","other","mdp","useImperativeHandle","container","useCallback","currentTarget","classList","copyTextToClipboard","dataset","setTimeout","btns","_container$current","querySelectorAll","elm","useCopied","rehypePrism","headings","rehypeIgnore","class","rehypeAttrs","customProps","val","setValue","permanent","light","dark","logo","rel","placeholder","spellCheck","onChange","e","MDStr","getElementById","createRoot","cb","el","body","getSelection","rangeCount","getRangeAt","select","isCopy","execCommand","removeChild","removeAllRanges","addRange","t","o","n","hasAttribute","removeAttribute","localStorage","getItem","setItem","l","window","matchMedia","onchange","MutationObserver","colorMode","colorScheme","observe","removeItem","icon","textContent","parentElement","onclick","dispatchEvent","CustomEvent","bubbles","composed","detail","module","exports","trueFunc","falseFunc","parser_context_1","require","render_1","attrEqualityMods","ruleNestingOperators","substitutesEnabled","_a","pseudos_1","unregisterSelectorPseudos","pseudos_2","registerNumericPseudos","pseudos_3","unregisterNumericPseudos","pseudos_4","operators","operators_1","unregisterNestingOperators","operators_2","mods","mods_1","mod","unregisterAttrEqualityMods","mods_2","enableSubstitutes","disableSubstitutes","parseCssSelector","renderEntity","utils_1","chr","getStr","quote","escapeTable","esc","isHex","getIdent","isIdent","identSpecialChars","parseSelector","parseSingleSelector","res","parseRule","currentRule","op","isIdentStart","attrValue","doubleQuotesEscapeChars","singleQuoteEscapeChars","pseudoName","entity","currentEntity","escapeIdentifier","cn","escapeStr","len","charCode","extraCharCode","strReplacementsRev","f","hasOwn","toStr","gOPD","hasOwnConstructor","hasIsPrototypeOf","setProperty","getProperty","copy","copyIsArray","clone","deep","BananaSlug","slugger","maintainCase","originalSlug","occurrences","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","EMPTY_STRING","lineno","updatePosition","Position","errorsList","msg","filename","silent","re","m","comments","rules","ret","decl","decls","declarations","parsePart","lhs","rhs","incr","DOCUMENT_MODE","VALID_DOCTYPE_NAME","QUIRKS_MODE_PUBLIC_ID_PREFIXES","QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES","QUIRKS_MODE_PUBLIC_IDS","LIMITED_QUIRKS_PUBLIC_ID_PREFIXES","LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES","enquoteDoctypeId","hasPrefix","prefixes","isConforming","getDocumentMode","QUIRKS","LIMITED_QUIRKS","NO_QUIRKS","serializeContent","controlCharacterInInputStream","noncharacterInInputStream","surrogateInInputStream","nonVoidHtmlElementStartTagWithTrailingSolidus","endTagWithAttributes","endTagWithTrailingSolidus","unexpectedSolidusInTag","unexpectedNullCharacter","unexpectedQuestionMarkInsteadOfTagName","invalidFirstCharacterOfTagName","unexpectedEqualsSignBeforeAttributeName","missingEndTagName","unexpectedCharacterInAttributeName","unknownNamedCharacterReference","missingSemicolonAfterCharacterReference","unexpectedCharacterAfterDoctypeSystemIdentifier","unexpectedCharacterInUnquotedAttributeValue","eofBeforeTagName","eofInTag","missingAttributeValue","missingWhitespaceBetweenAttributes","missingWhitespaceAfterDoctypePublicKeyword","missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers","missingWhitespaceAfterDoctypeSystemKeyword","missingQuoteBeforeDoctypePublicIdentifier","missingQuoteBeforeDoctypeSystemIdentifier","missingDoctypePublicIdentifier","missingDoctypeSystemIdentifier","abruptDoctypePublicIdentifier","abruptDoctypeSystemIdentifier","cdataInHtmlContent","incorrectlyOpenedComment","eofInScriptHtmlCommentLikeText","eofInDoctype","nestedComment","abruptClosingOfEmptyComment","eofInComment","incorrectlyClosedComment","eofInCdata","absenceOfDigitsInNumericCharacterReference","nullCharacterReference","surrogateCharacterReference","characterReferenceOutsideUnicodeRange","controlCharacterReference","noncharacterCharacterReference","missingWhitespaceBeforeDoctypeName","missingDoctypeName","invalidCharacterSequenceAfterDoctypeName","duplicateAttribute","nonConformingDoctype","missingDoctype","misplacedDoctype","endTagWithoutMatchingOpenElement","closingOfElementWithOpenChildElements","disallowedContentInNoscriptInHead","openElementsLeftAfterEof","abandonedHeadElementChild","misplacedStartTagForHeadElement","nestedNoscriptInHead","eofInElementThatCanContainOnlyText","Tokenizer","HTML","$","TAG_NAMES","NS","NAMESPACES","ATTRS","MIME_TYPES","SVG_ATTRS_ADJUSTMENT_MAP","attributename","attributetype","basefrequency","baseprofile","calcmode","clippathunits","diffuseconstant","edgemode","filterunits","glyphref","gradienttransform","gradientunits","kernelmatrix","kernelunitlength","keypoints","keysplines","keytimes","lengthadjust","limitingconeangle","markerheight","markerunits","markerwidth","maskcontentunits","maskunits","numoctaves","pathlength","patterncontentunits","patterntransform","patternunits","pointsatx","pointsaty","pointsatz","preservealpha","preserveaspectratio","primitiveunits","refx","refy","repeatcount","repeatdur","requiredextensions","requiredfeatures","specularconstant","specularexponent","spreadmethod","startoffset","stddeviation","stitchtiles","surfacescale","systemlanguage","tablevalues","targetx","targety","textlength","viewbox","viewtarget","xchannelselector","ychannelselector","zoomandpan","XML_ATTRS_ADJUSTMENT_MAP","XLINK","XML","XMLNS","SVG_TAG_NAMES_ADJUSTMENT_MAP","altglyph","altglyphdef","altglyphitem","animatecolor","animatemotion","animatetransform","clippath","feblend","fecolormatrix","fecomponenttransfer","fecomposite","feconvolvematrix","fediffuselighting","fedisplacementmap","fedistantlight","feflood","fefunca","fefuncb","fefuncg","fefuncr","fegaussianblur","feimage","femerge","femergenode","femorphology","feoffset","fepointlight","fespecularlighting","fespotlight","fetile","feturbulence","foreignobject","lineargradient","radialgradient","textpath","EXITS_FOREIGN_CONTENT","B","BIG","BLOCKQUOTE","BODY","BR","CENTER","CODE","DD","DIV","DL","DT","EM","EMBED","H1","H2","H3","H4","H5","H6","HEAD","HR","I","IMG","LI","LISTING","MENU","META","NOBR","OL","P","PRE","RUBY","S","SMALL","SPAN","STRONG","STRIKE","SUB","SUP","TABLE","TT","U","UL","VAR","causesExit","startTagToken","tn","FONT","getTokenAttr","COLOR","SIZE","FACE","adjustTokenMathMLAttrs","adjustTokenSVGAttrs","adjustedAttrName","adjustTokenXMLAttrs","adjustedAttrEntry","adjustTokenSVGTagName","adjustedTagName","isIntegrationPoint","foreignNS","MATHML","ANNOTATION_XML","ENCODING","SVG","FOREIGN_OBJECT","DESC","TITLE","isHtmlIntegrationPoint","MI","MO","MN","MS","MTEXT","isMathMLTextIntegrationPoint","TYPE","ACTION","PROMPT","NAME","A","ADDRESS","APPLET","AREA","ARTICLE","ASIDE","BASE","BASEFONT","BGSOUND","BUTTON","CAPTION","COL","COLGROUP","DETAILS","DIALOG","DIR","FIELDSET","FIGCAPTION","FIGURE","FOOTER","FORM","FRAME","FRAMESET","HEADER","HGROUP","IMAGE","INPUT","IFRAME","KEYGEN","LABEL","LINK","MAIN","MALIGNMARK","MARQUEE","MATH","MGLYPH","NAV","NOFRAMES","NOEMBED","NOSCRIPT","OBJECT","OPTGROUP","OPTION","PARAM","PLAINTEXT","RB","RP","RT","RTC","SCRIPT","SECTION","SELECT","SOURCE","STYLE","SUMMARY","TBODY","TEMPLATE","TEXTAREA","TFOOT","TD","TH","THEAD","TR","TRACK","WBR","XMP","SPECIAL_ELEMENTS","UNDEFINED_CODE_POINTS","REPLACEMENT_CHARACTER","CODE_POINTS","EOF","NULL","TABULATION","CARRIAGE_RETURN","LINE_FEED","FORM_FEED","SPACE","EXCLAMATION_MARK","QUOTATION_MARK","NUMBER_SIGN","AMPERSAND","APOSTROPHE","HYPHEN_MINUS","SOLIDUS","DIGIT_0","DIGIT_9","SEMICOLON","LESS_THAN_SIGN","EQUALS_SIGN","GREATER_THAN_SIGN","QUESTION_MARK","LATIN_CAPITAL_A","LATIN_CAPITAL_F","LATIN_CAPITAL_X","LATIN_CAPITAL_Z","RIGHT_SQUARE_BRACKET","GRAVE_ACCENT","LATIN_SMALL_A","LATIN_SMALL_F","LATIN_SMALL_X","LATIN_SMALL_Z","CODE_POINT_SEQUENCES","DASH_DASH_STRING","DOCTYPE_STRING","CDATA_START_STRING","SCRIPT_STRING","PUBLIC_STRING","SYSTEM_STRING","isSurrogate","cp","isSurrogatePair","getSurrogatePairCodePoint","cp1","cp2","isControlCodePoint","isUndefinedCodePoint","ErrorReportingMixinBase","host","onParseError","_setErrorLocation","mxn","_err","_reportError","ErrorReportingTokenizerMixin","LocationInfoTokenizerMixin","Mixin","ErrorReportingParserMixin","locBeforeToken","orig","fragmentContext","install","_processInputToken","beforeToken","PositionTrackingPreprocessorMixin","ErrorReportingPreprocessorMixin","lastErrOffset","preprocessorMixin","LocationInfoOpenElementStackMixin","onItemPop","popAllUpToHtmlElement","stackTop","LocationInfoParserMixin","lastStartTagToken","lastFosterParentingLocation","setNodeSourceCodeLocation","closingToken","getNodeSourceCodeLocation","getTagName","endLoc","END_TAG_TOKEN","updateNodeSourceCodeLocation","tokenizerMixin","openElements","_setEndLocation","scriptHandler","_processTokenInForeignContent","hasInScope","_setDocumentType","documentChildren","getChildNodes","cnLength","isDocumentTypeNode","_attachElementToTree","_setStartLocation","_appendElement","_insertElement","_insertTemplate","tmplContent","getTemplateContent","_appendCommentNode","commentNode","_findFosterParentingLocation","_insertCharacters","hasFosterParent","_shouldFosterParentOnInsertion","currentTmplContent","textNodeIdx","beforeElement","textNode","methods","_createStartTagToken","_createEndTagToken","_createCommentToken","_createDoctypeToken","initialName","_createCharacterToken","ch","_createEOFToken","_getCurrentLocation","_createAttr","attrNameFirstCh","_leaveAttrName","toState","_attachCurrentAttrLocationInfo","_leaveAttrValue","_emitCurrentToken","EOF_TOKEN","_emitCurrentCharacterToken","MODE","modeName","advance","retreat","dropParsedChunk","prevPos","reduction","FormattingElementList","bookmark","newElement","candidates","neAttrsLength","getAttrList","neTagName","neNamespaceURI","getNamespaceURI","MARKER_ENTRY","elementAttrs","_getNoahArkConditionCandidates","cLength","neAttrs","neAttrsMap","neAttr","j","cAttr","NOAH_ARK_CAPACITY","_ensureNoahArkCondition","ELEMENT_ENTRY","bookmarkIdx","OpenElementStack","defaultTreeAdapter","mergeOptions","foreignContent","ERR","unicode","DEFAULT_OPTIONS","HIDDEN_INPUT_TYPE","INITIAL_MODE","BEFORE_HTML_MODE","BEFORE_HEAD_MODE","IN_HEAD_MODE","IN_HEAD_NO_SCRIPT_MODE","AFTER_HEAD_MODE","IN_BODY_MODE","TEXT_MODE","IN_TABLE_MODE","IN_TABLE_TEXT_MODE","IN_CAPTION_MODE","IN_COLUMN_GROUP_MODE","IN_TABLE_BODY_MODE","IN_ROW_MODE","IN_CELL_MODE","IN_SELECT_MODE","IN_SELECT_IN_TABLE_MODE","IN_TEMPLATE_MODE","AFTER_BODY_MODE","IN_FRAMESET_MODE","AFTER_FRAMESET_MODE","AFTER_AFTER_BODY_MODE","AFTER_AFTER_FRAMESET_MODE","INSERTION_MODE_RESET_MAP","TEMPLATE_INSERTION_MODE_SWITCH_MAP","TOKEN_HANDLERS","CHARACTER_TOKEN","tokenInInitialMode","NULL_CHARACTER_TOKEN","WHITESPACE_CHARACTER_TOKEN","ignoreToken","COMMENT_TOKEN","appendComment","DOCTYPE_TOKEN","setDocumentMode","insertionMode","START_TAG_TOKEN","tokenBeforeHtml","tokenBeforeHead","startTagInBody","headElement","tokenInHead","insertCharacters","startTagInHead","endTagInHead","tokenInHeadNoScript","tokenAfterHead","framesetOk","characterInBody","whitespaceCharacterInBody","endTagInBody","eofInBody","pendingScript","originalInsertionMode","characterInTable","startTagInTable","endTagInTable","pendingCharacterTokens","hasNonWhitespacePendingCharacterToken","tokenInTableText","hasInTableScope","generateImpliedEndTags","popUntilTagNamePopped","activeFormattingElements","clearToLastMarker","tokenInColumnGroup","ackSelfClosing","currentTagName","clearBackToTableBodyContext","_insertFakeElement","hasTableBodyContextInTableScope","clearBackToTableRowContext","insertMarker","_closeTableCell","startTagInSelect","endTagInSelect","newInsertionMode","_popTmplInsertionMode","eofInTemplate","tokenAfterBody","stopParsing","isRootHtmlElementCurrent","tokenAfterAfterBody","appendCommentToDocument","documentMock","rootElement","getFirstChild","createDocumentFragment","stopped","formElement","tmplInsertionModeStack","tmplInsertionModeStackTop","currentTmplInsertionMode","fosterParentingEnabled","_setupTokenizerCDATAMode","getNextToken","HIBERNATION_TOKEN","substr","writeCallback","script","_getAdjustedCurrentElement","allowCDATA","_isIntegrationPoint","nextTokenizerState","getParentNode","RCDATA","RAWTEXT","SCRIPT_DATA","setDocumentType","_fosterParentElement","tmpl","setTemplateContent","createCommentNode","_fosterParentText","insertText","donor","recipient","detachNode","isCharacterToken","characterInForeignContent","nullCharacterInForeignContent","currentNs","startTagInForeignContent","popUntilElementPopped","endTagInForeignContent","_shouldProcessTokenInForeignContent","listLength","unopenIdx","contains","popUntilTableCellPopped","generateImpliedEndTagsWithExclusion","_resetInsertionModeForSelect","selectIdx","_isElementCausesFosterParenting","openElement","insertBefore","insertTextBefore","aaObtainFormattingElementEntry","formattingElementEntry","getElementEntryInScopeWithTagName","removeEntry","genericEndTagInBody","aaObtainFurthestBlock","furthestBlock","_isSpecialElement","aaInnerLoop","formattingElement","lastElement","nextElement","getCommonAncestor","elementEntry","getElementEntry","counterOverflow","aaRecreateElementFromEntry","aaInsertLastNodeInCommonAncestor","commonAncestor","aaReplaceFormattingElement","insertElementAfterBookmark","insertAfter","callAdoptionAgency","_switchToTextParsing","tmplCount","generateImpliedEndTagsThoroughly","errCode","_reconstructActiveFormattingElements","addressStartTagInBody","hasInButtonScope","_closePElement","preStartTagInBody","bStartTagInBody","pushElement","appletStartTagInBody","areaStartTagInBody","paramStartTagInBody","noembedStartTagInBody","optgroupStartTagInBody","rbStartTagInBody","genericStartTagInBody","activeElementEntry","aStartTagInBody","numberedHeaderStartTagInBody","elementTn","closeTn","listItemStartTagInBody","hrStartTagInBody","rtStartTagInBody","xmpStartTagInBody","svgStartTagInBody","adoptAttributes","htmlStartTagInBody","bodyElement","tryPeekProperlyNestedBodyElement","bodyStartTagInBody","inTemplate","formStartTagInBody","nobrStartTagInBody","mathStartTagInBody","menuStartTagInBody","tableStartTagInBody","inputType","inputStartTagInBody","imageStartTagInBody","buttonStartTagInBody","iframeStartTagInBody","selectStartTagInBody","framesetStartTagInBody","textareaStartTagInBody","plaintextStartTagInBody","addressEndTagInBody","appletEndTagInBody","pEndTagInBody","hasInListItemScope","liEndTagInBody","ddEndTagInBody","hasNumberedHeaderInScope","popUntilNumberedHeaderPopped","numberedHeaderEndTagInBody","brEndTagInBody","bodyEndTagInBody","htmlEndTagInBody","formEndTagInBody","curTn","tokenInTable","clearBackToTableContext","tdStartTagInTable","colStartTagInTable","formStartTagInTable","tableStartTagInTable","tbodyStartTagInTable","inputStartTagInTable","captionStartTagInTable","colgroupStartTagInTable","savedFosterParentingState","_processTokenInBodyMode","hasInSelectScope","prevOpenElement","prevOpenElementTn","isImpliedEndTagRequired","isImpliedEndTagRequiredThoroughly","isScopingElement","_isInTemplate","_updateCurrentElement","oldElement","_indexOf","referenceElement","insertionIdx","poppedElement","elementIdx","exclusionTagName","Preprocessor","neTree","$$","C1_CONTROLS_REFERENCE_REPLACEMENTS","DATA_STATE","RCDATA_STATE","RAWTEXT_STATE","SCRIPT_DATA_STATE","PLAINTEXT_STATE","TAG_OPEN_STATE","END_TAG_OPEN_STATE","TAG_NAME_STATE","RCDATA_LESS_THAN_SIGN_STATE","RCDATA_END_TAG_OPEN_STATE","RCDATA_END_TAG_NAME_STATE","RAWTEXT_LESS_THAN_SIGN_STATE","RAWTEXT_END_TAG_OPEN_STATE","RAWTEXT_END_TAG_NAME_STATE","SCRIPT_DATA_LESS_THAN_SIGN_STATE","SCRIPT_DATA_END_TAG_OPEN_STATE","SCRIPT_DATA_END_TAG_NAME_STATE","SCRIPT_DATA_ESCAPE_START_STATE","SCRIPT_DATA_ESCAPE_START_DASH_STATE","SCRIPT_DATA_ESCAPED_STATE","SCRIPT_DATA_ESCAPED_DASH_STATE","SCRIPT_DATA_ESCAPED_DASH_DASH_STATE","SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE","SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE","SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE","SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE","SCRIPT_DATA_DOUBLE_ESCAPED_STATE","SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE","SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE","SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE","SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE","BEFORE_ATTRIBUTE_NAME_STATE","ATTRIBUTE_NAME_STATE","AFTER_ATTRIBUTE_NAME_STATE","BEFORE_ATTRIBUTE_VALUE_STATE","ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE","ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE","ATTRIBUTE_VALUE_UNQUOTED_STATE","AFTER_ATTRIBUTE_VALUE_QUOTED_STATE","SELF_CLOSING_START_TAG_STATE","BOGUS_COMMENT_STATE","MARKUP_DECLARATION_OPEN_STATE","COMMENT_START_STATE","COMMENT_START_DASH_STATE","COMMENT_STATE","COMMENT_LESS_THAN_SIGN_STATE","COMMENT_LESS_THAN_SIGN_BANG_STATE","COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE","COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE","COMMENT_END_DASH_STATE","COMMENT_END_STATE","COMMENT_END_BANG_STATE","DOCTYPE_STATE","BEFORE_DOCTYPE_NAME_STATE","DOCTYPE_NAME_STATE","AFTER_DOCTYPE_NAME_STATE","AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE","BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE","DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE","DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE","AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE","BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE","AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE","BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE","DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE","DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE","AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE","BOGUS_DOCTYPE_STATE","CDATA_SECTION_STATE","CDATA_SECTION_BRACKET_STATE","CDATA_SECTION_END_STATE","CHARACTER_REFERENCE_STATE","NAMED_CHARACTER_REFERENCE_STATE","AMBIGUOUS_AMPERSAND_STATE","NUMERIC_CHARACTER_REFERENCE_STATE","HEXADEMICAL_CHARACTER_REFERENCE_START_STATE","DECIMAL_CHARACTER_REFERENCE_START_STATE","HEXADEMICAL_CHARACTER_REFERENCE_STATE","DECIMAL_CHARACTER_REFERENCE_STATE","NUMERIC_CHARACTER_REFERENCE_END_STATE","isWhitespace","isAsciiDigit","isAsciiUpper","isAsciiLower","isAsciiLetter","isAsciiAlphaNumeric","isAsciiUpperHexDigit","isAsciiLowerHexDigit","toAsciiLowerCodePoint","toChar","toAsciiLowerChar","findNamedEntityTreeBranch","nodeIx","branchCount","lo","hi","mid","midCp","_unconsume","_ensureHibernation","isLastChunk","insertHtmlAtCurrentPos","startCp","caseSensitive","consumedCount","isMatch","patternLength","patternPos","patternCp","ct","_appendCharToCurrentCharacterToken","codePoints","_emitCodePoint","excess","inNode","HAS_DATA_FLAG","withSemicolon","_isCharacterReferenceInAttribute","nextCp","_emitSeveralCodePoints","_emitEOFToken","_emitChars","_reconsumeInState","_isTempBufferEqualToScriptString","_consumeSequenceIfMatch","_flushCodePointsConsumedAsCharacterReference","matchResult","_matchNamedCharacterReference","_isCharacterReferenceAttributeQuirk","_errOnNextCodePoint","isAsciiHexDigit","DATA","attrName","Uint16Array","bufferWaterline","_addGap","_processSurrogate","_checkForProblematicCharacters","createTextNode","newNode","referenceNode","templateElement","contentElement","doctypeNode","prevNode","recipientAttrsMap","getTextNodeContent","getCommentNodeContent","getDocumentTypeNodeName","getDocumentTypeNodePublicId","getDocumentTypeNodeSystemId","isTextNode","isCommentNode","isElementNode","endLocation","defaults","merged","optObj","originalMethods","overriddenMethods","_getOverriddenMethods","Ctor","mixin","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","propName","componentName","propFullName","secret","getShim","isRequired","ReactPropTypes","array","bigint","bool","func","symbol","arrayOf","elementType","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","for","g","q","$$typeof","ContextConsumer","ContextProvider","Element","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","SuspenseList","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isSuspenseList","isValidElementType","getModuleId","w","C","x","sortIndex","performance","unstable_now","Date","y","z","D","E","clearTimeout","F","setImmediate","G","startTime","expirationTime","H","J","K","L","M","priorityLevel","navigator","scheduling","isInputPending","N","O","Q","R","MessageChannel","T","port2","port1","onmessage","postMessage","unstable_IdlePriority","unstable_ImmediatePriority","unstable_LowPriority","unstable_NormalPriority","unstable_Profiling","unstable_UserBlockingPriority","unstable_cancelCallback","unstable_continueExecution","unstable_forceFrameRate","floor","unstable_getCurrentPriorityLevel","unstable_getFirstCallbackNode","unstable_next","unstable_pauseExecution","unstable_requestPaint","unstable_runWithPriority","unstable_scheduleCallback","delay","unstable_shouldYield","unstable_wrapCallback","hasIterator","arr2","__esModule","ReferenceError","Constructor","_defineProperties","descriptor","protoProps","staticProps","allowArrayLike","it","normalCompletion","didErr","_e2","possibleConstructorReturn","Derived","hasNativeReflectConstruct","Super","NewTarget","superPropBase","_get","receiver","desc","_getPrototypeOf","__proto__","subClass","superClass","sham","Proxy","valueOf","_typeof","assertThisInitialized","_setPrototypeOf","arrayWithHoles","iterableToArrayLimit","nonIterableRest","arrayLikeToArray","minLen","isNativeFunction","_arrayLikeToArray","_assertThisInitialized","_classCallCheck","_createClass","_possibleConstructorReturn","_createSuper","_inherits","_isNativeReflectConstruct","_iterableToArray","iter","_toConsumableArray","_unsupportedIterableToArray","tokens","padRight","padLeft","char","subvalue","defaultTagName","buttonTypes","createAdjustMap","isProperties","addChild","spaceSeparated","commaOrSpaceSeparated","parsePrimitive","finalResult","overloadedBoolean","characterEntitiesLegacy","characterReferenceInvalid","isDecimal","isHexadecimal","isAlphanumerical","isAlphabetical","parseEntities","additional","queue","following","begin","characterReferenceCharacters","characters","terminated","namedReference","diff","nonTerminated","warning","referenceCode","prohibited","disallowed","flush","referenceContext","warningContext","textContext","Schema","normal","merge","DefinedInfo","xmlBase","xmlSpace","caseSensitiveTransform","caseInsensitiveTransform","xmlnsxlink","aria","ariaActiveDescendant","ariaAtomic","booleanish","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaInvalid","ariaKeyShortcuts","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","role","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","action","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","as","async","autoCapitalize","autoComplete","autoFocus","autoPlay","capture","charSet","cite","cols","colSpan","controls","controlsList","coords","crossOrigin","dateTime","decoding","default","defer","dirName","download","draggable","encType","enterKeyHint","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","hidden","high","hrefLang","htmlFor","httpEquiv","imageSizes","imageSrcSet","inputMode","integrity","isMap","itemProp","itemRef","itemScope","itemType","loading","loop","low","manifest","maxLength","min","minLength","multiple","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforePrint","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onError","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","optimum","ping","playsInline","poster","preload","readOnly","referrerPolicy","reversed","rowSpan","sandbox","scoped","seamless","slot","span","srcDoc","srcLang","srcSet","translate","typeMustMatch","useMap","aLink","archive","axis","background","border","borderColor","bottomMargin","cellPadding","cellSpacing","charOff","clear","codeBase","codeType","compact","declare","face","frame","frameBorder","hSpace","leftMargin","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","topMargin","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","security","unselectable","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dominantBaseline","enableBackground","fillOpacity","floodColor","floodOpacity","fontFamily","fontSizeAdjust","fontStretch","fontStyle","fontVariant","fontWeight","glyphName","glyphOrientationHorizontal","glyphOrientationVertical","horizAdvX","horizOriginX","horizOriginY","imageRendering","letterSpacing","lightingColor","markerEnd","markerMid","markerStart","navDown","navDownLeft","navDownRight","navLeft","navNext","navPrev","navRight","navUp","navUpLeft","navUpRight","onActivate","onBegin","onEnd","onFocusIn","onFocusOut","onMouseWheel","onRepeat","onShow","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","pointerEvents","renderingIntent","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeOpacity","textAnchor","textDecoration","textRendering","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","defaultAction","descent","diffuseConstant","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","filterRes","filterUnits","focusHighlight","fr","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","in2","intercept","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","mask","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","numOctaves","observer","orient","orientation","overflow","overlay","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","stdDeviation","stemh","stemv","stitchTiles","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","u1","u2","viewTarget","widths","x1","x2","xChannelSelector","y1","y2","yChannelSelector","zoomAndPan","htmlBase","svgBase","valid","dash","cap","Type","Info","rest","camelcase","dashes","kebab","mark","powers","increment","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","deferred","chunkIds","priority","notFulfilled","Infinity","fulfilled","every","getter","installedChunks","chunkId","webpackJsonpCallback","parentChunkLoadingFunction","moreModules","runtime","chunkLoadingGlobal","__webpack_exports__"],"sourceRoot":""}