{"version":3,"file":"static/chunks/594-d896785e4084e48a.js","mappings":"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ACA,YACA,OACA,YACA,QACA,SACA,WACA,UACA,YACA,WACA,OACA,QACA,OACA,OACA,OACA,WACA,MACA,YACA,QACA,aACA,SACA,MACA,YACA,WACA,QACA,OACA,aACA,OACA,UACA,UACA,OACA,cACA,SACA,UACA,aACA,iBACA,WACA,MACA,WACA,OACA,UACA,UACA,QACA,SACA,YACA,WACA,WACA,QACA,OACA,QACA,OACA,WACA,OACA,aACA,MACA,SACA,SACA,QACA,OACA,SACA,YACA,gBACA,SACA,QACA,QACA,OACA,EACAC,EAAA,IAAAD,IAAA,CACA,SACA,QACA,UACA,SACA,UACA,UACA,WACA,mBACA,qBACA,sBACA,YACA,aACA,UACA,UACA,SACA,WACA,UACA,WACA,UACA,gBACA,gBACA,SACA,YACA,cACA,aACA,cACA,aACA,cACA,SACA,cACA,eACA,eACA,cACA,aACA,cACA,YACA,gBACA,iBACA,iBACA,cACA,WACA,gBACA,aACA,cACA,eACA,mBACA,iBACA,uBACA,kBACA,EC9KAE,EAAA,cACAC,EAAA,cACAC,EAAA,gBACA,SAAAhE,EAAArD,CAAA,CAAAsH,EAAA,EAAwC,EACxC,IACA/D,UAAAA,EAAA,GACAY,QAAAA,EAAA,GACAoD,UAAAA,CAAA,CACAC,cAAAA,CAAA,CACAC,eAAAA,CAAA,CACAC,cAAAA,CAAA,CACAC,eAAAA,CAAA,CACA,CAAIL,EACJM,EAAA,GACA,IAAAzD,EACA,OAAAnE,EAEA,QAAA1I,KAAA0I,IACAwH,CAAAA,MAAAA,EAAA,OAAAA,EAAAK,GAAA,CAAAvQ,EAAA,GAGA,CAAAmQ,MAAAA,EAAA,OAAAA,EAAAI,GAAA,CAAAvQ,EAAA,GAAA+P,EAAAZ,IAAA,CAAAnP,IAGA+P,EAAAZ,IAAA,CAAAnP,IAAA,CAA8B4P,EAAaW,GAAA,CAAAvQ,IAG3CoQ,GAAAP,EAAAV,IAAA,CAAAnP,IAGAqQ,GAAAN,EAAAZ,IAAA,CAAAnP,KAGA3F,CAAAA,OAAAC,SAAA,CAAAC,cAAA,CAAAS,IAAA,CAAA0N,EAAA1I,IAA8D0P,CAAAA,EAAYa,GAAA,CAAAvQ,IAAAiM,GAAA6D,EAAAX,IAAA,CAAAnP,IAAAiQ,CAAAA,MAAAA,EAAA,OAAAA,EAAAM,GAAA,CAAAvQ,EAAA,GAAA6P,EAAAV,IAAA,CAAAnP,EAAA,GAAA+P,EAAAZ,IAAA,CAAAnP,EAAA,GAC1EsQ,CAAAA,CAAA,CAAAtQ,EAAA,CAAA0I,CAAA,CAAA1I,EAAA,EAGA,OAAAsQ,CACA,oFCqDA,SAASlE,EAAU/C,CAAG,EACpB,IAAM8C,EAASqE,CAAAA,EAAAA,EAAAA,MAAAA,EAAO,MAEtB,MADAC,CAAAA,EAAAA,EAAAA,mBAAAA,EAAoBpH,EAAK,IAAM8C,EAAOuE,OAAO,EACtCvE,CACT,CA5FY,oBAAOpG,QAA0BA,OAAO4K,QAAQ,EAAI5K,OAAO4K,QAAQ,CAACC,aAAa,oCCiB7F,SAAApE,EAAA,GAAAhK,CAAA,EAEA,IADA,IAAAqO,EAAAC,EAAArU,EAAA,EAAAY,EAAA,GACAZ,EAAA+F,EAAA9F,MAAA,EACAmU,CAAAA,EAAArO,CAAA,CAAA/F,IAAA,GACAqU,CAAAA,EAAAC,SA7BAA,EAAAC,CAAA,EACA,IAAAC,EAAAC,EAAA7T,EAAA,GACA,oBAAA2T,GAAA,iBAAAA,EACA3T,GAAA2T,OACI,oBAAAA,GACJ,GAAAjW,MAAAF,OAAA,CAAAmW,GACA,IAAAC,EAAA,EAAkBA,EAAAD,EAAAtU,MAAA,CAAgBuU,IAClCD,CAAA,CAAAC,EAAA,EACAC,CAAAA,EAAAH,EAAAC,CAAA,CAAAC,EAAA,KACA5T,GAAAA,CAAAA,GAAA,KACAA,GAAA6T,QAKA,IAAAD,KAAAD,EACAA,CAAA,CAAAC,EAAA,GACA5T,GAAAA,CAAAA,GAAA,KACAA,GAAA4T,GAKA,OAAA5T,CACA,EAKAwT,EAAA,IACAxT,GAAAA,CAAAA,GAAA,KACAA,GAAAyT,GAIA,OAAAzT,CACA,qGCTA,IAAA2P,EAAA,GAAAmE,EAAA,iDCWA,SAAA7E,EAAApR,CAAA,EACA,IAAAA,GAAA,iBAAAA,EACA,SAEA,IACA,OAAAkW,KAAAC,SAAA,CAAAnW,EACA,CAAI,MAAAqG,EAAA,CACJ,QACA,CACA,0IC3CI+P,EAAQ,GAAAC,QAAAC,EAAA,EAAE,CACdnF,MAAA,CACAoF,QAAA,0BACAC,cAAA,2CACAC,IAAA,wEACAC,WAAA,CACA,WACA,MACA,UACA,SACA,SACA,eACA,SACA,UACA,YACA,eACA,aACA,gBACA,EAEAC,SAAA,CACAC,OAAA,CACAC,KAAA,GACAC,GAAA,GACAC,GAAA,GACAC,GAAA,GACAC,KAAA,EACA,EACAC,OAAA,CACAL,KAAA,CACAN,QAAA,cACAE,IAAA,aACA,EACAK,GAAA,CACAP,QAAA,eACAE,IAAA,cACA,EACAM,GAAA,CACAR,QAAA,gBACAE,IAAA,eACA,EACAO,GAAA,CACAT,QAAA,eACAE,IAAA,cACA,CACA,EACAU,SAAA,CACAC,KAAA,CACAX,IAAA,+CAEA,EACAY,aAAA,CACAD,KAAA,CACAb,QAAA,CACA,QACA,WACA,kBACA,+BACA,qBACA,kBACA,iBACA,2BACA,uCACA,kBACA,4BACA,0BACA,0BACA,sBACA,iCACA,wBACA,oBACA,iBACA,gBACA,cACA,oBACA,yBACA,CACAE,IAAA,WACA,CACA,EACAlH,iBAAA,CACA6H,KAAA,CACAX,IAAA,iBACA,EACAa,MAAA,CACAb,IAAA,0EACA,CACA,CACA,EACAc,gBAAA,CACAX,OAAA,KACAM,OAAA,OACAC,SAAA,GACAK,UAAA,GACAH,aAAA,GACA9H,iBAAA,EACA,EACAkI,cAAA,CACA,CACAtG,MAAA,+CACAyF,OAAA,OACAnF,MAAA,cACA,EACA,CACAN,MAAA,+CACAyF,OAAA,OACAnF,MAAA,cACA,EACA,CACAN,MAAA,+CACAyF,OAAA,KACAnF,MAAA,eACA,EACA,CACAN,MAAA,+CACAyF,OAAA,KACAnF,MAAA,YACA,EACA,CACAN,MAAA,+CACAyF,OAAA,KACAnF,MAAA,eACA,EACA,2CC9HAiG,EAAAlO,CAAAmO,MAAAA,WAAA,OAAAA,WAAAlC,QAAA,EAAuFvM,EAAA0O,eAAe,CAAG1O,EAAA2O,SAAS,WGO9GC,EAAQ5J,CAAAA,EAAAA,EAAAA,EAAAA,EAAW,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AzN,KAAA,YACA,EACA0N,GAAA,CACA1N,KAAA,aACA,CACA,EACAwG,UAAA,CACA+G,KAAA,CACAvN,KAAA,cACA,EACA2R,MAAA,CACA3R,KAAA,iBACA,EACA4R,OAAA,CACA5R,KAAA,WACA,EACA6R,OAAA,CACA7R,KAAA,kBACA,EACA8R,MAAA,CACA9R,KAAA,iBACA,CACA,EACA8I,UAAA,CACAgF,KAAA,CACA9N,KAAA,gBACA,EACAgO,MAAA,CACAhO,KAAA,+CAEA,EACAqF,WAAA,CACAyI,KAAA,CACA9N,KAAA,uCACAiF,UAAA,kBACA,CACA,EACAgB,iBAAA,CACA+H,MAAA,CACAhO,KAAA,oBACA,EACA8N,KAAA,CACA9N,KAAA,iBACA,CACA,CACA,EACAiO,gBAAA,CACA/F,KAAA,KACA3B,MAAA,aACAC,UAAA,QACAnB,WAAA,GACAY,iBAAA,EACA,EACA8L,iBAAA,CACA,CACAjJ,UAAA,GACAvC,MAAA,aACA4B,MAAA,CACAnI,KAAA,iBACA,CACA,EACA,CACA8I,UAAA,GACAvC,MAAA,UACA4B,MAAA,CACAnI,KAAA,cACA,CACA,EACA,CACA8I,UAAA,GACAvC,MAAA,YACA4B,MAAA,CACAnI,KAAA,gBACA,CACA,EACA,CACA8I,UAAA,GACAvC,MAAA,UACA4B,MAAA,CACAnI,KAAA,cACA,CACA,EACA,CACA8I,UAAA,GACAvC,MAAA,UACA4B,MAAA,CACAnI,KAAA,cACA,CACA,EACA,CACA8I,UAAA,GACAvC,MAAA,SACA4B,MAAA,CACAnI,KAAA,aACA,CACA,EACA,CACA8I,UAAA,GACAtC,UAAA,OACA2B,MAAA,CACAnI,KAAA,cACA,CACA,EACA,CACAwG,UAAA,oCACA2B,MAAA,oBACA,EACA,GAEA/B,EAAkB,GAAA8K,EAAAlE,EAAA,EAAE,CACpBnF,MAAA,CACAI,KAAA,GACAK,KAAA,2BACAC,SAAA,cACAtD,UAAA,uBACA,EACAoI,SAAA,CACAnF,KAAA,CACAsF,GAAA,GACAC,GAAA,GACAC,GAAA,EACA,EACAJ,OAAA,CACAC,KAAA,CACAjF,KAAA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AtpB,QAAA,CAGA4pB,WAAAA,GACA3oF,UAAAA,EAAA08D,QAAA,CAEAitB,cAAAA,GACA3pF,aAAAA,EAAA08D,QAAA,CAEAktB,mBAAAA,GACA5pF,kBAAAA,EAAA08D,QAAA,CAEAmtB,cAAAA,GACAztF,OAAAC,SAAA,CAAAC,cAAA,CAAAS,IAAA,CAAAiD,EAAA,WAGA8pF,0BAAA9pF,CAAA,CAAA88D,CAAA,EACA98D,EAAAu9D,kBAAA,CAAAT,CACA,EACAitB,0BAAAA,GACA/pF,EAAAu9D,kBAAA,CAEAysB,6BAAAhqF,CAAA,CAAAiqF,CAAA,EACAjqF,EAAAu9D,kBAAA,EAAoC,GAAAv9D,EAAAu9D,kBAAA,IAAA0sB,CAAA,CACpC,CACA,EC1KAC,GAAA,OAGAC,GAAA,CACA,6CACA,6CACA,uDACA,kCACA,kCACA,yCACA,yCACA,iCACA,0BACA,2BACA,0BACA,gCACA,0BACA,wBACA,8BACA,8BACA,8BACA,8BACA,qCACA,qCACA,qCACA,qCACA,6BACA,sBACA,2CACA,wDACA,iDACA,mDACA,wDACA,iDACA,mDACA,sCACA,6CACA,6CACA,sDACA,8DACA,8CACA,iFACA,wEACA,uCACA,gDACA,uDACA,kCACA,+BACA,+BACA,yBACA,gCACA,kCACA,sCACA,2CACA,yCACA,wBACA,4BACA,sCACA,kCACA,CACAC,GAAA,IACAD,GACA,mCACA,uCACA,CACAE,GAAA,IAAA34E,IAAA,CACA,uCACA,qCACA,OACA,EACA44E,GAAA,4EACAC,GAAA,IACAD,GACA,mCACA,uCACA,CAEA,SAAAE,GAAA1rB,CAAA,CAAA2rB,CAAA,EACA,OAAAA,EAAAC,IAAA,IAAA5rB,EAAAn3D,UAAA,CAAAqT,GACA,CC/EA,IAAA2vE,GAAA,CACAC,UAAA,YACAC,gBAAA,uBACA,EAIAC,GAAA,IAAAtiF,IAAA,CACA,gBACA,gBACA,gBACA,cACA,WACA,gBACA,kBACA,WACA,cACA,WACA,oBACA,gBACA,eACA,mBACA,YACA,aACA,WACA,eACA,oBACA,eACA,cACA,cACA,mBACA,YACA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","sources":["webpack://_N_E/./node_modules/extend/index.js","webpack://_N_E/./node_modules/inline-style-parser/index.js","webpack://_N_E/./node_modules/style-to-object/cjs/index.js","webpack://_N_E/./node_modules/process/browser.js","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/node_modules/@nextui-org/react-rsc-utils/dist/chunk-FGM523TA.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/ar-AE.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/bg-BG.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/cs-CZ.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/da-DK.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/de-DE.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/el-GR.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/en-US.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/es-ES.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/et-EE.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/fi-FI.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/fr-FR.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/he-IL.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/hr-HR.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/hu-HU.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/it-IT.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/ja-JP.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/ko-KR.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/lt-LT.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/lv-LV.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/nb-NO.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/nl-NL.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/pl-PL.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/pt-BR.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/pt-PT.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/ro-RO.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/ru-RU.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/sk-SK.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/sl-SI.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/sr-SP.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/sv-SE.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/tr-TR.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/uk-UA.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/zh-CN.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/zh-TW.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/intlStrings.mjs","webpack://_N_E/./node_modules/@internationalized/string/dist/LocalizedStringDictionary.mjs","webpack://_N_E/./node_modules/@internationalized/string/dist/LocalizedStringFormatter.mjs","webpack://_N_E/./node_modules/@react-aria/i18n/dist/useLocalizedStringFormatter.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/useBreadcrumbs.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/dist/chunk-AAD6P2XK.mjs","webpack://_N_E/./node_modules/@nextui-org/shared-icons/dist/chunk-534KRDYK.mjs","webpack://_N_E/./node_modules/@nextui-org/shared-icons/dist/chunk-BU32PI3O.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/node_modules/@nextui-org/shared-utils/dist/chunk-RFUEKIFS.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/dist/chunk-6WHGJGLN.mjs","webpack://_N_E/./node_modules/@react-aria/breadcrumbs/dist/useBreadcrumbItem.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/dist/chunk-HM6BKCEH.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/dist/chunk-TPV4OC2M.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/node_modules/@nextui-org/react-rsc-utils/dist/chunk-RFWDHYLZ.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/node_modules/@nextui-org/react-rsc-utils/dist/chunk-RJKRL3AU.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/node_modules/@nextui-org/react-utils/dist/chunk-RQNQ5XFG.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/node_modules/@nextui-org/shared-utils/dist/chunk-6BQDBGF4.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/node_modules/@nextui-org/shared-utils/dist/chunk-MCFSCOSB.mjs","webpack://_N_E/./node_modules/@nextui-org/breadcrumbs/node_modules/@nextui-org/shared-utils/dist/chunk-SOU6N57Y.mjs","webpack://_N_E/./node_modules/@nextui-org/theme/dist/chunk-LDBYFTHC.mjs","webpack://_N_E/./node_modules/@nextui-org/use-safe-layout-effect/dist/index.mjs","webpack://_N_E/./node_modules/@nextui-org/use-image/dist/index.mjs","webpack://_N_E/./node_modules/@nextui-org/image/dist/chunk-AJLGONGP.mjs","webpack://_N_E/./node_modules/@nextui-org/image/dist/chunk-NK4BRF7C.mjs","webpack://_N_E/./node_modules/@nextui-org/image/dist/index.mjs","webpack://_N_E/./node_modules/@nextui-org/link/dist/index.mjs","webpack://_N_E/./node_modules/@nextui-org/shared-utils/dist/chunk-6BQDBGF4.mjs","webpack://_N_E/./node_modules/@nextui-org/theme/dist/chunk-6XJJCV76.mjs","webpack://_N_E/./node_modules/@react-aria/i18n/dist/utils.mjs","webpack://_N_E/./node_modules/@react-aria/i18n/dist/useDefaultLocale.mjs","webpack://_N_E/./node_modules/@react-aria/i18n/dist/context.mjs","webpack://_N_E/./node_modules/@react-aria/ssr/dist/SSRProvider.mjs","webpack://_N_E/./node_modules/@ungap/structured-clone/esm/types.js","webpack://_N_E/./node_modules/@ungap/structured-clone/esm/deserialize.js","webpack://_N_E/./node_modules/@ungap/structured-clone/esm/serialize.js","webpack://_N_E/./node_modules/@ungap/structured-clone/esm/index.js","webpack://_N_E/./node_modules/comma-separated-tokens/index.js","webpack://_N_E/./node_modules/devlop/lib/default.js","webpack://_N_E/./node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js","webpack://_N_E/./node_modules/mdast-util-find-and-replace/lib/index.js","webpack://_N_E/./node_modules/mdast-util-to-string/lib/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://_N_E/./node_modules/micromark-factory-space/index.js","webpack://_N_E/./node_modules/micromark-util-character/index.js","webpack://_N_E/./node_modules/micromark-util-chunked/index.js","webpack://_N_E/./node_modules/micromark-util-classify-character/index.js","webpack://_N_E/./node_modules/micromark-util-combine-extensions/index.js","webpack://_N_E/./node_modules/micromark-util-normalize-identifier/index.js","webpack://_N_E/./node_modules/micromark-util-resolve-all/index.js","webpack://_N_E/./node_modules/property-information/lib/util/schema.js","webpack://_N_E/./node_modules/property-information/lib/util/merge.js","webpack://_N_E/./node_modules/property-information/lib/util/create.js","webpack://_N_E/./node_modules/property-information/lib/xlink.js","webpack://_N_E/./node_modules/property-information/lib/xml.js","webpack://_N_E/./node_modules/property-information/lib/util/case-sensitive-transform.js","webpack://_N_E/./node_modules/property-information/lib/util/case-insensitive-transform.js","webpack://_N_E/./node_modules/property-information/lib/xmlns.js","webpack://_N_E/./node_modules/property-information/lib/aria.js","webpack://_N_E/./node_modules/property-information/lib/html.js","webpack://_N_E/./node_modules/property-information/lib/svg.js","webpack://_N_E/./node_modules/property-information/index.js","webpack://_N_E/./node_modules/property-information/lib/find.js","webpack://_N_E/./node_modules/property-information/lib/normalize.js","webpack://_N_E/./node_modules/property-information/lib/util/defined-info.js","webpack://_N_E/./node_modules/property-information/lib/util/info.js","webpack://_N_E/./node_modules/property-information/lib/util/types.js","webpack://_N_E/./node_modules/estree-util-is-identifier-name/lib/index.js","webpack://_N_E/./node_modules/hast-util-whitespace/lib/index.js","webpack://_N_E/./node_modules/property-information/lib/hast-to-react.js","webpack://_N_E/./node_modules/style-to-object/esm/index.mjs","webpack://_N_E/./node_modules/unist-util-stringify-position/lib/index.js","webpack://_N_E/./node_modules/vfile-message/lib/index.js","webpack://_N_E/./node_modules/hast-util-to-jsx-runtime/lib/index.js","webpack://_N_E/./node_modules/html-url-attributes/lib/index.js","webpack://_N_E/./node_modules/micromark-util-subtokenize/lib/splice-buffer.js","webpack://_N_E/./node_modules/micromark-util-subtokenize/index.js","webpack://_N_E/./node_modules/micromark/lib/postprocess.js","webpack://_N_E/./node_modules/micromark/lib/initialize/content.js","webpack://_N_E/./node_modules/micromark/lib/initialize/document.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/content.js","webpack://_N_E/./node_modules/micromark/lib/initialize/flow.js","webpack://_N_E/./node_modules/micromark/lib/initialize/text.js","webpack://_N_E/./node_modules/micromark/lib/create-tokenizer.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/list.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://_N_E/./node_modules/micromark-factory-destination/index.js","webpack://_N_E/./node_modules/micromark-factory-label/index.js","webpack://_N_E/./node_modules/micromark-factory-title/index.js","webpack://_N_E/./node_modules/micromark-factory-whitespace/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/definition.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://_N_E/./node_modules/micromark-util-html-tag-name/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://_N_E/./node_modules/decode-named-character-reference/index.dom.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-end.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/attention.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/autolink.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/html-text.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-text.js","webpack://_N_E/./node_modules/micromark/lib/constructs.js","webpack://_N_E/./node_modules/micromark/lib/parse.js","webpack://_N_E/./node_modules/micromark/lib/preprocess.js","webpack://_N_E/./node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://_N_E/./node_modules/micromark-util-decode-string/index.js","webpack://_N_E/./node_modules/mdast-util-from-markdown/lib/index.js","webpack://_N_E/./node_modules/remark-parse/lib/index.js","webpack://_N_E/./node_modules/micromark-util-sanitize-uri/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/footer.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/revert.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/table-row.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","webpack://_N_E/./node_modules/trim-lines/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/state.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/index.js","webpack://_N_E/./node_modules/remark-rehype/lib/index.js","webpack://_N_E/./node_modules/bail/index.js","webpack://_N_E/./node_modules/is-plain-obj/index.js","webpack://_N_E/./node_modules/trough/lib/index.js","webpack://_N_E/./node_modules/vfile/lib/minpath.browser.js","webpack://_N_E/./node_modules/vfile/lib/minproc.browser.js","webpack://_N_E/./node_modules/vfile/lib/minurl.shared.js","webpack://_N_E/./node_modules/vfile/lib/minurl.browser.js","webpack://_N_E/./node_modules/vfile/lib/index.js","webpack://_N_E/./node_modules/unified/lib/callable-instance.js","webpack://_N_E/./node_modules/unified/lib/index.js","webpack://_N_E/./node_modules/react-markdown/lib/index.js","webpack://_N_E/./node_modules/hast-util-parse-selector/lib/index.js","webpack://_N_E/./node_modules/hastscript/lib/create-h.js","webpack://_N_E/./node_modules/hastscript/lib/svg-case-sensitive-tag-names.js","webpack://_N_E/./node_modules/hastscript/lib/index.js","webpack://_N_E/./node_modules/vfile-location/lib/index.js","webpack://_N_E/./node_modules/web-namespaces/index.js","webpack://_N_E/./node_modules/hast-util-from-parse5/lib/index.js","webpack://_N_E/./node_modules/zwitch/index.js","webpack://_N_E/./node_modules/hast-util-to-parse5/lib/index.js","webpack://_N_E/./node_modules/html-void-elements/index.js","webpack://_N_E/./node_modules/parse5/dist/common/unicode.js","webpack://_N_E/./node_modules/parse5/dist/common/error-codes.js","webpack://_N_E/./node_modules/parse5/dist/tokenizer/preprocessor.js","webpack://_N_E/./node_modules/parse5/dist/common/token.js","webpack://_N_E/./node_modules/entities/lib/esm/generated/decode-data-html.js","webpack://_N_E/./node_modules/entities/lib/esm/generated/decode-data-xml.js","webpack://_N_E/./node_modules/entities/lib/esm/decode_codepoint.js","webpack://_N_E/./node_modules/entities/lib/esm/decode.js","webpack://_N_E/./node_modules/parse5/dist/common/html.js","webpack://_N_E/./node_modules/parse5/dist/tokenizer/index.js","webpack://_N_E/./node_modules/parse5/dist/parser/open-element-stack.js","webpack://_N_E/./node_modules/parse5/dist/parser/formatting-element-list.js","webpack://_N_E/./node_modules/parse5/dist/tree-adapters/default.js","webpack://_N_E/./node_modules/parse5/dist/common/doctype.js","webpack://_N_E/./node_modules/parse5/dist/common/foreign-content.js","webpack://_N_E/./node_modules/parse5/dist/parser/index.js","webpack://_N_E/./node_modules/entities/lib/esm/escape.js","webpack://_N_E/./node_modules/parse5/dist/serializer/index.js","webpack://_N_E/./node_modules/parse5/dist/index.js","webpack://_N_E/./node_modules/hast-util-raw/lib/index.js","webpack://_N_E/./node_modules/rehype-raw/lib/index.js","webpack://_N_E/./node_modules/mdast-util-newline-to-break/lib/index.js","webpack://_N_E/./node_modules/remark-breaks/lib/index.js","webpack://_N_E/./node_modules/ccount/index.js","webpack://_N_E/./node_modules/mdast-util-gfm-autolink-literal/lib/index.js","webpack://_N_E/./node_modules/mdast-util-gfm-footnote/lib/index.js","webpack://_N_E/./node_modules/mdast-util-gfm-strikethrough/lib/index.js","webpack://_N_E/./node_modules/markdown-table/index.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/blockquote.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/break.js","webpack://_N_E/./node_modules/longest-streak/index.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-fence.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/code.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-quote.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/definition.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/emphasis.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/heading.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/html.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/image.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/image-reference.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/link.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/link-reference.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-rule.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/list.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/list-item.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/paragraph.js","webpack://_N_E/./node_modules/mdast-util-phrasing/lib/index.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/root.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-strong.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/strong.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/text.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js","webpack://_N_E/./node_modules/mdast-util-to-markdown/lib/handle/index.js","webpack://_N_E/./node_modules/mdast-util-gfm-table/lib/index.js","webpack://_N_E/./node_modules/mdast-util-gfm-task-list-item/lib/index.js","webpack://_N_E/./node_modules/mdast-util-gfm/lib/index.js","webpack://_N_E/./node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js","webpack://_N_E/./node_modules/micromark-extension-gfm-footnote/lib/syntax.js","webpack://_N_E/./node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js","webpack://_N_E/./node_modules/micromark-extension-gfm-table/lib/edit-map.js","webpack://_N_E/./node_modules/micromark-extension-gfm-table/lib/infer.js","webpack://_N_E/./node_modules/micromark-extension-gfm-table/lib/syntax.js","webpack://_N_E/./node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js","webpack://_N_E/./node_modules/micromark-extension-gfm/index.js","webpack://_N_E/./node_modules/remark-gfm/lib/index.js","webpack://_N_E/./node_modules/space-separated-tokens/index.js","webpack://_N_E/./node_modules/unist-util-is/lib/index.js","webpack://_N_E/./node_modules/unist-util-position/lib/index.js","webpack://_N_E/./node_modules/unist-util-visit-parents/lib/color.js","webpack://_N_E/./node_modules/unist-util-visit-parents/lib/index.js","webpack://_N_E/./node_modules/unist-util-visit/lib/index.js"],"sourcesContent":["'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","// 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","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar inline_style_parser_1 = __importDefault(require(\"inline-style-parser\"));\n/**\n * Parses inline style to object.\n *\n * @param style - Inline style.\n * @param iterator - Iterator.\n * @returns - Style object or null.\n *\n * @example Parsing inline style to object:\n *\n * ```js\n * import parse from 'style-to-object';\n * parse('line-height: 42;'); // { 'line-height': '42' }\n * ```\n */\nfunction StyleToObject(style, iterator) {\n    var styleObject = null;\n    if (!style || typeof style !== 'string') {\n        return styleObject;\n    }\n    var declarations = (0, inline_style_parser_1.default)(style);\n    var hasIterator = typeof iterator === 'function';\n    declarations.forEach(function (declaration) {\n        if (declaration.type !== 'declaration') {\n            return;\n        }\n        var property = declaration.property, value = declaration.value;\n        if (hasIterator) {\n            iterator(property, value, declaration);\n        }\n        else if (value) {\n            styleObject = styleObject || {};\n            styleObject[property] = value;\n        }\n    });\n    return styleObject;\n}\nexports.default = StyleToObject;\n//# sourceMappingURL=index.js.map","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","// src/children.ts\nimport { Children, isValidElement } from \"react\";\nfunction getValidChildren(children) {\n  return Children.toArray(children).filter(\n    (child) => isValidElement(child)\n  );\n}\nvar pickChildren = (children, targetChild) => {\n  var _a;\n  let target = [];\n  const withoutTargetChildren = (_a = Children.map(children, (item) => {\n    if (!isValidElement(item))\n      return item;\n    if (item.type === targetChild) {\n      target.push(item);\n      return null;\n    }\n    return item;\n  })) == null ? void 0 : _a.filter(Boolean);\n  const targetChildren = target.length >= 0 ? target : void 0;\n  return [withoutTargetChildren, targetChildren];\n};\n\nexport {\n  getValidChildren,\n  pickChildren\n};\n","var $b91590b2dc47de39$exports = {};\n$b91590b2dc47de39$exports = {\n    \"breadcrumbs\": `\\u{639}\\u{646}\\u{627}\\u{635}\\u{631} \\u{627}\\u{644}\\u{648}\\u{627}\\u{62C}\\u{647}\\u{629}`\n};\n\n\nexport {$b91590b2dc47de39$exports as default};\n//# sourceMappingURL=ar-AE.module.js.map\n","var $55b0693b2cf3fe91$exports = {};\n$55b0693b2cf3fe91$exports = {\n    \"breadcrumbs\": `\\u{422}\\u{440}\\u{43E}\\u{445}\\u{438} \\u{445}\\u{43B}\\u{44F}\\u{431}`\n};\n\n\nexport {$55b0693b2cf3fe91$exports as default};\n//# sourceMappingURL=bg-BG.module.js.map\n","var $6ec1ed7729e948cc$exports = {};\n$6ec1ed7729e948cc$exports = {\n    \"breadcrumbs\": `Popis cesty`\n};\n\n\nexport {$6ec1ed7729e948cc$exports as default};\n//# sourceMappingURL=cs-CZ.module.js.map\n","var $5a41bb2baa6861e4$exports = {};\n$5a41bb2baa6861e4$exports = {\n    \"breadcrumbs\": `Br\\xf8dkrummer`\n};\n\n\nexport {$5a41bb2baa6861e4$exports as default};\n//# sourceMappingURL=da-DK.module.js.map\n","var $f28bbea439e87eca$exports = {};\n$f28bbea439e87eca$exports = {\n    \"breadcrumbs\": `Breadcrumbs`\n};\n\n\nexport {$f28bbea439e87eca$exports as default};\n//# sourceMappingURL=de-DE.module.js.map\n","var $b3eca51cb720961a$exports = {};\n$b3eca51cb720961a$exports = {\n    \"breadcrumbs\": `\\u{3A0}\\u{3BB}\\u{3BF}\\u{3B7}\\u{3B3}\\u{3AE}\\u{3C3}\\u{3B5}\\u{3B9}\\u{3C2} breadcrumb`\n};\n\n\nexport {$b3eca51cb720961a$exports as default};\n//# sourceMappingURL=el-GR.module.js.map\n","var $0b39b205118db415$exports = {};\n$0b39b205118db415$exports = {\n    \"breadcrumbs\": `Breadcrumbs`\n};\n\n\nexport {$0b39b205118db415$exports as default};\n//# sourceMappingURL=en-US.module.js.map\n","var $f467c0ee7bfb0950$exports = {};\n$f467c0ee7bfb0950$exports = {\n    \"breadcrumbs\": `Migas de pan`\n};\n\n\nexport {$f467c0ee7bfb0950$exports as default};\n//# sourceMappingURL=es-ES.module.js.map\n","var $ab711d2ffb4cdf3d$exports = {};\n$ab711d2ffb4cdf3d$exports = {\n    \"breadcrumbs\": `Lingiread`\n};\n\n\nexport {$ab711d2ffb4cdf3d$exports as default};\n//# sourceMappingURL=et-EE.module.js.map\n","var $b63105d663e6f9d5$exports = {};\n$b63105d663e6f9d5$exports = {\n    \"breadcrumbs\": `Navigointilinkit`\n};\n\n\nexport {$b63105d663e6f9d5$exports as default};\n//# sourceMappingURL=fi-FI.module.js.map\n","var $9d2ed7be7fcdc2a1$exports = {};\n$9d2ed7be7fcdc2a1$exports = {\n    \"breadcrumbs\": `Chemin de navigation`\n};\n\n\nexport {$9d2ed7be7fcdc2a1$exports as default};\n//# sourceMappingURL=fr-FR.module.js.map\n","var $c5704294d85c7b5d$exports = {};\n$c5704294d85c7b5d$exports = {\n    \"breadcrumbs\": `\\u{5E9}\\u{5D1}\\u{5D9}\\u{5DC}\\u{5D9} \\u{5E0}\\u{5D9}\\u{5D5}\\u{5D5}\\u{5D8}`\n};\n\n\nexport {$c5704294d85c7b5d$exports as default};\n//# sourceMappingURL=he-IL.module.js.map\n","var $20c975671d6bbc63$exports = {};\n$20c975671d6bbc63$exports = {\n    \"breadcrumbs\": `Navigacijski putovi`\n};\n\n\nexport {$20c975671d6bbc63$exports as default};\n//# sourceMappingURL=hr-HR.module.js.map\n","var $2569ca3917233115$exports = {};\n$2569ca3917233115$exports = {\n    \"breadcrumbs\": `Morzsamen\\xfc`\n};\n\n\nexport {$2569ca3917233115$exports as default};\n//# sourceMappingURL=hu-HU.module.js.map\n","var $caa152f7f8e96c85$exports = {};\n$caa152f7f8e96c85$exports = {\n    \"breadcrumbs\": `Breadcrumb`\n};\n\n\nexport {$caa152f7f8e96c85$exports as default};\n//# sourceMappingURL=it-IT.module.js.map\n","var $cbc6af0cc98fad10$exports = {};\n$cbc6af0cc98fad10$exports = {\n    \"breadcrumbs\": `\\u{30D1}\\u{30F3}\\u{304F}\\u{305A}\\u{30EA}\\u{30B9}\\u{30C8}`\n};\n\n\nexport {$cbc6af0cc98fad10$exports as default};\n//# sourceMappingURL=ja-JP.module.js.map\n","var $ad9be5d332b4d607$exports = {};\n$ad9be5d332b4d607$exports = {\n    \"breadcrumbs\": `\\u{D0D0}\\u{C0C9} \\u{D45C}\\u{C2DC}`\n};\n\n\nexport {$ad9be5d332b4d607$exports as default};\n//# sourceMappingURL=ko-KR.module.js.map\n","var $659de19a00ff9617$exports = {};\n$659de19a00ff9617$exports = {\n    \"breadcrumbs\": `Nar\\u{161}ymo kelias`\n};\n\n\nexport {$659de19a00ff9617$exports as default};\n//# sourceMappingURL=lt-LT.module.js.map\n","var $173e9fb4d14fe309$exports = {};\n$173e9fb4d14fe309$exports = {\n    \"breadcrumbs\": `Atpaka\\u{13C}ce\\u{13C}i`\n};\n\n\nexport {$173e9fb4d14fe309$exports as default};\n//# sourceMappingURL=lv-LV.module.js.map\n","var $d8e2640a066567a9$exports = {};\n$d8e2640a066567a9$exports = {\n    \"breadcrumbs\": `Navigasjonsstier`\n};\n\n\nexport {$d8e2640a066567a9$exports as default};\n//# sourceMappingURL=nb-NO.module.js.map\n","var $d71fd764236c0d12$exports = {};\n$d71fd764236c0d12$exports = {\n    \"breadcrumbs\": `Broodkruimels`\n};\n\n\nexport {$d71fd764236c0d12$exports as default};\n//# sourceMappingURL=nl-NL.module.js.map\n","var $f4ad3faf9f4aaec6$exports = {};\n$f4ad3faf9f4aaec6$exports = {\n    \"breadcrumbs\": `Struktura nawigacyjna`\n};\n\n\nexport {$f4ad3faf9f4aaec6$exports as default};\n//# sourceMappingURL=pl-PL.module.js.map\n","var $9703be9d55d8e9c2$exports = {};\n$9703be9d55d8e9c2$exports = {\n    \"breadcrumbs\": `Caminho detalhado`\n};\n\n\nexport {$9703be9d55d8e9c2$exports as default};\n//# sourceMappingURL=pt-BR.module.js.map\n","var $7e23baec8a14f309$exports = {};\n$7e23baec8a14f309$exports = {\n    \"breadcrumbs\": `Categorias`\n};\n\n\nexport {$7e23baec8a14f309$exports as default};\n//# sourceMappingURL=pt-PT.module.js.map\n","var $568f95594049d56e$exports = {};\n$568f95594049d56e$exports = {\n    \"breadcrumbs\": `Miez de p\\xe2ine`\n};\n\n\nexport {$568f95594049d56e$exports as default};\n//# sourceMappingURL=ro-RO.module.js.map\n","var $625df06cecc70764$exports = {};\n$625df06cecc70764$exports = {\n    \"breadcrumbs\": `\\u{41D}\\u{430}\\u{432}\\u{438}\\u{433}\\u{430}\\u{446}\\u{438}\\u{44F}`\n};\n\n\nexport {$625df06cecc70764$exports as default};\n//# sourceMappingURL=ru-RU.module.js.map\n","var $b5a67525f3a2f594$exports = {};\n$b5a67525f3a2f594$exports = {\n    \"breadcrumbs\": `Naviga\\u{10D}n\\xe9 prvky Breadcrumbs`\n};\n\n\nexport {$b5a67525f3a2f594$exports as default};\n//# sourceMappingURL=sk-SK.module.js.map\n","var $16125922964febca$exports = {};\n$16125922964febca$exports = {\n    \"breadcrumbs\": `Drobtine`\n};\n\n\nexport {$16125922964febca$exports as default};\n//# sourceMappingURL=sl-SI.module.js.map\n","var $de104bf355206bcf$exports = {};\n$de104bf355206bcf$exports = {\n    \"breadcrumbs\": `Putanje navigacije`\n};\n\n\nexport {$de104bf355206bcf$exports as default};\n//# sourceMappingURL=sr-SP.module.js.map\n","var $d5ab76bcbadc9c07$exports = {};\n$d5ab76bcbadc9c07$exports = {\n    \"breadcrumbs\": `S\\xf6kv\\xe4gar`\n};\n\n\nexport {$d5ab76bcbadc9c07$exports as default};\n//# sourceMappingURL=sv-SE.module.js.map\n","var $a6a1af5968159b55$exports = {};\n$a6a1af5968159b55$exports = {\n    \"breadcrumbs\": `\\u{130}\\xe7erik haritalar\\u{131}`\n};\n\n\nexport {$a6a1af5968159b55$exports as default};\n//# sourceMappingURL=tr-TR.module.js.map\n","var $5204a30f0d17ffec$exports = {};\n$5204a30f0d17ffec$exports = {\n    \"breadcrumbs\": `\\u{41D}\\u{430}\\u{432}\\u{456}\\u{433}\\u{430}\\u{446}\\u{456}\\u{439}\\u{43D}\\u{430} \\u{441}\\u{442}\\u{435}\\u{436}\\u{43A}\\u{430}`\n};\n\n\nexport {$5204a30f0d17ffec$exports as default};\n//# sourceMappingURL=uk-UA.module.js.map\n","var $8d15e736e12d3dfd$exports = {};\n$8d15e736e12d3dfd$exports = {\n    \"breadcrumbs\": `\\u{5BFC}\\u{822A}\\u{680F}`\n};\n\n\nexport {$8d15e736e12d3dfd$exports as default};\n//# sourceMappingURL=zh-CN.module.js.map\n","var $f8c49dd804b75140$exports = {};\n$f8c49dd804b75140$exports = {\n    \"breadcrumbs\": `\\u{5C0E}\\u{89BD}\\u{5217}`\n};\n\n\nexport {$f8c49dd804b75140$exports as default};\n//# sourceMappingURL=zh-TW.module.js.map\n","import $g4LcJ$arAEmodulejs from \"./ar-AE.mjs\";\nimport $g4LcJ$bgBGmodulejs from \"./bg-BG.mjs\";\nimport $g4LcJ$csCZmodulejs from \"./cs-CZ.mjs\";\nimport $g4LcJ$daDKmodulejs from \"./da-DK.mjs\";\nimport $g4LcJ$deDEmodulejs from \"./de-DE.mjs\";\nimport $g4LcJ$elGRmodulejs from \"./el-GR.mjs\";\nimport $g4LcJ$enUSmodulejs from \"./en-US.mjs\";\nimport $g4LcJ$esESmodulejs from \"./es-ES.mjs\";\nimport $g4LcJ$etEEmodulejs from \"./et-EE.mjs\";\nimport $g4LcJ$fiFImodulejs from \"./fi-FI.mjs\";\nimport $g4LcJ$frFRmodulejs from \"./fr-FR.mjs\";\nimport $g4LcJ$heILmodulejs from \"./he-IL.mjs\";\nimport $g4LcJ$hrHRmodulejs from \"./hr-HR.mjs\";\nimport $g4LcJ$huHUmodulejs from \"./hu-HU.mjs\";\nimport $g4LcJ$itITmodulejs from \"./it-IT.mjs\";\nimport $g4LcJ$jaJPmodulejs from \"./ja-JP.mjs\";\nimport $g4LcJ$koKRmodulejs from \"./ko-KR.mjs\";\nimport $g4LcJ$ltLTmodulejs from \"./lt-LT.mjs\";\nimport $g4LcJ$lvLVmodulejs from \"./lv-LV.mjs\";\nimport $g4LcJ$nbNOmodulejs from \"./nb-NO.mjs\";\nimport $g4LcJ$nlNLmodulejs from \"./nl-NL.mjs\";\nimport $g4LcJ$plPLmodulejs from \"./pl-PL.mjs\";\nimport $g4LcJ$ptBRmodulejs from \"./pt-BR.mjs\";\nimport $g4LcJ$ptPTmodulejs from \"./pt-PT.mjs\";\nimport $g4LcJ$roROmodulejs from \"./ro-RO.mjs\";\nimport $g4LcJ$ruRUmodulejs from \"./ru-RU.mjs\";\nimport $g4LcJ$skSKmodulejs from \"./sk-SK.mjs\";\nimport $g4LcJ$slSImodulejs from \"./sl-SI.mjs\";\nimport $g4LcJ$srSPmodulejs from \"./sr-SP.mjs\";\nimport $g4LcJ$svSEmodulejs from \"./sv-SE.mjs\";\nimport $g4LcJ$trTRmodulejs from \"./tr-TR.mjs\";\nimport $g4LcJ$ukUAmodulejs from \"./uk-UA.mjs\";\nimport $g4LcJ$zhCNmodulejs from \"./zh-CN.mjs\";\nimport $g4LcJ$zhTWmodulejs from \"./zh-TW.mjs\";\n\nvar $8229b34715874f89$exports = {};\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n$8229b34715874f89$exports = {\n    \"ar-AE\": $g4LcJ$arAEmodulejs,\n    \"bg-BG\": $g4LcJ$bgBGmodulejs,\n    \"cs-CZ\": $g4LcJ$csCZmodulejs,\n    \"da-DK\": $g4LcJ$daDKmodulejs,\n    \"de-DE\": $g4LcJ$deDEmodulejs,\n    \"el-GR\": $g4LcJ$elGRmodulejs,\n    \"en-US\": $g4LcJ$enUSmodulejs,\n    \"es-ES\": $g4LcJ$esESmodulejs,\n    \"et-EE\": $g4LcJ$etEEmodulejs,\n    \"fi-FI\": $g4LcJ$fiFImodulejs,\n    \"fr-FR\": $g4LcJ$frFRmodulejs,\n    \"he-IL\": $g4LcJ$heILmodulejs,\n    \"hr-HR\": $g4LcJ$hrHRmodulejs,\n    \"hu-HU\": $g4LcJ$huHUmodulejs,\n    \"it-IT\": $g4LcJ$itITmodulejs,\n    \"ja-JP\": $g4LcJ$jaJPmodulejs,\n    \"ko-KR\": $g4LcJ$koKRmodulejs,\n    \"lt-LT\": $g4LcJ$ltLTmodulejs,\n    \"lv-LV\": $g4LcJ$lvLVmodulejs,\n    \"nb-NO\": $g4LcJ$nbNOmodulejs,\n    \"nl-NL\": $g4LcJ$nlNLmodulejs,\n    \"pl-PL\": $g4LcJ$plPLmodulejs,\n    \"pt-BR\": $g4LcJ$ptBRmodulejs,\n    \"pt-PT\": $g4LcJ$ptPTmodulejs,\n    \"ro-RO\": $g4LcJ$roROmodulejs,\n    \"ru-RU\": $g4LcJ$ruRUmodulejs,\n    \"sk-SK\": $g4LcJ$skSKmodulejs,\n    \"sl-SI\": $g4LcJ$slSImodulejs,\n    \"sr-SP\": $g4LcJ$srSPmodulejs,\n    \"sv-SE\": $g4LcJ$svSEmodulejs,\n    \"tr-TR\": $g4LcJ$trTRmodulejs,\n    \"uk-UA\": $g4LcJ$ukUAmodulejs,\n    \"zh-CN\": $g4LcJ$zhCNmodulejs,\n    \"zh-TW\": $g4LcJ$zhTWmodulejs\n};\n\n\nexport {$8229b34715874f89$exports as default};\n//# sourceMappingURL=intlStrings.module.js.map\n","/*\n * Copyright 2022 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ const $5b160d28a433310d$var$localeSymbol = Symbol.for('react-aria.i18n.locale');\nconst $5b160d28a433310d$var$stringsSymbol = Symbol.for('react-aria.i18n.strings');\nlet $5b160d28a433310d$var$cachedGlobalStrings = undefined;\nclass $5b160d28a433310d$export$c17fa47878dc55b6 {\n    /** Returns a localized string for the given key and locale. */ getStringForLocale(key, locale) {\n        let strings = this.getStringsForLocale(locale);\n        let string = strings[key];\n        if (!string) throw new Error(`Could not find intl message ${key} in ${locale} locale`);\n        return string;\n    }\n    /** Returns all localized strings for the given locale. */ getStringsForLocale(locale) {\n        let strings = this.strings[locale];\n        if (!strings) {\n            strings = $5b160d28a433310d$var$getStringsForLocale(locale, this.strings, this.defaultLocale);\n            this.strings[locale] = strings;\n        }\n        return strings;\n    }\n    static getGlobalDictionaryForPackage(packageName) {\n        if (typeof window === 'undefined') return null;\n        let locale = window[$5b160d28a433310d$var$localeSymbol];\n        if ($5b160d28a433310d$var$cachedGlobalStrings === undefined) {\n            let globalStrings = window[$5b160d28a433310d$var$stringsSymbol];\n            if (!globalStrings) return null;\n            $5b160d28a433310d$var$cachedGlobalStrings = {};\n            for(let pkg in globalStrings)$5b160d28a433310d$var$cachedGlobalStrings[pkg] = new $5b160d28a433310d$export$c17fa47878dc55b6({\n                [locale]: globalStrings[pkg]\n            }, locale);\n        }\n        let dictionary = $5b160d28a433310d$var$cachedGlobalStrings === null || $5b160d28a433310d$var$cachedGlobalStrings === void 0 ? void 0 : $5b160d28a433310d$var$cachedGlobalStrings[packageName];\n        if (!dictionary) throw new Error(`Strings for package \"${packageName}\" were not included by LocalizedStringProvider. Please add it to the list passed to createLocalizedStringDictionary.`);\n        return dictionary;\n    }\n    constructor(messages, defaultLocale = 'en-US'){\n        // Clone messages so we don't modify the original object.\n        // Filter out entries with falsy values which may have been caused by applying optimize-locales-plugin.\n        this.strings = Object.fromEntries(Object.entries(messages).filter(([, v])=>v));\n        this.defaultLocale = defaultLocale;\n    }\n}\nfunction $5b160d28a433310d$var$getStringsForLocale(locale, strings, defaultLocale = 'en-US') {\n    // If there is an exact match, use it.\n    if (strings[locale]) return strings[locale];\n    // Attempt to find the closest match by language.\n    // For example, if the locale is fr-CA (French Canadian), but there is only\n    // an fr-FR (France) set of strings, use that.\n    // This could be replaced with Intl.LocaleMatcher once it is supported.\n    // https://github.com/tc39/proposal-intl-localematcher\n    let language = $5b160d28a433310d$var$getLanguage(locale);\n    if (strings[language]) return strings[language];\n    for(let key in strings){\n        if (key.startsWith(language + '-')) return strings[key];\n    }\n    // Nothing close, use english.\n    return strings[defaultLocale];\n}\nfunction $5b160d28a433310d$var$getLanguage(locale) {\n    // @ts-ignore\n    if (Intl.Locale) // @ts-ignore\n    return new Intl.Locale(locale).language;\n    return locale.split('-')[0];\n}\n\n\nexport {$5b160d28a433310d$export$c17fa47878dc55b6 as LocalizedStringDictionary};\n//# sourceMappingURL=LocalizedStringDictionary.module.js.map\n","/*\n * Copyright 2022 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ const $6db58dc88e78b024$var$pluralRulesCache = new Map();\nconst $6db58dc88e78b024$var$numberFormatCache = new Map();\nclass $6db58dc88e78b024$export$2f817fcdc4b89ae0 {\n    /** Formats a localized string for the given key with the provided variables. */ format(key, variables) {\n        let message = this.strings.getStringForLocale(key, this.locale);\n        return typeof message === 'function' ? message(variables, this) : message;\n    }\n    plural(count, options, type = 'cardinal') {\n        let opt = options['=' + count];\n        if (opt) return typeof opt === 'function' ? opt() : opt;\n        let key = this.locale + ':' + type;\n        let pluralRules = $6db58dc88e78b024$var$pluralRulesCache.get(key);\n        if (!pluralRules) {\n            pluralRules = new Intl.PluralRules(this.locale, {\n                type: type\n            });\n            $6db58dc88e78b024$var$pluralRulesCache.set(key, pluralRules);\n        }\n        let selected = pluralRules.select(count);\n        opt = options[selected] || options.other;\n        return typeof opt === 'function' ? opt() : opt;\n    }\n    number(value) {\n        let numberFormat = $6db58dc88e78b024$var$numberFormatCache.get(this.locale);\n        if (!numberFormat) {\n            numberFormat = new Intl.NumberFormat(this.locale);\n            $6db58dc88e78b024$var$numberFormatCache.set(this.locale, numberFormat);\n        }\n        return numberFormat.format(value);\n    }\n    select(options, value) {\n        let opt = options[value] || options.other;\n        return typeof opt === 'function' ? opt() : opt;\n    }\n    constructor(locale, strings){\n        this.locale = locale;\n        this.strings = strings;\n    }\n}\n\n\nexport {$6db58dc88e78b024$export$2f817fcdc4b89ae0 as LocalizedStringFormatter};\n//# sourceMappingURL=LocalizedStringFormatter.module.js.map\n","import {useLocale as $18f2051aff69b9bf$export$43bb16f9c6d9e3f7} from \"./context.mjs\";\nimport {LocalizedStringDictionary as $6ksNp$LocalizedStringDictionary, LocalizedStringFormatter as $6ksNp$LocalizedStringFormatter} from \"@internationalized/string\";\nimport {useMemo as $6ksNp$useMemo} from \"react\";\n\n/*\n * Copyright 2022 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\nconst $fca6afa0e843324b$var$cache = new WeakMap();\nfunction $fca6afa0e843324b$var$getCachedDictionary(strings) {\n    let dictionary = $fca6afa0e843324b$var$cache.get(strings);\n    if (!dictionary) {\n        dictionary = new (0, $6ksNp$LocalizedStringDictionary)(strings);\n        $fca6afa0e843324b$var$cache.set(strings, dictionary);\n    }\n    return dictionary;\n}\nfunction $fca6afa0e843324b$export$87b761675e8eaa10(strings, packageName) {\n    return packageName && (0, $6ksNp$LocalizedStringDictionary).getGlobalDictionaryForPackage(packageName) || $fca6afa0e843324b$var$getCachedDictionary(strings);\n}\nfunction $fca6afa0e843324b$export$f12b703ca79dfbb1(strings, packageName) {\n    let { locale: locale } = (0, $18f2051aff69b9bf$export$43bb16f9c6d9e3f7)();\n    let dictionary = $fca6afa0e843324b$export$87b761675e8eaa10(strings, packageName);\n    return (0, $6ksNp$useMemo)(()=>new (0, $6ksNp$LocalizedStringFormatter)(locale, dictionary), [\n        locale,\n        dictionary\n    ]);\n}\n\n\nexport {$fca6afa0e843324b$export$87b761675e8eaa10 as useLocalizedStringDictionary, $fca6afa0e843324b$export$f12b703ca79dfbb1 as useLocalizedStringFormatter};\n//# sourceMappingURL=useLocalizedStringFormatter.module.js.map\n","import $lFxPb$intlStringsmodulejs from \"./intlStrings.mjs\";\nimport {filterDOMProps as $lFxPb$filterDOMProps} from \"@react-aria/utils\";\nimport {useLocalizedStringFormatter as $lFxPb$useLocalizedStringFormatter} from \"@react-aria/i18n\";\n\n\nfunction $parcel$interopDefault(a) {\n  return a && a.__esModule ? a.default : a;\n}\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\nfunction $848231d7a2b3998e$export$8cefe241bd876ca0(props) {\n    let { 'aria-label': ariaLabel, ...otherProps } = props;\n    let strings = (0, $lFxPb$useLocalizedStringFormatter)((0, ($parcel$interopDefault($lFxPb$intlStringsmodulejs))), '@react-aria/breadcrumbs');\n    return {\n        navProps: {\n            ...(0, $lFxPb$filterDOMProps)(otherProps, {\n                labelable: true\n            }),\n            'aria-label': ariaLabel || strings.format('breadcrumbs')\n        }\n    };\n}\n\n\nexport {$848231d7a2b3998e$export$8cefe241bd876ca0 as useBreadcrumbs};\n//# sourceMappingURL=useBreadcrumbs.module.js.map\n","\"use client\";\nimport {\n  breadcrumb_item_default\n} from \"./chunk-TPV4OC2M.mjs\";\n\n// src/use-breadcrumbs.ts\nimport { Children } from \"react\";\nimport {\n  mapPropsVariants,\n  useProviderContext\n} from \"@nextui-org/system\";\nimport { breadcrumbs } from \"@nextui-org/theme\";\nimport { filterDOMProps, pickChildren, useDOMRef } from \"@nextui-org/react-utils\";\nimport { mergeProps } from \"@react-aria/utils\";\nimport { useBreadcrumbs as useAriaBreadcrumbs } from \"@react-aria/breadcrumbs\";\nimport { useMemo } from \"react\";\nimport { clsx, dataAttr, objectToDeps } from \"@nextui-org/shared-utils\";\nfunction useBreadcrumbs(originalProps) {\n  var _a, _b;\n  const globalContext = useProviderContext();\n  const disableAnimation = (_b = (_a = originalProps == null ? void 0 : originalProps.disableAnimation) != null ? _a : globalContext == null ? void 0 : globalContext.disableAnimation) != null ? _b : false;\n  const [props, variantProps] = mapPropsVariants(originalProps, breadcrumbs.variantKeys);\n  const {\n    ref,\n    as,\n    color,\n    underline,\n    isDisabled,\n    separator,\n    children: childrenProp,\n    itemsBeforeCollapse = 1,\n    itemsAfterCollapse = 2,\n    maxItems = 8,\n    hideSeparator,\n    renderEllipsis,\n    className,\n    classNames,\n    itemClasses,\n    onAction,\n    ...otherProps\n  } = props;\n  const Component = as || \"nav\";\n  const shouldFilterDOMProps = typeof Component === \"string\";\n  const { navProps } = useAriaBreadcrumbs(originalProps);\n  const [, children] = pickChildren(childrenProp, breadcrumb_item_default);\n  const childCount = Children.count(children);\n  const domRef = useDOMRef(ref);\n  const slots = useMemo(\n    () => breadcrumbs({\n      ...variantProps,\n      className\n    }),\n    [objectToDeps(variantProps), className]\n  );\n  const baseStyles = clsx(classNames == null ? void 0 : classNames.base, className);\n  const itemProps = {\n    color,\n    underline,\n    disableAnimation,\n    hideSeparator,\n    size: originalProps == null ? void 0 : originalProps.size,\n    classNames: itemClasses\n  };\n  const getBaseProps = () => ({\n    ref: domRef,\n    \"data-slot\": \"base\",\n    className: slots.base({ class: baseStyles }),\n    ...mergeProps(\n      navProps,\n      filterDOMProps(otherProps, {\n        enabled: shouldFilterDOMProps\n      })\n    )\n  });\n  const getListProps = () => ({\n    \"data-slot\": \"list\",\n    className: slots.list({ class: classNames == null ? void 0 : classNames.list })\n  });\n  const getEllipsisProps = () => ({\n    \"data-slot\": \"ellipsis\",\n    className: slots.ellipsis({ class: classNames == null ? void 0 : classNames.ellipsis })\n  });\n  const getSeparatorProps = () => ({\n    \"data-slot\": \"separator\",\n    \"aria-hidden\": dataAttr(true),\n    className: slots.separator({ class: classNames == null ? void 0 : classNames.separator })\n  });\n  return {\n    Component,\n    children,\n    slots,\n    separator,\n    childCount,\n    itemsAfterCollapse,\n    itemsBeforeCollapse,\n    maxItems,\n    classNames,\n    isDisabled,\n    itemProps,\n    renderEllipsis,\n    getBaseProps,\n    getListProps,\n    getEllipsisProps,\n    getSeparatorProps,\n    onAction\n  };\n}\n\nexport {\n  useBreadcrumbs\n};\n","// src/chevron-right.tsx\nimport { jsx } from \"react/jsx-runtime\";\nvar ChevronRightIcon = (props) => /* @__PURE__ */ jsx(\n  \"svg\",\n  {\n    \"aria-hidden\": \"true\",\n    fill: \"none\",\n    focusable: \"false\",\n    height: \"1em\",\n    role: \"presentation\",\n    stroke: \"currentColor\",\n    strokeLinecap: \"round\",\n    strokeLinejoin: \"round\",\n    strokeWidth: \"1.5\",\n    viewBox: \"0 0 24 24\",\n    width: \"1em\",\n    ...props,\n    children: /* @__PURE__ */ jsx(\"path\", { d: \"m9 18 6-6-6-6\" })\n  }\n);\n\nexport {\n  ChevronRightIcon\n};\n","// src/ellipsis.tsx\nimport { jsx, jsxs } from \"react/jsx-runtime\";\nvar EllipsisIcon = (props) => /* @__PURE__ */ jsxs(\n  \"svg\",\n  {\n    \"aria-hidden\": \"true\",\n    fill: \"none\",\n    height: \"1em\",\n    shapeRendering: \"geometricPrecision\",\n    strokeLinecap: \"round\",\n    strokeLinejoin: \"round\",\n    strokeWidth: \"1.5\",\n    viewBox: \"0 0 24 24\",\n    width: \"1em\",\n    ...props,\n    children: [\n      /* @__PURE__ */ jsx(\"circle\", { cx: \"12\", cy: \"12\", fill: \"currentColor\", r: \"1\" }),\n      /* @__PURE__ */ jsx(\"circle\", { cx: \"19\", cy: \"12\", fill: \"currentColor\", r: \"1\" }),\n      /* @__PURE__ */ jsx(\"circle\", { cx: \"5\", cy: \"12\", fill: \"currentColor\", r: \"1\" })\n    ]\n  }\n);\n\nexport {\n  EllipsisIcon\n};\n","// src/console.ts\nvar warningStack = {};\nfunction warn(message, component, ...args) {\n  var _a;\n  const tag = component ? ` [${component}]` : \" \";\n  const log = `[Next UI]${tag}: ${message}`;\n  if (typeof console === \"undefined\")\n    return;\n  if (warningStack[log])\n    return;\n  warningStack[log] = true;\n  if (((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.NODE_ENV) !== \"production\") {\n    return console.warn(log, args);\n  }\n}\n\nexport {\n  warn\n};\n","\"use client\";\nimport {\n  useBreadcrumbs\n} from \"./chunk-AAD6P2XK.mjs\";\n\n// src/breadcrumbs.tsx\nimport { cloneElement, useMemo } from \"react\";\nimport { forwardRef } from \"@nextui-org/system\";\nimport { ChevronRightIcon, EllipsisIcon } from \"@nextui-org/shared-icons\";\nimport { warn } from \"@nextui-org/shared-utils\";\nimport { chain } from \"@react-aria/utils\";\nimport { jsx } from \"react/jsx-runtime\";\nvar Breadcrumbs = forwardRef((props, ref) => {\n  const {\n    Component,\n    children,\n    childCount,\n    itemProps,\n    separator = /* @__PURE__ */ jsx(ChevronRightIcon, {}),\n    maxItems,\n    itemsBeforeCollapse,\n    itemsAfterCollapse,\n    isDisabled,\n    renderEllipsis,\n    getBaseProps,\n    getListProps,\n    getEllipsisProps,\n    getSeparatorProps,\n    onAction\n  } = useBreadcrumbs({\n    ...props,\n    ref\n  });\n  const content = useMemo(() => {\n    let items = children == null ? void 0 : children.map((child, i) => {\n      var _a;\n      const isLast = i === childCount - 1;\n      const itemKey = (child == null ? void 0 : child.key) || i;\n      return cloneElement(child, {\n        ...itemProps,\n        isLast,\n        separator,\n        isDisabled: isDisabled && !isLast,\n        isCurrent: isLast || child.props.isCurrent,\n        ...child.props,\n        key: itemKey,\n        onPress: chain((_a = child.props) == null ? void 0 : _a.onPress, () => onAction == null ? void 0 : onAction(itemKey))\n      });\n    });\n    if (!items)\n      return null;\n    if (childCount < maxItems) {\n      return items;\n    }\n    if (itemsBeforeCollapse + itemsAfterCollapse >= childCount) {\n      warn(\n        `You have provided an invalid combination of props to the Breadcrumbs. itemsAfterCollapse={${itemsAfterCollapse}} + itemsBeforeCollapse={${itemsBeforeCollapse}} >= itemsCount={${childCount}}`,\n        \"Breadcrumbs\"\n      );\n      return items;\n    }\n    const itemsInEllipsis = items.slice(itemsBeforeCollapse, items.length - itemsAfterCollapse);\n    if (itemsInEllipsis.length < 1) {\n      return items;\n    }\n    const ellipsisIcon = /* @__PURE__ */ jsx(EllipsisIcon, { ...getEllipsisProps() });\n    const collapsedItem = cloneElement(itemsInEllipsis[0], {\n      ...itemsInEllipsis[0].props,\n      key: \"ellipsis\",\n      children: ellipsisIcon\n    });\n    const ellipsisItem = typeof renderEllipsis === \"function\" ? renderEllipsis({\n      collapsedItem,\n      items: itemsInEllipsis.map((item) => item.props),\n      maxItems,\n      ellipsisIcon,\n      itemsBeforeCollapse,\n      itemsAfterCollapse,\n      separator: /* @__PURE__ */ jsx(\"span\", { ...getSeparatorProps(), children: separator })\n    }) : collapsedItem;\n    return [\n      ...items.slice(0, itemsBeforeCollapse),\n      ellipsisItem,\n      ...items.slice(items.length - itemsAfterCollapse, items.length)\n    ];\n  }, [\n    children,\n    childCount,\n    separator,\n    itemProps,\n    itemsBeforeCollapse,\n    itemsAfterCollapse,\n    isDisabled\n  ]);\n  return /* @__PURE__ */ jsx(Component, { ...getBaseProps(), children: /* @__PURE__ */ jsx(\"ol\", { ...getListProps(), children: content }) });\n});\nBreadcrumbs.displayName = \"NextUI.Breadcrumbs\";\nvar breadcrumbs_default = Breadcrumbs;\n\nexport {\n  breadcrumbs_default\n};\n","import {useLink as $iYMrm$useLink} from \"@react-aria/link\";\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nfunction $dafd15390222438a$export$452b38fce62c9384(props, ref) {\n    let { isCurrent: isCurrent, isDisabled: isDisabled, 'aria-current': ariaCurrent, elementType: elementType = 'a', ...otherProps } = props;\n    let { linkProps: linkProps } = (0, $iYMrm$useLink)({\n        isDisabled: isDisabled || isCurrent,\n        elementType: elementType,\n        ...otherProps\n    }, ref);\n    let isHeading = /^h[1-6]$/.test(elementType);\n    let itemProps = {};\n    if (!isHeading) itemProps = linkProps;\n    if (isCurrent) {\n        itemProps['aria-current'] = ariaCurrent || 'page';\n        // isCurrent sets isDisabled === true for the current item,\n        // so we have to restore the tabIndex in order to support autoFocus.\n        itemProps.tabIndex = props.autoFocus ? -1 : undefined;\n    }\n    return {\n        itemProps: {\n            'aria-disabled': isDisabled,\n            ...itemProps\n        }\n    };\n}\n\n\nexport {$dafd15390222438a$export$452b38fce62c9384 as useBreadcrumbItem};\n//# sourceMappingURL=useBreadcrumbItem.module.js.map\n","\"use client\";\n\n// src/use-breadcrumb-item.ts\nimport { mapPropsVariants } from \"@nextui-org/system\";\nimport { useFocusRing } from \"@react-aria/focus\";\nimport { breadcrumbItem } from \"@nextui-org/theme\";\nimport { filterDOMProps, useDOMRef } from \"@nextui-org/react-utils\";\nimport { useBreadcrumbItem as useAriaBreadcrumbItem } from \"@react-aria/breadcrumbs\";\nimport { clsx, dataAttr, objectToDeps } from \"@nextui-org/shared-utils\";\nimport { useMemo } from \"react\";\nimport { mergeProps } from \"@react-aria/utils\";\nfunction useBreadcrumbItem(originalProps) {\n  const [props, variantProps] = mapPropsVariants(originalProps, breadcrumbItem.variantKeys);\n  const {\n    ref,\n    as,\n    className,\n    children,\n    isLast,\n    separator,\n    startContent,\n    endContent,\n    classNames,\n    hideSeparator = false,\n    ...otherProps\n  } = props;\n  const WrapperComponent = as || \"li\";\n  const isCurrent = !!(originalProps == null ? void 0 : originalProps.isCurrent);\n  const isDisabled = originalProps == null ? void 0 : originalProps.isDisabled;\n  const Component = (originalProps == null ? void 0 : originalProps.href) && !isCurrent ? \"a\" : \"span\";\n  const shouldFilterDOMProps = typeof Component === \"string\";\n  const domRef = useDOMRef(ref);\n  const { itemProps } = useAriaBreadcrumbItem(\n    { ...originalProps, isCurrent, elementType: Component },\n    domRef\n  );\n  const { isFocusVisible, isFocused, focusProps } = useFocusRing();\n  const slots = useMemo(\n    () => breadcrumbItem({\n      ...variantProps,\n      isCurrent,\n      underline: (originalProps == null ? void 0 : originalProps.underline) !== void 0 && !isCurrent ? originalProps == null ? void 0 : originalProps.underline : \"none\",\n      className\n    }),\n    [objectToDeps(variantProps), isCurrent, className]\n  );\n  const baseStyles = clsx(classNames == null ? void 0 : classNames.base, className);\n  const getBaseProps = () => ({\n    ref: domRef,\n    \"data-slot\": \"base\",\n    className: slots.base({ class: baseStyles }),\n    ...filterDOMProps(otherProps, {\n      enabled: shouldFilterDOMProps\n    })\n  });\n  const getItemProps = () => ({\n    href: !isCurrent ? originalProps == null ? void 0 : originalProps.href : void 0,\n    \"data-slot\": \"item\",\n    \"data-focus\": dataAttr(isFocused),\n    \"data-focus-visible\": dataAttr(isFocusVisible),\n    \"data-disabled\": originalProps == null ? void 0 : originalProps.isDisabled,\n    \"data-current\": originalProps == null ? void 0 : originalProps.isCurrent,\n    className: slots.item({ class: classNames == null ? void 0 : classNames.item }),\n    ...mergeProps(itemProps, isDisabled ? {} : focusProps)\n  });\n  const getSeparatorProps = () => ({\n    \"data-slot\": \"separator\",\n    \"aria-hidden\": dataAttr(true),\n    className: slots.separator({ class: classNames == null ? void 0 : classNames.separator })\n  });\n  return {\n    Component,\n    WrapperComponent,\n    children,\n    separator,\n    startContent,\n    endContent,\n    isDisabled,\n    isCurrent,\n    isLast,\n    hideSeparator,\n    getBaseProps,\n    getItemProps,\n    getSeparatorProps\n  };\n}\n\nexport {\n  useBreadcrumbItem\n};\n","\"use client\";\nimport {\n  useBreadcrumbItem\n} from \"./chunk-HM6BKCEH.mjs\";\n\n// src/breadcrumb-item.tsx\nimport { forwardRef } from \"@nextui-org/system\";\nimport { jsx, jsxs } from \"react/jsx-runtime\";\nvar Breadcrumbs = forwardRef((props, ref) => {\n  const {\n    Component,\n    WrapperComponent,\n    children,\n    isLast,\n    separator,\n    startContent,\n    endContent,\n    hideSeparator,\n    getBaseProps,\n    getItemProps,\n    getSeparatorProps\n  } = useBreadcrumbItem({\n    ...props,\n    ref\n  });\n  return /* @__PURE__ */ jsxs(WrapperComponent, { ...getBaseProps(), children: [\n    /* @__PURE__ */ jsxs(Component, { ...getItemProps(), children: [\n      startContent,\n      children,\n      endContent\n    ] }),\n    !isLast && !hideSeparator && /* @__PURE__ */ jsx(\"span\", { ...getSeparatorProps(), children: separator })\n  ] });\n});\nBreadcrumbs.displayName = \"NextUI.Breadcrumbs\";\nvar breadcrumb_item_default = Breadcrumbs;\n\nexport {\n  breadcrumb_item_default\n};\n","// src/dom-props.ts\nvar DOMPropNames = /* @__PURE__ */ new Set([\n  \"id\",\n  \"type\",\n  \"style\",\n  \"title\",\n  \"role\",\n  \"tabIndex\",\n  \"htmlFor\",\n  \"width\",\n  \"height\",\n  \"abbr\",\n  \"accept\",\n  \"acceptCharset\",\n  \"accessKey\",\n  \"action\",\n  \"allowFullScreen\",\n  \"allowTransparency\",\n  \"alt\",\n  \"async\",\n  \"autoComplete\",\n  \"autoFocus\",\n  \"autoPlay\",\n  \"cellPadding\",\n  \"cellSpacing\",\n  \"challenge\",\n  \"charset\",\n  \"checked\",\n  \"cite\",\n  \"class\",\n  \"className\",\n  \"cols\",\n  \"colSpan\",\n  \"command\",\n  \"content\",\n  \"contentEditable\",\n  \"contextMenu\",\n  \"controls\",\n  \"coords\",\n  \"crossOrigin\",\n  \"data\",\n  \"dateTime\",\n  \"default\",\n  \"defer\",\n  \"dir\",\n  \"disabled\",\n  \"download\",\n  \"draggable\",\n  \"dropzone\",\n  \"encType\",\n  \"enterKeyHint\",\n  \"for\",\n  \"form\",\n  \"formAction\",\n  \"formEncType\",\n  \"formMethod\",\n  \"formNoValidate\",\n  \"formTarget\",\n  \"frameBorder\",\n  \"headers\",\n  \"hidden\",\n  \"high\",\n  \"href\",\n  \"hrefLang\",\n  \"httpEquiv\",\n  \"icon\",\n  \"inputMode\",\n  \"isMap\",\n  \"itemId\",\n  \"itemProp\",\n  \"itemRef\",\n  \"itemScope\",\n  \"itemType\",\n  \"kind\",\n  \"label\",\n  \"lang\",\n  \"list\",\n  \"loop\",\n  \"manifest\",\n  \"max\",\n  \"maxLength\",\n  \"media\",\n  \"mediaGroup\",\n  \"method\",\n  \"min\",\n  \"minLength\",\n  \"multiple\",\n  \"muted\",\n  \"name\",\n  \"noValidate\",\n  \"open\",\n  \"optimum\",\n  \"pattern\",\n  \"ping\",\n  \"placeholder\",\n  \"poster\",\n  \"preload\",\n  \"radioGroup\",\n  \"referrerPolicy\",\n  \"readOnly\",\n  \"rel\",\n  \"required\",\n  \"rows\",\n  \"rowSpan\",\n  \"sandbox\",\n  \"scope\",\n  \"scoped\",\n  \"scrolling\",\n  \"seamless\",\n  \"selected\",\n  \"shape\",\n  \"size\",\n  \"sizes\",\n  \"slot\",\n  \"sortable\",\n  \"span\",\n  \"spellCheck\",\n  \"src\",\n  \"srcDoc\",\n  \"srcSet\",\n  \"start\",\n  \"step\",\n  \"target\",\n  \"translate\",\n  \"typeMustMatch\",\n  \"useMap\",\n  \"value\",\n  \"wmode\",\n  \"wrap\"\n]);\nvar DOMEventNames = /* @__PURE__ */ new Set([\n  \"onCopy\",\n  \"onCut\",\n  \"onPaste\",\n  \"onLoad\",\n  \"onError\",\n  \"onWheel\",\n  \"onScroll\",\n  \"onCompositionEnd\",\n  \"onCompositionStart\",\n  \"onCompositionUpdate\",\n  \"onKeyDown\",\n  \"onKeyPress\",\n  \"onKeyUp\",\n  \"onFocus\",\n  \"onBlur\",\n  \"onChange\",\n  \"onInput\",\n  \"onSubmit\",\n  \"onClick\",\n  \"onContextMenu\",\n  \"onDoubleClick\",\n  \"onDrag\",\n  \"onDragEnd\",\n  \"onDragEnter\",\n  \"onDragExit\",\n  \"onDragLeave\",\n  \"onDragOver\",\n  \"onDragStart\",\n  \"onDrop\",\n  \"onMouseDown\",\n  \"onMouseEnter\",\n  \"onMouseLeave\",\n  \"onMouseMove\",\n  \"onMouseOut\",\n  \"onMouseOver\",\n  \"onMouseUp\",\n  \"onPointerDown\",\n  \"onPointerEnter\",\n  \"onPointerLeave\",\n  \"onPointerUp\",\n  \"onSelect\",\n  \"onTouchCancel\",\n  \"onTouchEnd\",\n  \"onTouchMove\",\n  \"onTouchStart\",\n  \"onAnimationStart\",\n  \"onAnimationEnd\",\n  \"onAnimationIteration\",\n  \"onTransitionEnd\"\n]);\n\nexport {\n  DOMPropNames,\n  DOMEventNames\n};\n","import {\n  DOMEventNames,\n  DOMPropNames\n} from \"./chunk-RFWDHYLZ.mjs\";\n\n// src/filter-dom-props.ts\nvar propRe = /^(data-.*)$/;\nvar ariaRe = /^(aria-.*)$/;\nvar funcRe = /^(on[A-Z].*)$/;\nfunction filterDOMProps(props, opts = {}) {\n  let {\n    labelable = true,\n    enabled = true,\n    propNames,\n    omitPropNames,\n    omitEventNames,\n    omitDataProps,\n    omitEventProps\n  } = opts;\n  let filteredProps = {};\n  if (!enabled) {\n    return props;\n  }\n  for (const prop in props) {\n    if (omitPropNames == null ? void 0 : omitPropNames.has(prop)) {\n      continue;\n    }\n    if ((omitEventNames == null ? void 0 : omitEventNames.has(prop)) && funcRe.test(prop)) {\n      continue;\n    }\n    if (funcRe.test(prop) && !DOMEventNames.has(prop)) {\n      continue;\n    }\n    if (omitDataProps && propRe.test(prop)) {\n      continue;\n    }\n    if (omitEventProps && funcRe.test(prop)) {\n      continue;\n    }\n    if (Object.prototype.hasOwnProperty.call(props, prop) && (DOMPropNames.has(prop) || labelable && ariaRe.test(prop) || (propNames == null ? void 0 : propNames.has(prop)) || propRe.test(prop)) || funcRe.test(prop)) {\n      filteredProps[prop] = props[prop];\n    }\n  }\n  return filteredProps;\n}\n\nexport {\n  filterDOMProps\n};\n","\"use client\";\n\n// src/dom.ts\nimport {\n  useImperativeHandle,\n  useLayoutEffect,\n  useRef\n} from \"react\";\nfunction canUseDOM() {\n  return !!(typeof window !== \"undefined\" && window.document && window.document.createElement);\n}\nvar isBrowser = canUseDOM();\nfunction getUserAgentBrowser(navigator) {\n  const { userAgent: ua, vendor } = navigator;\n  const android = /(android)/i.test(ua);\n  switch (true) {\n    case /CriOS/.test(ua):\n      return \"Chrome for iOS\";\n    case /Edg\\//.test(ua):\n      return \"Edge\";\n    case (android && /Silk\\//.test(ua)):\n      return \"Silk\";\n    case (/Chrome/.test(ua) && /Google Inc/.test(vendor)):\n      return \"Chrome\";\n    case /Firefox\\/\\d+\\.\\d+$/.test(ua):\n      return \"Firefox\";\n    case android:\n      return \"AOSP\";\n    case /MSIE|Trident/.test(ua):\n      return \"IE\";\n    case (/Safari/.test(navigator.userAgent) && /Apple Computer/.test(ua)):\n      return \"Safari\";\n    case /AppleWebKit/.test(ua):\n      return \"WebKit\";\n    default:\n      return null;\n  }\n}\nfunction getUserAgentOS(navigator) {\n  const { userAgent: ua, platform } = navigator;\n  switch (true) {\n    case /Android/.test(ua):\n      return \"Android\";\n    case /iPhone|iPad|iPod/.test(platform):\n      return \"iOS\";\n    case /Win/.test(platform):\n      return \"Windows\";\n    case /Mac/.test(platform):\n      return \"Mac\";\n    case /CrOS/.test(ua):\n      return \"Chrome OS\";\n    case /Firefox/.test(ua):\n      return \"Firefox OS\";\n    default:\n      return null;\n  }\n}\nfunction detectDeviceType(navigator) {\n  const { userAgent: ua } = navigator;\n  if (/(tablet)|(iPad)|(Nexus 9)/i.test(ua))\n    return \"tablet\";\n  if (/(mobi)/i.test(ua))\n    return \"phone\";\n  return \"desktop\";\n}\nfunction detectOS(os) {\n  if (!isBrowser)\n    return false;\n  return getUserAgentOS(window.navigator) === os;\n}\nfunction detectBrowser(browser) {\n  if (!isBrowser)\n    return false;\n  return getUserAgentBrowser(window.navigator) === browser;\n}\nfunction detectTouch() {\n  if (!isBrowser)\n    return false;\n  return window.ontouchstart === null && window.ontouchmove === null && window.ontouchend === null;\n}\nfunction createDOMRef(ref) {\n  return {\n    UNSAFE_getDOMNode() {\n      return ref.current;\n    }\n  };\n}\nfunction createFocusableRef(domRef, focusableRef = domRef) {\n  return {\n    ...createDOMRef(domRef),\n    focus() {\n      if (focusableRef.current) {\n        focusableRef.current.focus();\n      }\n    }\n  };\n}\nfunction useDOMRef(ref) {\n  const domRef = useRef(null);\n  useImperativeHandle(ref, () => domRef.current);\n  return domRef;\n}\nfunction useFocusableRef(ref, focusableRef) {\n  const domRef = useRef(null);\n  useImperativeHandle(ref, () => createFocusableRef(domRef, focusableRef));\n  return domRef;\n}\nfunction useSyncRef(context, ref) {\n  useLayoutEffect(() => {\n    if (context && context.ref && ref && ref.current) {\n      context.ref.current = ref.current;\n      return () => {\n        var _a;\n        if ((_a = context.ref) == null ? void 0 : _a.current) {\n          context.ref.current = null;\n        }\n      };\n    }\n  }, [context, ref]);\n}\nfunction areRectsIntersecting(rect1, rect2) {\n  return rect1 && rect2 && rect1.x < rect2.x + rect2.width && rect1.x + rect1.width > rect2.x && rect1.y < rect2.y + rect2.height && rect1.y + rect1.height > rect2.y;\n}\n\nexport {\n  canUseDOM,\n  isBrowser,\n  getUserAgentBrowser,\n  getUserAgentOS,\n  detectDeviceType,\n  detectOS,\n  detectBrowser,\n  detectTouch,\n  createDOMRef,\n  createFocusableRef,\n  useDOMRef,\n  useFocusableRef,\n  useSyncRef,\n  areRectsIntersecting\n};\n","// src/clsx.ts\nfunction toVal(mix) {\n  var k, y, str = \"\";\n  if (typeof mix === \"string\" || typeof mix === \"number\") {\n    str += mix;\n  } else if (typeof mix === \"object\") {\n    if (Array.isArray(mix)) {\n      for (k = 0; k < mix.length; k++) {\n        if (mix[k]) {\n          if (y = toVal(mix[k])) {\n            str && (str += \" \");\n            str += y;\n          }\n        }\n      }\n    } else {\n      for (k in mix) {\n        if (mix[k]) {\n          str && (str += \" \");\n          str += k;\n        }\n      }\n    }\n  }\n  return str;\n}\nfunction clsx(...args) {\n  var i = 0, tmp, x, str = \"\";\n  while (i < args.length) {\n    if (tmp = args[i++]) {\n      if (x = toVal(tmp)) {\n        str && (str += \" \");\n        str += x;\n      }\n    }\n  }\n  return str;\n}\n\nexport {\n  clsx\n};\n","// src/assertion.ts\nvar __DEV__ = process.env.NODE_ENV !== \"production\";\nvar __TEST__ = process.env.NODE_ENV === \"test\";\nfunction isArray(value) {\n  return Array.isArray(value);\n}\nfunction isEmptyArray(value) {\n  return isArray(value) && value.length === 0;\n}\nfunction isObject(value) {\n  const type = typeof value;\n  return value != null && (type === \"object\" || type === \"function\") && !isArray(value);\n}\nfunction isEmptyObject(value) {\n  return isObject(value) && Object.keys(value).length === 0;\n}\nfunction isEmpty(value) {\n  if (isArray(value))\n    return isEmptyArray(value);\n  if (isObject(value))\n    return isEmptyObject(value);\n  if (value == null || value === \"\")\n    return true;\n  return false;\n}\nfunction isFunction(value) {\n  return typeof value === \"function\";\n}\nvar dataAttr = (condition) => condition ? \"true\" : void 0;\nvar isNumeric = (value) => value != null && parseInt(value.toString(), 10) > 0;\n\nexport {\n  __DEV__,\n  __TEST__,\n  isArray,\n  isEmptyArray,\n  isObject,\n  isEmptyObject,\n  isEmpty,\n  isFunction,\n  dataAttr,\n  isNumeric\n};\n","// src/functions.ts\nvar capitalize = (text) => {\n  return text.charAt(0).toUpperCase() + text.slice(1);\n};\nfunction callAllHandlers(...fns) {\n  return function func(event) {\n    fns.some((fn) => {\n      fn == null ? void 0 : fn(event);\n      return event == null ? void 0 : event.defaultPrevented;\n    });\n  };\n}\nfunction callAll(...fns) {\n  return function mergedFn(arg) {\n    fns.forEach((fn) => {\n      fn == null ? void 0 : fn(arg);\n    });\n  };\n}\nfunction extractProperty(key, defaultValue, ...objs) {\n  let result = defaultValue;\n  for (const obj of objs) {\n    if (obj && key in obj && !!obj[key]) {\n      result = obj[key];\n    }\n  }\n  return result;\n}\nfunction getUniqueID(prefix) {\n  return `${prefix}-${Math.floor(Math.random() * 1e6)}`;\n}\nfunction removeEvents(input) {\n  for (const key in input) {\n    if (key.startsWith(\"on\")) {\n      delete input[key];\n    }\n  }\n  return input;\n}\nfunction objectToDeps(obj) {\n  if (!obj || typeof obj !== \"object\") {\n    return \"\";\n  }\n  try {\n    return JSON.stringify(obj);\n  } catch (e) {\n    return \"\";\n  }\n}\n\nexport {\n  capitalize,\n  callAllHandlers,\n  callAll,\n  extractProperty,\n  getUniqueID,\n  removeEvents,\n  objectToDeps\n};\n","import {\n  tv\n} from \"./chunk-GMMETTYU.mjs\";\n\n// src/components/image.ts\nvar image = tv({\n  slots: {\n    wrapper: \"relative shadow-black/5\",\n    zoomedWrapper: \"relative overflow-hidden rounded-inherit\",\n    img: \"relative z-10 opacity-0 shadow-black/5 data-[loaded=true]:opacity-100\",\n    blurredImg: [\n      \"absolute\",\n      \"z-0\",\n      \"inset-0\",\n      \"w-full\",\n      \"h-full\",\n      \"object-cover\",\n      \"filter\",\n      \"blur-lg\",\n      \"scale-105\",\n      \"saturate-150\",\n      \"opacity-30\",\n      \"translate-y-1\"\n    ]\n  },\n  variants: {\n    radius: {\n      none: {},\n      sm: {},\n      md: {},\n      lg: {},\n      full: {}\n    },\n    shadow: {\n      none: {\n        wrapper: \"shadow-none\",\n        img: \"shadow-none\"\n      },\n      sm: {\n        wrapper: \"shadow-small\",\n        img: \"shadow-small\"\n      },\n      md: {\n        wrapper: \"shadow-medium\",\n        img: \"shadow-medium\"\n      },\n      lg: {\n        wrapper: \"shadow-large\",\n        img: \"shadow-large\"\n      }\n    },\n    isZoomed: {\n      true: {\n        img: [\"object-cover\", \"transform\", \"hover:scale-125\"]\n      }\n    },\n    showSkeleton: {\n      true: {\n        wrapper: [\n          \"group\",\n          \"relative\",\n          \"overflow-hidden\",\n          \"bg-content3 dark:bg-content2\",\n          \"before:opacity-100\",\n          \"before:absolute\",\n          \"before:inset-0\",\n          \"before:-translate-x-full\",\n          \"before:animate-[shimmer_2s_infinite]\",\n          \"before:border-t\",\n          \"before:border-content4/30\",\n          \"before:bg-gradient-to-r\",\n          \"before:from-transparent\",\n          \"before:via-content4\",\n          \"dark:before:via-default-700/10\",\n          \"before:to-transparent\",\n          \"after:opacity-100\",\n          \"after:absolute\",\n          \"after:inset-0\",\n          \"after:-z-10\",\n          \"after:bg-content3\",\n          \"dark:after:bg-content2\"\n        ],\n        img: \"opacity-0\"\n      }\n    },\n    disableAnimation: {\n      true: {\n        img: \"transition-none\"\n      },\n      false: {\n        img: \"transition-transform-opacity motion-reduce:transition-none !duration-300\"\n      }\n    }\n  },\n  defaultVariants: {\n    radius: \"lg\",\n    shadow: \"none\",\n    isZoomed: false,\n    isBlurred: false,\n    showSkeleton: false,\n    disableAnimation: false\n  },\n  compoundSlots: [\n    {\n      slots: [\"wrapper\", \"img\", \"blurredImg\", \"zoomedWrapper\"],\n      radius: \"none\",\n      class: \"rounded-none\"\n    },\n    {\n      slots: [\"wrapper\", \"img\", \"blurredImg\", \"zoomedWrapper\"],\n      radius: \"full\",\n      class: \"rounded-full\"\n    },\n    {\n      slots: [\"wrapper\", \"img\", \"blurredImg\", \"zoomedWrapper\"],\n      radius: \"sm\",\n      class: \"rounded-small\"\n    },\n    {\n      slots: [\"wrapper\", \"img\", \"blurredImg\", \"zoomedWrapper\"],\n      radius: \"md\",\n      class: \"rounded-md\"\n    },\n    {\n      slots: [\"wrapper\", \"img\", \"blurredImg\", \"zoomedWrapper\"],\n      radius: \"lg\",\n      class: \"rounded-large\"\n    }\n  ]\n});\n\nexport {\n  image\n};\n","// src/index.ts\nimport { useEffect, useLayoutEffect } from \"react\";\nvar useSafeLayoutEffect = Boolean(globalThis == null ? void 0 : globalThis.document) ? useLayoutEffect : useEffect;\nexport {\n  useSafeLayoutEffect\n};\n","// src/index.ts\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useSafeLayoutEffect } from \"@nextui-org/use-safe-layout-effect\";\nfunction useImage(props = {}) {\n  const { loading, src, srcSet, onLoad, onError, crossOrigin, sizes, ignoreFallback } = props;\n  const [status, setStatus] = useState(\"pending\");\n  useEffect(() => {\n    setStatus(src ? \"loading\" : \"pending\");\n  }, [src]);\n  const imageRef = useRef();\n  const load = useCallback(() => {\n    if (!src)\n      return;\n    flush();\n    const img = new Image();\n    img.src = src;\n    if (crossOrigin)\n      img.crossOrigin = crossOrigin;\n    if (srcSet)\n      img.srcset = srcSet;\n    if (sizes)\n      img.sizes = sizes;\n    if (loading)\n      img.loading = loading;\n    img.onload = (event) => {\n      flush();\n      setStatus(\"loaded\");\n      onLoad == null ? void 0 : onLoad(event);\n    };\n    img.onerror = (error) => {\n      flush();\n      setStatus(\"failed\");\n      onError == null ? void 0 : onError(error);\n    };\n    imageRef.current = img;\n  }, [src, crossOrigin, srcSet, sizes, onLoad, onError, loading]);\n  const flush = () => {\n    if (imageRef.current) {\n      imageRef.current.onload = null;\n      imageRef.current.onerror = null;\n      imageRef.current = null;\n    }\n  };\n  useSafeLayoutEffect(() => {\n    if (ignoreFallback)\n      return void 0;\n    if (status === \"loading\") {\n      load();\n    }\n    return () => {\n      flush();\n    };\n  }, [status, load, ignoreFallback]);\n  return ignoreFallback ? \"loaded\" : status;\n}\nvar shouldShowFallbackImage = (status, fallbackStrategy) => status !== \"loaded\" && fallbackStrategy === \"beforeLoadOrError\" || status === \"failed\" && fallbackStrategy === \"onError\";\nexport {\n  shouldShowFallbackImage,\n  useImage\n};\n","\"use client\";\n\n// src/use-image.ts\nimport { useCallback } from \"react\";\nimport {\n  mapPropsVariants,\n  useProviderContext\n} from \"@nextui-org/system\";\nimport { image } from \"@nextui-org/theme\";\nimport { useDOMRef } from \"@nextui-org/react-utils\";\nimport { clsx, dataAttr, objectToDeps } from \"@nextui-org/shared-utils\";\nimport { useImage as useImageBase } from \"@nextui-org/use-image\";\nimport { useMemo } from \"react\";\nfunction useImage(originalProps) {\n  var _a, _b;\n  const globalContext = useProviderContext();\n  const [props, variantProps] = mapPropsVariants(originalProps, image.variantKeys);\n  const {\n    ref,\n    as,\n    src,\n    className,\n    classNames,\n    loading,\n    isBlurred,\n    fallbackSrc,\n    isLoading: isLoadingProp,\n    disableSkeleton = !!fallbackSrc,\n    removeWrapper = false,\n    onError,\n    onLoad,\n    srcSet,\n    sizes,\n    crossOrigin,\n    ...otherProps\n  } = props;\n  const imageStatus = useImageBase({\n    src,\n    loading,\n    onError,\n    onLoad,\n    ignoreFallback: false,\n    srcSet,\n    sizes,\n    crossOrigin\n  });\n  const disableAnimation = (_b = (_a = originalProps.disableAnimation) != null ? _a : globalContext == null ? void 0 : globalContext.disableAnimation) != null ? _b : false;\n  const isImgLoaded = imageStatus === \"loaded\" && !isLoadingProp;\n  const isLoading = imageStatus === \"loading\" || isLoadingProp;\n  const isZoomed = originalProps.isZoomed;\n  const Component = as || \"img\";\n  const domRef = useDOMRef(ref);\n  const { w, h } = useMemo(() => {\n    return {\n      w: props.width ? typeof props.width === \"number\" ? `${props.width}px` : props.width : \"fit-content\",\n      h: props.height ? typeof props.height === \"number\" ? `${props.height}px` : props.height : \"auto\"\n    };\n  }, [props == null ? void 0 : props.width, props == null ? void 0 : props.height]);\n  const showFallback = (!src || !isImgLoaded) && !!fallbackSrc;\n  const showSkeleton = isLoading && !disableSkeleton;\n  const slots = useMemo(\n    () => image({\n      ...variantProps,\n      disableAnimation,\n      showSkeleton\n    }),\n    [objectToDeps(variantProps), disableAnimation, showSkeleton]\n  );\n  const baseStyles = clsx(className, classNames == null ? void 0 : classNames.img);\n  const getImgProps = (props2 = {}) => {\n    const imgStyles = clsx(baseStyles, props2 == null ? void 0 : props2.className);\n    return {\n      src,\n      ref: domRef,\n      \"data-loaded\": dataAttr(isImgLoaded),\n      className: slots.img({ class: imgStyles }),\n      loading,\n      srcSet,\n      sizes,\n      crossOrigin,\n      ...otherProps,\n      style: {\n        ...(otherProps == null ? void 0 : otherProps.height) && { height: h },\n        ...props2.style,\n        ...otherProps.style\n      }\n    };\n  };\n  const getWrapperProps = useCallback(() => {\n    const fallbackStyle = showFallback ? {\n      backgroundImage: `url(${fallbackSrc})`\n    } : {};\n    return {\n      className: slots.wrapper({ class: classNames == null ? void 0 : classNames.wrapper }),\n      style: {\n        ...fallbackStyle,\n        maxWidth: w\n      }\n    };\n  }, [slots, showFallback, fallbackSrc, classNames == null ? void 0 : classNames.wrapper]);\n  const getBlurredImgProps = useCallback(() => {\n    return {\n      src,\n      \"aria-hidden\": dataAttr(true),\n      className: slots.blurredImg({ class: classNames == null ? void 0 : classNames.blurredImg })\n    };\n  }, [slots, src, classNames == null ? void 0 : classNames.blurredImg]);\n  return {\n    Component,\n    domRef,\n    slots,\n    classNames,\n    isBlurred,\n    disableSkeleton,\n    fallbackSrc,\n    removeWrapper,\n    isZoomed,\n    isLoading,\n    getImgProps,\n    getWrapperProps,\n    getBlurredImgProps\n  };\n}\n\nexport {\n  useImage\n};\n","\"use client\";\nimport {\n  useImage\n} from \"./chunk-AJLGONGP.mjs\";\n\n// src/image.tsx\nimport { cloneElement } from \"react\";\nimport { forwardRef } from \"@nextui-org/system\";\nimport { jsx, jsxs } from \"react/jsx-runtime\";\nvar Image = forwardRef((props, ref) => {\n  const {\n    Component,\n    domRef,\n    slots,\n    classNames,\n    isBlurred,\n    isZoomed,\n    fallbackSrc,\n    removeWrapper,\n    disableSkeleton,\n    getImgProps,\n    getWrapperProps,\n    getBlurredImgProps\n  } = useImage({\n    ...props,\n    ref\n  });\n  const img = /* @__PURE__ */ jsx(Component, { ref: domRef, ...getImgProps() });\n  if (removeWrapper) {\n    return img;\n  }\n  const zoomed = /* @__PURE__ */ jsx(\"div\", { className: slots.zoomedWrapper({ class: classNames == null ? void 0 : classNames.zoomedWrapper }), children: img });\n  if (isBlurred) {\n    return /* @__PURE__ */ jsxs(\"div\", { ...getWrapperProps(), children: [\n      isZoomed ? zoomed : img,\n      cloneElement(img, getBlurredImgProps())\n    ] });\n  }\n  if (isZoomed || !disableSkeleton || fallbackSrc) {\n    return /* @__PURE__ */ jsxs(\"div\", { ...getWrapperProps(), children: [\n      \" \",\n      isZoomed ? zoomed : img\n    ] });\n  }\n  return img;\n});\nImage.displayName = \"NextUI.Image\";\nvar image_default = Image;\n\nexport {\n  image_default\n};\n","\"use client\";\nimport {\n  image_default\n} from \"./chunk-NK4BRF7C.mjs\";\nimport {\n  useImage\n} from \"./chunk-AJLGONGP.mjs\";\nexport {\n  image_default as Image,\n  useImage\n};\n","\"use client\";\nimport {\n  LinkIcon\n} from \"./chunk-7LH7ZARU.mjs\";\nimport {\n  link_default\n} from \"./chunk-4HJHOVVR.mjs\";\nimport {\n  useLink\n} from \"./chunk-UUF4FQYI.mjs\";\nexport {\n  link_default as Link,\n  LinkIcon,\n  useLink\n};\n","// src/clsx.ts\nfunction toVal(mix) {\n  var k, y, str = \"\";\n  if (typeof mix === \"string\" || typeof mix === \"number\") {\n    str += mix;\n  } else if (typeof mix === \"object\") {\n    if (Array.isArray(mix)) {\n      for (k = 0; k < mix.length; k++) {\n        if (mix[k]) {\n          if (y = toVal(mix[k])) {\n            str && (str += \" \");\n            str += y;\n          }\n        }\n      }\n    } else {\n      for (k in mix) {\n        if (mix[k]) {\n          str && (str += \" \");\n          str += k;\n        }\n      }\n    }\n  }\n  return str;\n}\nfunction clsx(...args) {\n  var i = 0, tmp, x, str = \"\";\n  while (i < args.length) {\n    if (tmp = args[i++]) {\n      if (x = toVal(tmp)) {\n        str && (str += \" \");\n        str += x;\n      }\n    }\n  }\n  return str;\n}\n\nexport {\n  clsx\n};\n","import {\n  tv\n} from \"./chunk-GMMETTYU.mjs\";\nimport {\n  dataFocusVisibleClasses\n} from \"./chunk-XHQUSKIE.mjs\";\n\n// src/components/breadcrumbs.ts\nvar breadcrumbItem = tv({\n  slots: {\n    base: \"flex items-center\",\n    item: [\n      \"flex gap-1 items-center\",\n      \"cursor-pointer\",\n      \"whitespace-nowrap\",\n      \"line-clamp-1\",\n      \"outline-none\",\n      \"tap-highlight-transparent\",\n      ...dataFocusVisibleClasses\n    ],\n    separator: \"text-default-400 px-1\"\n  },\n  variants: {\n    color: {\n      foreground: {\n        item: \"text-foreground/50\",\n        separator: \"text-foreground/50\"\n      },\n      primary: {\n        item: \"text-primary/80\",\n        separator: \"text-primary/80\"\n      },\n      secondary: {\n        item: \"text-secondary/80\",\n        separator: \"text-secondary/80\"\n      },\n      success: {\n        item: \"text-success/80\",\n        separator: \"text-success/80\"\n      },\n      warning: {\n        item: \"text-warning/80\",\n        separator: \"text-warning/80\"\n      },\n      danger: {\n        item: \"text-danger/80\",\n        separator: \"text-danger/80\"\n      }\n    },\n    size: {\n      sm: {\n        item: \"text-tiny\"\n      },\n      md: {\n        item: \"text-small\"\n      },\n      lg: {\n        item: \"text-medium\"\n      }\n    },\n    underline: {\n      none: {\n        item: \"no-underline\"\n      },\n      hover: {\n        item: \"hover:underline\"\n      },\n      always: {\n        item: \"underline\"\n      },\n      active: {\n        item: \"active:underline\"\n      },\n      focus: {\n        item: \"focus:underline\"\n      }\n    },\n    isCurrent: {\n      true: {\n        item: \"cursor-default\"\n      },\n      false: {\n        item: [\"hover:opacity-80\", \"active:opacity-disabled\"]\n      }\n    },\n    isDisabled: {\n      true: {\n        item: \"opacity-disabled pointer-events-none\",\n        separator: \"opacity-disabled\"\n      }\n    },\n    disableAnimation: {\n      false: {\n        item: \"transition-opacity\"\n      },\n      true: {\n        item: \"transition-none\"\n      }\n    }\n  },\n  defaultVariants: {\n    size: \"md\",\n    color: \"foreground\",\n    underline: \"hover\",\n    isDisabled: false,\n    disableAnimation: false\n  },\n  compoundVariants: [\n    {\n      isCurrent: true,\n      color: \"foreground\",\n      class: {\n        item: \"text-foreground\"\n      }\n    },\n    {\n      isCurrent: true,\n      color: \"primary\",\n      class: {\n        item: \"text-primary\"\n      }\n    },\n    {\n      isCurrent: true,\n      color: \"secondary\",\n      class: {\n        item: \"text-secondary\"\n      }\n    },\n    {\n      isCurrent: true,\n      color: \"success\",\n      class: {\n        item: \"text-success\"\n      }\n    },\n    {\n      isCurrent: true,\n      color: \"warning\",\n      class: {\n        item: \"text-warning\"\n      }\n    },\n    {\n      isCurrent: true,\n      color: \"danger\",\n      class: {\n        item: \"text-danger\"\n      }\n    },\n    {\n      isCurrent: false,\n      underline: \"none\",\n      class: {\n        item: \"no-underline\"\n      }\n    },\n    {\n      underline: [\"hover\", \"always\", \"active\", \"focus\"],\n      class: \"underline-offset-4\"\n    }\n  ]\n});\nvar breadcrumbs = tv({\n  slots: {\n    base: \"\",\n    list: \"flex flex-wrap list-none\",\n    ellipsis: \"text-medium\",\n    separator: \"text-default-400 px-1\"\n  },\n  variants: {\n    size: {\n      sm: {},\n      md: {},\n      lg: {}\n    },\n    radius: {\n      none: {\n        list: \"rounded-none\"\n      },\n      sm: {\n        list: \"rounded-small\"\n      },\n      md: {\n        list: \"rounded-medium\"\n      },\n      lg: {\n        list: \"rounded-large\"\n      },\n      full: {\n        list: \"rounded-full\"\n      }\n    },\n    variant: {\n      solid: {\n        list: \"bg-default-100\"\n      },\n      bordered: {\n        list: \"border-medium border-default-200 shadow-sm\"\n      },\n      light: {}\n    }\n  },\n  defaultVariants: {\n    size: \"md\",\n    radius: \"sm\",\n    variant: \"light\"\n  },\n  compoundVariants: [\n    {\n      variant: [\"solid\", \"bordered\"],\n      class: {\n        list: \"max-w-fit\"\n      }\n    },\n    {\n      variant: [\"solid\", \"bordered\"],\n      size: \"sm\",\n      class: {\n        list: \"px-2 py-1\"\n      }\n    },\n    {\n      variant: [\"solid\", \"bordered\"],\n      size: \"md\",\n      class: {\n        list: \"px-2.5 py-1.5\"\n      }\n    },\n    {\n      variant: [\"solid\", \"bordered\"],\n      size: \"lg\",\n      class: {\n        list: \"px-3 py-2\"\n      }\n    }\n  ]\n});\n\nexport {\n  breadcrumbItem,\n  breadcrumbs\n};\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // https://en.wikipedia.org/wiki/Right-to-left\nconst $148a7a147e38ea7f$var$RTL_SCRIPTS = new Set([\n    'Arab',\n    'Syrc',\n    'Samr',\n    'Mand',\n    'Thaa',\n    'Mend',\n    'Nkoo',\n    'Adlm',\n    'Rohg',\n    'Hebr'\n]);\nconst $148a7a147e38ea7f$var$RTL_LANGS = new Set([\n    'ae',\n    'ar',\n    'arc',\n    'bcc',\n    'bqi',\n    'ckb',\n    'dv',\n    'fa',\n    'glk',\n    'he',\n    'ku',\n    'mzn',\n    'nqo',\n    'pnb',\n    'ps',\n    'sd',\n    'ug',\n    'ur',\n    'yi'\n]);\nfunction $148a7a147e38ea7f$export$702d680b21cbd764(localeString) {\n    // If the Intl.Locale API is available, use it to get the locale's text direction.\n    // @ts-ignore\n    if (Intl.Locale) {\n        let locale = new Intl.Locale(localeString).maximize();\n        // Use the text info object to get the direction if possible.\n        // @ts-ignore - this was implemented as a property by some browsers before it was standardized as a function.\n        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getTextInfo\n        let textInfo = typeof locale.getTextInfo === 'function' ? locale.getTextInfo() : locale.textInfo;\n        if (textInfo) return textInfo.direction === 'rtl';\n        // Fallback: guess using the script.\n        // This is more accurate than guessing by language, since languages can be written in multiple scripts.\n        if (locale.script) return $148a7a147e38ea7f$var$RTL_SCRIPTS.has(locale.script);\n    }\n    // If not, just guess by the language (first part of the locale)\n    let lang = localeString.split('-')[0];\n    return $148a7a147e38ea7f$var$RTL_LANGS.has(lang);\n}\n\n\nexport {$148a7a147e38ea7f$export$702d680b21cbd764 as isRTL};\n//# sourceMappingURL=utils.module.js.map\n","import {isRTL as $148a7a147e38ea7f$export$702d680b21cbd764} from \"./utils.mjs\";\nimport {useState as $ffhGL$useState, useEffect as $ffhGL$useEffect} from \"react\";\nimport {useIsSSR as $ffhGL$useIsSSR} from \"@react-aria/ssr\";\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\n// Locale passed from server by PackageLocalizationProvider.\nconst $1e5a04cdaf7d1af8$var$localeSymbol = Symbol.for('react-aria.i18n.locale');\nfunction $1e5a04cdaf7d1af8$export$f09106e7c6677ec5() {\n    let locale = typeof window !== 'undefined' && window[$1e5a04cdaf7d1af8$var$localeSymbol] || typeof navigator !== 'undefined' && (navigator.language || navigator.userLanguage) || 'en-US';\n    try {\n        // @ts-ignore\n        Intl.DateTimeFormat.supportedLocalesOf([\n            locale\n        ]);\n    } catch (_err) {\n        locale = 'en-US';\n    }\n    return {\n        locale: locale,\n        direction: (0, $148a7a147e38ea7f$export$702d680b21cbd764)(locale) ? 'rtl' : 'ltr'\n    };\n}\nlet $1e5a04cdaf7d1af8$var$currentLocale = $1e5a04cdaf7d1af8$export$f09106e7c6677ec5();\nlet $1e5a04cdaf7d1af8$var$listeners = new Set();\nfunction $1e5a04cdaf7d1af8$var$updateLocale() {\n    $1e5a04cdaf7d1af8$var$currentLocale = $1e5a04cdaf7d1af8$export$f09106e7c6677ec5();\n    for (let listener of $1e5a04cdaf7d1af8$var$listeners)listener($1e5a04cdaf7d1af8$var$currentLocale);\n}\nfunction $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a() {\n    let isSSR = (0, $ffhGL$useIsSSR)();\n    let [defaultLocale, setDefaultLocale] = (0, $ffhGL$useState)($1e5a04cdaf7d1af8$var$currentLocale);\n    (0, $ffhGL$useEffect)(()=>{\n        if ($1e5a04cdaf7d1af8$var$listeners.size === 0) window.addEventListener('languagechange', $1e5a04cdaf7d1af8$var$updateLocale);\n        $1e5a04cdaf7d1af8$var$listeners.add(setDefaultLocale);\n        return ()=>{\n            $1e5a04cdaf7d1af8$var$listeners.delete(setDefaultLocale);\n            if ($1e5a04cdaf7d1af8$var$listeners.size === 0) window.removeEventListener('languagechange', $1e5a04cdaf7d1af8$var$updateLocale);\n        };\n    }, []);\n    // We cannot determine the browser's language on the server, so default to\n    // en-US. This will be updated after hydration on the client to the correct value.\n    if (isSSR) return {\n        locale: 'en-US',\n        direction: 'ltr'\n    };\n    return defaultLocale;\n}\n\n\nexport {$1e5a04cdaf7d1af8$export$f09106e7c6677ec5 as getDefaultLocale, $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a as useDefaultLocale};\n//# sourceMappingURL=useDefaultLocale.module.js.map\n","import {isRTL as $148a7a147e38ea7f$export$702d680b21cbd764} from \"./utils.mjs\";\nimport {useDefaultLocale as $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a} from \"./useDefaultLocale.mjs\";\nimport $h9FiU$react, {useContext as $h9FiU$useContext} from \"react\";\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\nconst $18f2051aff69b9bf$var$I18nContext = /*#__PURE__*/ (0, $h9FiU$react).createContext(null);\nfunction $18f2051aff69b9bf$export$a54013f0d02a8f82(props) {\n    let { locale: locale, children: children } = props;\n    let defaultLocale = (0, $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a)();\n    let value = (0, $h9FiU$react).useMemo(()=>{\n        if (!locale) return defaultLocale;\n        return {\n            locale: locale,\n            direction: (0, $148a7a147e38ea7f$export$702d680b21cbd764)(locale) ? 'rtl' : 'ltr'\n        };\n    }, [\n        defaultLocale,\n        locale\n    ]);\n    return /*#__PURE__*/ (0, $h9FiU$react).createElement($18f2051aff69b9bf$var$I18nContext.Provider, {\n        value: value\n    }, children);\n}\nfunction $18f2051aff69b9bf$export$43bb16f9c6d9e3f7() {\n    let defaultLocale = (0, $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a)();\n    let context = (0, $h9FiU$useContext)($18f2051aff69b9bf$var$I18nContext);\n    return context || defaultLocale;\n}\n\n\nexport {$18f2051aff69b9bf$export$a54013f0d02a8f82 as I18nProvider, $18f2051aff69b9bf$export$43bb16f9c6d9e3f7 as useLocale};\n//# sourceMappingURL=context.module.js.map\n","import $670gB$react, {useContext as $670gB$useContext, useState as $670gB$useState, useMemo as $670gB$useMemo, useLayoutEffect as $670gB$useLayoutEffect, useRef as $670gB$useRef} from \"react\";\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // We must avoid a circular dependency with @react-aria/utils, and this useLayoutEffect is\n// guarded by a check that it only runs on the client side.\n// eslint-disable-next-line rulesdir/useLayoutEffectRule\n\n// Default context value to use in case there is no SSRProvider. This is fine for\n// client-only apps. In order to support multiple copies of React Aria potentially\n// being on the page at once, the prefix is set to a random number. SSRProvider\n// will reset this to zero for consistency between server and client, so in the\n// SSR case multiple copies of React Aria is not supported.\nconst $b5e257d569688ac6$var$defaultContext = {\n    prefix: String(Math.round(Math.random() * 10000000000)),\n    current: 0\n};\nconst $b5e257d569688ac6$var$SSRContext = /*#__PURE__*/ (0, $670gB$react).createContext($b5e257d569688ac6$var$defaultContext);\nconst $b5e257d569688ac6$var$IsSSRContext = /*#__PURE__*/ (0, $670gB$react).createContext(false);\n// This is only used in React < 18.\nfunction $b5e257d569688ac6$var$LegacySSRProvider(props) {\n    let cur = (0, $670gB$useContext)($b5e257d569688ac6$var$SSRContext);\n    let counter = $b5e257d569688ac6$var$useCounter(cur === $b5e257d569688ac6$var$defaultContext);\n    let [isSSR, setIsSSR] = (0, $670gB$useState)(true);\n    let value = (0, $670gB$useMemo)(()=>({\n            // If this is the first SSRProvider, start with an empty string prefix, otherwise\n            // append and increment the counter.\n            prefix: cur === $b5e257d569688ac6$var$defaultContext ? '' : `${cur.prefix}-${counter}`,\n            current: 0\n        }), [\n        cur,\n        counter\n    ]);\n    // If on the client, and the component was initially server rendered,\n    // then schedule a layout effect to update the component after hydration.\n    if (typeof document !== 'undefined') // This if statement technically breaks the rules of hooks, but is safe\n    // because the condition never changes after mounting.\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    (0, $670gB$useLayoutEffect)(()=>{\n        setIsSSR(false);\n    }, []);\n    return /*#__PURE__*/ (0, $670gB$react).createElement($b5e257d569688ac6$var$SSRContext.Provider, {\n        value: value\n    }, /*#__PURE__*/ (0, $670gB$react).createElement($b5e257d569688ac6$var$IsSSRContext.Provider, {\n        value: isSSR\n    }, props.children));\n}\nlet $b5e257d569688ac6$var$warnedAboutSSRProvider = false;\nfunction $b5e257d569688ac6$export$9f8ac96af4b1b2ae(props) {\n    if (typeof (0, $670gB$react)['useId'] === 'function') {\n        if (process.env.NODE_ENV !== 'test' && !$b5e257d569688ac6$var$warnedAboutSSRProvider) {\n            console.warn('In React 18, SSRProvider is not necessary and is a noop. You can remove it from your app.');\n            $b5e257d569688ac6$var$warnedAboutSSRProvider = true;\n        }\n        return /*#__PURE__*/ (0, $670gB$react).createElement((0, $670gB$react).Fragment, null, props.children);\n    }\n    return /*#__PURE__*/ (0, $670gB$react).createElement($b5e257d569688ac6$var$LegacySSRProvider, props);\n}\nlet $b5e257d569688ac6$var$canUseDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);\nlet $b5e257d569688ac6$var$componentIds = new WeakMap();\nfunction $b5e257d569688ac6$var$useCounter(isDisabled = false) {\n    let ctx = (0, $670gB$useContext)($b5e257d569688ac6$var$SSRContext);\n    let ref = (0, $670gB$useRef)(null);\n    // eslint-disable-next-line rulesdir/pure-render\n    if (ref.current === null && !isDisabled) {\n        var _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner, _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n        // In strict mode, React renders components twice, and the ref will be reset to null on the second render.\n        // This means our id counter will be incremented twice instead of once. This is a problem because on the\n        // server, components are only rendered once and so ids generated on the server won't match the client.\n        // In React 18, useId was introduced to solve this, but it is not available in older versions. So to solve this\n        // we need to use some React internals to access the underlying Fiber instance, which is stable between renders.\n        // This is exposed as ReactCurrentOwner in development, which is all we need since StrictMode only runs in development.\n        // To ensure that we only increment the global counter once, we store the starting id for this component in\n        // a weak map associated with the Fiber. On the second render, we reset the global counter to this value.\n        // Since React runs the second render immediately after the first, this is safe.\n        // @ts-ignore\n        let currentOwner = (_React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = (0, $670gB$react).__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED === void 0 ? void 0 : (_React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner = _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner) === null || _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner === void 0 ? void 0 : _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner.current;\n        if (currentOwner) {\n            let prevComponentValue = $b5e257d569688ac6$var$componentIds.get(currentOwner);\n            if (prevComponentValue == null) // On the first render, and first call to useId, store the id and state in our weak map.\n            $b5e257d569688ac6$var$componentIds.set(currentOwner, {\n                id: ctx.current,\n                state: currentOwner.memoizedState\n            });\n            else if (currentOwner.memoizedState !== prevComponentValue.state) {\n                // On the second render, the memoizedState gets reset by React.\n                // Reset the counter, and remove from the weak map so we don't\n                // do this for subsequent useId calls.\n                ctx.current = prevComponentValue.id;\n                $b5e257d569688ac6$var$componentIds.delete(currentOwner);\n            }\n        }\n        // eslint-disable-next-line rulesdir/pure-render\n        ref.current = ++ctx.current;\n    }\n    // eslint-disable-next-line rulesdir/pure-render\n    return ref.current;\n}\nfunction $b5e257d569688ac6$var$useLegacySSRSafeId(defaultId) {\n    let ctx = (0, $670gB$useContext)($b5e257d569688ac6$var$SSRContext);\n    // If we are rendering in a non-DOM environment, and there's no SSRProvider,\n    // provide a warning to hint to the developer to add one.\n    if (ctx === $b5e257d569688ac6$var$defaultContext && !$b5e257d569688ac6$var$canUseDOM) console.warn('When server rendering, you must wrap your application in an <SSRProvider> to ensure consistent ids are generated between the client and server.');\n    let counter = $b5e257d569688ac6$var$useCounter(!!defaultId);\n    let prefix = ctx === $b5e257d569688ac6$var$defaultContext && process.env.NODE_ENV === 'test' ? 'react-aria' : `react-aria${ctx.prefix}`;\n    return defaultId || `${prefix}-${counter}`;\n}\nfunction $b5e257d569688ac6$var$useModernSSRSafeId(defaultId) {\n    // @ts-ignore\n    let id = (0, $670gB$react).useId();\n    let [didSSR] = (0, $670gB$useState)($b5e257d569688ac6$export$535bd6ca7f90a273());\n    let prefix = didSSR || process.env.NODE_ENV === 'test' ? 'react-aria' : `react-aria${$b5e257d569688ac6$var$defaultContext.prefix}`;\n    return defaultId || `${prefix}-${id}`;\n}\nconst $b5e257d569688ac6$export$619500959fc48b26 = typeof (0, $670gB$react)['useId'] === 'function' ? $b5e257d569688ac6$var$useModernSSRSafeId : $b5e257d569688ac6$var$useLegacySSRSafeId;\nfunction $b5e257d569688ac6$var$getSnapshot() {\n    return false;\n}\nfunction $b5e257d569688ac6$var$getServerSnapshot() {\n    return true;\n}\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction $b5e257d569688ac6$var$subscribe(onStoreChange) {\n    // noop\n    return ()=>{};\n}\nfunction $b5e257d569688ac6$export$535bd6ca7f90a273() {\n    // In React 18, we can use useSyncExternalStore to detect if we're server rendering or hydrating.\n    if (typeof (0, $670gB$react)['useSyncExternalStore'] === 'function') return (0, $670gB$react)['useSyncExternalStore']($b5e257d569688ac6$var$subscribe, $b5e257d569688ac6$var$getSnapshot, $b5e257d569688ac6$var$getServerSnapshot);\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return (0, $670gB$useContext)($b5e257d569688ac6$var$IsSSRContext);\n}\n\n\nexport {$b5e257d569688ac6$export$9f8ac96af4b1b2ae as SSRProvider, $b5e257d569688ac6$export$535bd6ca7f90a273 as useIsSSR, $b5e257d569688ac6$export$619500959fc48b26 as useSSRSafeId};\n//# sourceMappingURL=SSRProvider.module.js.map\n","export const VOID       = -1;\nexport const PRIMITIVE  = 0;\nexport const ARRAY      = 1;\nexport const OBJECT     = 2;\nexport const DATE       = 3;\nexport const REGEXP     = 4;\nexport const MAP        = 5;\nexport const SET        = 6;\nexport const ERROR      = 7;\nexport const BIGINT     = 8;\n// export const SYMBOL = 9;\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst env = typeof self === 'object' ? self : globalThis;\n\nconst deserializer = ($, _) => {\n  const as = (out, index) => {\n    $.set(index, out);\n    return out;\n  };\n\n  const unpair = index => {\n    if ($.has(index))\n      return $.get(index);\n\n    const [type, value] = _[index];\n    switch (type) {\n      case PRIMITIVE:\n      case VOID:\n        return as(value, index);\n      case ARRAY: {\n        const arr = as([], index);\n        for (const index of value)\n          arr.push(unpair(index));\n        return arr;\n      }\n      case OBJECT: {\n        const object = as({}, index);\n        for (const [key, index] of value)\n          object[unpair(key)] = unpair(index);\n        return object;\n      }\n      case DATE:\n        return as(new Date(value), index);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as(new RegExp(source, flags), index);\n      }\n      case MAP: {\n        const map = as(new Map, index);\n        for (const [key, index] of value)\n          map.set(unpair(key), unpair(index));\n        return map;\n      }\n      case SET: {\n        const set = as(new Set, index);\n        for (const index of value)\n          set.add(unpair(index));\n        return set;\n      }\n      case ERROR: {\n        const {name, message} = value;\n        return as(new env[name](message), index);\n      }\n      case BIGINT:\n        return as(BigInt(value), index);\n      case 'BigInt':\n        return as(Object(BigInt(value)), index);\n    }\n    return as(new env[type](value), index);\n  };\n\n  return unpair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns a deserialized value from a serialized array of Records.\n * @param {Record[]} serialized a previously serialized value.\n * @returns {any}\n */\nexport const deserialize = serialized => deserializer(new Map, serialized)(0);\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst EMPTY = '';\n\nconst {toString} = {};\nconst {keys} = Object;\n\nconst typeOf = value => {\n  const type = typeof value;\n  if (type !== 'object' || !value)\n    return [PRIMITIVE, type];\n\n  const asString = toString.call(value).slice(8, -1);\n  switch (asString) {\n    case 'Array':\n      return [ARRAY, EMPTY];\n    case 'Object':\n      return [OBJECT, EMPTY];\n    case 'Date':\n      return [DATE, EMPTY];\n    case 'RegExp':\n      return [REGEXP, EMPTY];\n    case 'Map':\n      return [MAP, EMPTY];\n    case 'Set':\n      return [SET, EMPTY];\n  }\n\n  if (asString.includes('Array'))\n    return [ARRAY, asString];\n\n  if (asString.includes('Error'))\n    return [ERROR, asString];\n\n  return [OBJECT, asString];\n};\n\nconst shouldSkip = ([TYPE, type]) => (\n  TYPE === PRIMITIVE &&\n  (type === 'function' || type === 'symbol')\n);\n\nconst serializer = (strict, json, $, _) => {\n\n  const as = (out, value) => {\n    const index = _.push(out) - 1;\n    $.set(value, index);\n    return index;\n  };\n\n  const pair = value => {\n    if ($.has(value))\n      return $.get(value);\n\n    let [TYPE, type] = typeOf(value);\n    switch (TYPE) {\n      case PRIMITIVE: {\n        let entry = value;\n        switch (type) {\n          case 'bigint':\n            TYPE = BIGINT;\n            entry = value.toString();\n            break;\n          case 'function':\n          case 'symbol':\n            if (strict)\n              throw new TypeError('unable to serialize ' + type);\n            entry = null;\n            break;\n          case 'undefined':\n            return as([VOID], value);\n        }\n        return as([TYPE, entry], value);\n      }\n      case ARRAY: {\n        if (type)\n          return as([type, [...value]], value);\n  \n        const arr = [];\n        const index = as([TYPE, arr], value);\n        for (const entry of value)\n          arr.push(pair(entry));\n        return index;\n      }\n      case OBJECT: {\n        if (type) {\n          switch (type) {\n            case 'BigInt':\n              return as([type, value.toString()], value);\n            case 'Boolean':\n            case 'Number':\n            case 'String':\n              return as([type, value.valueOf()], value);\n          }\n        }\n\n        if (json && ('toJSON' in value))\n          return pair(value.toJSON());\n\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const key of keys(value)) {\n          if (strict || !shouldSkip(typeOf(value[key])))\n            entries.push([pair(key), pair(value[key])]);\n        }\n        return index;\n      }\n      case DATE:\n        return as([TYPE, value.toISOString()], value);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as([TYPE, {source, flags}], value);\n      }\n      case MAP: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const [key, entry] of value) {\n          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))\n            entries.push([pair(key), pair(entry)]);\n        }\n        return index;\n      }\n      case SET: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const entry of value) {\n          if (strict || !shouldSkip(typeOf(entry)))\n            entries.push(pair(entry));\n        }\n        return index;\n      }\n    }\n\n    const {message} = value;\n    return as([TYPE, {name: type, message}], value);\n  };\n\n  return pair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} value a serializable value.\n * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n *  if `true`, will not throw errors on incompatible types, and behave more\n *  like JSON stringify would behave. Symbol and Function will be discarded.\n * @returns {Record[]}\n */\n export const serialize = (value, {json, lossy} = {}) => {\n  const _ = [];\n  return serializer(!(json || lossy), !!json, new Map, _)(value), _;\n};\n","import {deserialize} from './deserialize.js';\nimport {serialize} from './serialize.js';\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} any a serializable value.\n * @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n * a transfer option (ignored when polyfilled) and/or non standard fields that\n * fallback to the polyfill if present.\n * @returns {Record[]}\n */\nexport default typeof structuredClone === \"function\" ?\n  /* c8 ignore start */\n  (any, options) => (\n    options && ('json' in options || 'lossy' in options) ?\n      deserialize(serialize(any, options)) : structuredClone(any)\n  ) :\n  (any, options) => deserialize(serialize(any, options));\n  /* c8 ignore stop */\n\nexport {deserialize, serialize};\n","/**\n * @typedef Options\n *   Configuration for `stringify`.\n * @property {boolean} [padLeft=true]\n *   Whether to pad a space before a token.\n * @property {boolean} [padRight=false]\n *   Whether to pad a space after a token.\n */\n\n/**\n * @typedef {Options} StringifyOptions\n *   Please use `StringifyOptions` instead.\n */\n\n/**\n * Parse comma-separated tokens to an array.\n *\n * @param {string} value\n *   Comma-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  /** @type {Array<string>} */\n  const tokens = []\n  const input = String(value || '')\n  let index = input.indexOf(',')\n  let start = 0\n  /** @type {boolean} */\n  let end = false\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    const 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 or numbers to comma-separated tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @param {Options} [options]\n *   Configuration for `stringify` (optional).\n * @returns {string}\n *   Comma-separated tokens.\n */\nexport function stringify(values, options) {\n  const settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  const input = values[values.length - 1] === '' ? [...values, ''] : values\n\n  return input\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n","export function deprecate(fn) {\n  return fn\n}\n\nexport function equal() {}\n\nexport function ok() {}\n\nexport function unreachable() {}\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').Nodes} Nodes\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Text} Text\n * @typedef {import('unist-util-visit-parents').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef RegExpMatchObject\n *   Info on the match.\n * @property {number} index\n *   The index of the search at which the result was found.\n * @property {string} input\n *   A copy of the search string in the text node.\n * @property {[...Array<Parents>, Text]} stack\n *   All ancestors of the text node, where the last node is the text itself.\n *\n * @typedef {RegExp | string} Find\n *   Pattern to find.\n *\n *   Strings are escaped and then turned into global expressions.\n *\n * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList\n *   Several find and replaces, in array form.\n *\n * @typedef {[Find, Replace?]} FindAndReplaceTuple\n *   Find and replace in tuple form.\n *\n * @typedef {ReplaceFunction | string | null | undefined} Replace\n *   Thing to replace with.\n *\n * @callback ReplaceFunction\n *   Callback called when a search matches.\n * @param {...any} parameters\n *   The parameters are the result of corresponding search expression:\n *\n *   * `value` (`string`) — whole match\n *   * `...capture` (`Array<string>`) — matches from regex capture groups\n *   * `match` (`RegExpMatchObject`) — info on the match\n * @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}\n *   Thing to replace with.\n *\n *   * when `null`, `undefined`, `''`, remove the match\n *   * …or when `false`, do not replace at all\n *   * …or when `string`, replace with a text node of that value\n *   * …or when `Node` or `Array<Node>`, replace with those nodes\n *\n * @typedef {[RegExp, ReplaceFunction]} Pair\n *   Normalized find and replace.\n *\n * @typedef {Array<Pair>} Pairs\n *   All find and replaced.\n *\n * @typedef Options\n *   Configuration.\n * @property {Test | null | undefined} [ignore]\n *   Test for which nodes to ignore (optional).\n */\n\nimport escape from 'escape-string-regexp'\nimport {visitParents} from 'unist-util-visit-parents'\nimport {convert} from 'unist-util-is'\n\n/**\n * Find patterns in a tree and replace them.\n *\n * The algorithm searches the tree in *preorder* for complete values in `Text`\n * nodes.\n * Partial matches are not supported.\n *\n * @param {Nodes} tree\n *   Tree to change.\n * @param {FindAndReplaceList | FindAndReplaceTuple} list\n *   Patterns to find.\n * @param {Options | null | undefined} [options]\n *   Configuration (when `find` is not `Find`).\n * @returns {undefined}\n *   Nothing.\n */\nexport function findAndReplace(tree, list, options) {\n  const settings = options || {}\n  const ignored = convert(settings.ignore || [])\n  const pairs = toPairs(list)\n  let pairIndex = -1\n\n  while (++pairIndex < pairs.length) {\n    visitParents(tree, 'text', visitor)\n  }\n\n  /** @type {import('unist-util-visit-parents').BuildVisitor<Root, 'text'>} */\n  function visitor(node, parents) {\n    let index = -1\n    /** @type {Parents | undefined} */\n    let grandparent\n\n    while (++index < parents.length) {\n      const parent = parents[index]\n      /** @type {Array<Nodes> | undefined} */\n      const siblings = grandparent ? grandparent.children : undefined\n\n      if (\n        ignored(\n          parent,\n          siblings ? siblings.indexOf(parent) : undefined,\n          grandparent\n        )\n      ) {\n        return\n      }\n\n      grandparent = parent\n    }\n\n    if (grandparent) {\n      return handler(node, parents)\n    }\n  }\n\n  /**\n   * Handle a text node which is not in an ignored parent.\n   *\n   * @param {Text} node\n   *   Text node.\n   * @param {Array<Parents>} parents\n   *   Parents.\n   * @returns {VisitorResult}\n   *   Result.\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    /** @type {Array<Nodes>} */\n    const siblings = parent.children\n    const index = siblings.indexOf(node)\n    let change = false\n    /** @type {Array<PhrasingContent>} */\n    let nodes = []\n\n    find.lastIndex = 0\n\n    let match = find.exec(node.value)\n\n    while (match) {\n      const 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      // It wasn’t a match after all.\n      if (value === false) {\n        // False acts as if there was no match.\n        // So we need to reset `lastIndex`, which currently being at the end of\n        // the current match, to the beginning.\n        find.lastIndex = position + 1\n      } else {\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 * Turn a tuple or a list of tuples into pairs.\n *\n * @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList\n *   Schema.\n * @returns {Pairs}\n *   Clean pairs.\n */\nfunction toPairs(tupleOrList) {\n  /** @type {Pairs} */\n  const result = []\n\n  if (!Array.isArray(tupleOrList)) {\n    throw new TypeError('Expected find and replace tuple or list of tuples')\n  }\n\n  /** @type {FindAndReplaceList} */\n  // @ts-expect-error: correct.\n  const list =\n    !tupleOrList[0] || Array.isArray(tupleOrList[0])\n      ? tupleOrList\n      : [tupleOrList]\n\n  let index = -1\n\n  while (++index < list.length) {\n    const tuple = list[index]\n    result.push([toExpression(tuple[0]), toFunction(tuple[1])])\n  }\n\n  return result\n}\n\n/**\n * Turn a find into an expression.\n *\n * @param {Find} find\n *   Find.\n * @returns {RegExp}\n *   Expression.\n */\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find\n}\n\n/**\n * Turn a replace into a function.\n *\n * @param {Replace} replace\n *   Replace.\n * @returns {ReplaceFunction}\n *   Function.\n */\nfunction toFunction(replace) {\n  return typeof replace === 'function'\n    ? replace\n    : function () {\n        return replace\n      }\n}\n","/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownSpace} from 'micromark-util-character'\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\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\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n    return ok(code)\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\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 * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\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 * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\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 * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\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 *   Code.\n * @returns {boolean}\n *   Whether it matches.\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/**\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 * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\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 * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\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 * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\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 *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\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 *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\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 *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\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 * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\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 * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\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 *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {Array<unknown>} */\n  let parameters\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n  remove = remove > 0 ? remove : 0\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove)\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters)\n      chunkStart += 10000\n      start += 10000\n    }\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 *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * 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**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Handles} Handles\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {Array<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   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\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\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/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n * @param {Array<unknown>} list\n * @returns {undefined}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<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 multiple HTML extensions into one.\n *\n * @param {Array<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   A single combined HTML 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\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\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 {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value\n      // Collapse markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ')\n      // Trim.\n      .replace(/^ | $/g, '')\n      // 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').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {Array<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<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('./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    blocking: spaceSeparated,\n    capture: null,\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    fetchPriority: 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    inert: boolean,\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    onBeforeMatch: null,\n    onBeforePrint: null,\n    onBeforeToggle: 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    onScrollEnd: 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    popover: null,\n    popoverTarget: null,\n    popoverTargetAction: null,\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    shadowRootClonable: boolean,\n    shadowRootDelegatesFocus: boolean,\n    shadowRootMode: null,\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    writingSuggestions: 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    transformOrigin: 'transform-origin',\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    transformOrigin: 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 * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [jsx=false]\n *   Support JSX identifiers (default: `false`).\n */\n\nconst startRe = /[$_\\p{ID_Start}]/u\nconst contRe = /[$_\\u{200C}\\u{200D}\\p{ID_Continue}]/u\nconst contReJsx = /[-$_\\u{200C}\\u{200D}\\p{ID_Continue}]/u\nconst nameRe = /^[$_\\p{ID_Start}][$_\\u{200C}\\u{200D}\\p{ID_Continue}]*$/u\nconst nameReJsx = /^[$_\\p{ID_Start}][-$_\\u{200C}\\u{200D}\\p{ID_Continue}]*$/u\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Checks if the given code point can start an identifier.\n *\n * @param {number | undefined} code\n *   Code point to check.\n * @returns {boolean}\n *   Whether `code` can start an identifier.\n */\n// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.\nexport function start(code) {\n  return code ? startRe.test(String.fromCodePoint(code)) : false\n}\n\n/**\n * Checks if the given code point can continue an identifier.\n *\n * @param {number | undefined} code\n *   Code point to check.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {boolean}\n *   Whether `code` can continue an identifier.\n */\n// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.\nexport function cont(code, options) {\n  const settings = options || emptyOptions\n  const re = settings.jsx ? contReJsx : contRe\n  return code ? re.test(String.fromCodePoint(code)) : false\n}\n\n/**\n * Checks if the given value is a valid identifier name.\n *\n * @param {string} name\n *   Identifier to check.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {boolean}\n *   Whether `name` can be an identifier.\n */\nexport function name(name, options) {\n  const settings = options || emptyOptions\n  const re = settings.jsx ? nameReJsx : nameRe\n  return re.test(name)\n}\n","/**\n * @typedef {import('hast').Nodes} Nodes\n */\n\n// HTML whitespace expression.\n// See <https://infra.spec.whatwg.org/#ascii-whitespace>.\nconst re = /[ \\t\\n\\f\\r]/g\n\n/**\n * Check if the given value is *inter-element whitespace*.\n *\n * @param {Nodes | string} thing\n *   Thing to check (`Node` or `string`).\n * @returns {boolean}\n *   Whether the `value` is inter-element whitespace (`boolean`): consisting of\n *   zero or more of space, tab (`\\t`), line feed (`\\n`), carriage return\n *   (`\\r`), or form feed (`\\f`); if a node is passed it must be a `Text` node,\n *   whose `value` field is checked.\n */\nexport function whitespace(thing) {\n  return typeof thing === 'object'\n    ? thing.type === 'text'\n      ? empty(thing.value)\n      : false\n    : empty(thing)\n}\n\n/**\n * @param {string} value\n * @returns {boolean}\n */\nfunction empty(value) {\n  return value.replace(re, '') === ''\n}\n","/**\n * `hast` is close to `React`, but differs in a couple of cases.\n *\n * To get a React property from a hast property, check if it is in\n * `hastToReact`, if it is, then use the corresponding value,\n * otherwise, use the hast property.\n *\n * @type {Record<string, string>}\n */\nexport 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","import StyleToObject from '../cjs/index.js';\n\n// ensure compatibility with rollup umd build\nexport default StyleToObject.default || StyleToObject;\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value]\n *   Node, position, or point.\n * @returns {string}\n *   Pretty printed positional info of a node (`string`).\n *\n *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n *   column, `s` for `start`, and `e` for end.\n *   An empty string (`''`) is returned if the given value is neither `node`,\n *   `position`, nor `point`.\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 | PointLike | null | 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 | PositionLike | null | 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 | null | 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').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef Options\n *   Configuration.\n * @property {Array<Node> | null | undefined} [ancestors]\n *   Stack of (inclusive) ancestor nodes surrounding the message (optional).\n * @property {Error | null | undefined} [cause]\n *   Original error cause of the message (optional).\n * @property {Point | Position | null | undefined} [place]\n *   Place of message (optional).\n * @property {string | null | undefined} [ruleId]\n *   Category of message (optional, example: `'my-rule'`).\n * @property {string | null | undefined} [source]\n *   Namespace of who sent the message (optional, example: `'my-package'`).\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n  /**\n   * Create a message for `reason`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Options | null | undefined} [options]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns\n   *   Instance of `VFileMessage`.\n   */\n  // eslint-disable-next-line complexity\n  constructor(causeOrReason, optionsOrParentOrPlace, origin) {\n    super()\n\n    if (typeof optionsOrParentOrPlace === 'string') {\n      origin = optionsOrParentOrPlace\n      optionsOrParentOrPlace = undefined\n    }\n\n    /** @type {string} */\n    let reason = ''\n    /** @type {Options} */\n    let options = {}\n    let legacyCause = false\n\n    if (optionsOrParentOrPlace) {\n      // Point.\n      if (\n        'line' in optionsOrParentOrPlace &&\n        'column' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Position.\n      else if (\n        'start' in optionsOrParentOrPlace &&\n        'end' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Node.\n      else if ('type' in optionsOrParentOrPlace) {\n        options = {\n          ancestors: [optionsOrParentOrPlace],\n          place: optionsOrParentOrPlace.position\n        }\n      }\n      // Options.\n      else {\n        options = {...optionsOrParentOrPlace}\n      }\n    }\n\n    if (typeof causeOrReason === 'string') {\n      reason = causeOrReason\n    }\n    // Error.\n    else if (!options.cause && causeOrReason) {\n      legacyCause = true\n      reason = causeOrReason.message\n      options.cause = causeOrReason\n    }\n\n    if (!options.ruleId && !options.source && typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        options.ruleId = origin\n      } else {\n        options.source = origin.slice(0, index)\n        options.ruleId = origin.slice(index + 1)\n      }\n    }\n\n    if (!options.place && options.ancestors && options.ancestors) {\n      const parent = options.ancestors[options.ancestors.length - 1]\n\n      if (parent) {\n        options.place = parent.position\n      }\n    }\n\n    const start =\n      options.place && 'start' in options.place\n        ? options.place.start\n        : options.place\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * Stack of ancestor nodes surrounding the message.\n     *\n     * @type {Array<Node> | undefined}\n     */\n    this.ancestors = options.ancestors || undefined\n\n    /**\n     * Original error cause of the message.\n     *\n     * @type {Error | undefined}\n     */\n    this.cause = options.cause || undefined\n\n    /**\n     * Starting column of message.\n     *\n     * @type {number | undefined}\n     */\n    this.column = start ? start.column : undefined\n\n    /**\n     * State of problem.\n     *\n     * * `true` — error, file not usable\n     * * `false` — warning, change may be needed\n     * * `undefined` — change likely not needed\n     *\n     * @type {boolean | null | undefined}\n     */\n    this.fatal = undefined\n\n    /**\n     * Path of a file (used throughout the `VFile` ecosystem).\n     *\n     * @type {string | undefined}\n     */\n    this.file\n\n    // Field from `Error`.\n    /**\n     * Reason for message.\n     *\n     * @type {string}\n     */\n    this.message = reason\n\n    /**\n     * Starting line of error.\n     *\n     * @type {number | undefined}\n     */\n    this.line = start ? start.line : undefined\n\n    // Field from `Error`.\n    /**\n     * Serialized positional info of message.\n     *\n     * On normal errors, this would be something like `ParseError`, buit in\n     * `VFile` messages we use this space to show where an error happened.\n     */\n    this.name = stringifyPosition(options.place) || '1:1'\n\n    /**\n     * Place of message.\n     *\n     * @type {Point | Position | undefined}\n     */\n    this.place = options.place || undefined\n\n    /**\n     * Reason for message, should use markdown.\n     *\n     * @type {string}\n     */\n    this.reason = this.message\n\n    /**\n     * Category of message (example: `'my-rule'`).\n     *\n     * @type {string | undefined}\n     */\n    this.ruleId = options.ruleId || undefined\n\n    /**\n     * Namespace of message (example: `'my-package'`).\n     *\n     * @type {string | undefined}\n     */\n    this.source = options.source || undefined\n\n    // Field from `Error`.\n    /**\n     * Stack of message.\n     *\n     * This is used by normal errors to show where something happened in\n     * programming code, irrelevant for `VFile` messages,\n     *\n     * @type {string}\n     */\n    this.stack =\n      legacyCause && options.cause && typeof options.cause.stack === 'string'\n        ? options.cause.stack\n        : ''\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    /**\n     * Specify the source value that’s being reported, which is deemed\n     * incorrect.\n     *\n     * @type {string | undefined}\n     */\n    this.actual\n\n    /**\n     * Suggest acceptable values that can be used instead of `actual`.\n     *\n     * @type {Array<string> | undefined}\n     */\n    this.expected\n\n    /**\n     * Long form description of the message (you should use markdown).\n     *\n     * @type {string | undefined}\n     */\n    this.note\n\n    /**\n     * Link to docs for the message.\n     *\n     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n     * > to `new URL(x)`.\n     *\n     * @type {string | undefined}\n     */\n    this.url\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.column = undefined\nVFileMessage.prototype.line = undefined\nVFileMessage.prototype.ancestors = undefined\nVFileMessage.prototype.cause = undefined\nVFileMessage.prototype.fatal = undefined\nVFileMessage.prototype.place = undefined\nVFileMessage.prototype.ruleId = undefined\nVFileMessage.prototype.source = undefined\n","// Register MDX nodes in mdast:\n/// <reference types=\"mdast-util-mdx-expression\" />\n/// <reference types=\"mdast-util-mdx-jsx\" />\n/// <reference types=\"mdast-util-mdxjs-esm\" />\n\n/**\n * @typedef {import('estree').Identifier} Identifier\n * @typedef {import('estree').Literal} Literal\n * @typedef {import('estree').MemberExpression} MemberExpression\n * @typedef {import('estree').Expression} Expression\n * @typedef {import('estree').Program} Program\n *\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Parents} Parents\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n *\n * @typedef {import('mdast-util-mdx-expression').MdxFlowExpressionHast} MdxFlowExpression\n * @typedef {import('mdast-util-mdx-expression').MdxTextExpressionHast} MdxTextExpression\n *\n * @typedef {import('mdast-util-mdx-jsx').MdxJsxFlowElementHast} MdxJsxFlowElement\n * @typedef {import('mdast-util-mdx-jsx').MdxJsxTextElementHast} MdxJsxTextElement\n *\n * @typedef {import('mdast-util-mdxjs-esm').MdxjsEsmHast} MdxjsEsm\n *\n * @typedef {import('property-information').Schema} Schema\n *\n * @typedef {import('unist').Position} Position\n *\n * @typedef {import('./components.js').Components} Components\n */\n\n/**\n * @typedef {JSX.Element | string | null | undefined} Child\n *   Child.\n *\n * @callback Create\n *   Create something in development or production.\n * @param {Nodes} node\n *   hast node.\n * @param {unknown} type\n *   Fragment symbol or tag name.\n * @param {Props} props\n *   Properties and children.\n * @param {string | undefined} key\n *   Key.\n * @returns {JSX.Element}\n *   Result.\n *\n * @callback CreateEvaluater\n *   Create an evaluator that turns ESTree ASTs from embedded MDX into values.\n * @returns {Evaluater}\n *   Evaluater.\n *\n * @typedef {'html' | 'react'} ElementAttributeNameCase\n *   Casing to use for attribute names.\n *\n *   HTML casing is for example `class`, `stroke-linecap`, `xml:lang`.\n *   React casing is for example `className`, `strokeLinecap`, `xmlLang`.\n *\n * @callback EvaluateExpression\n *   Turn an MDX expression into a value.\n * @param {Expression} expression\n *   ESTree expression.\n * @returns {unknown}\n *   Result of expression.\n *\n * @callback EvaluateProgram\n *   Turn an MDX program (export/import statements) into a value.\n * @param {Program} expression\n *   ESTree program.\n * @returns {unknown}\n *   Result of program;\n *   should likely be `undefined` as ESM changes the scope but doesn’t yield\n *   something.\n *\n * @typedef Evaluater\n *   Evaluator that turns ESTree ASTs from embedded MDX into values.\n * @property {EvaluateExpression} evaluateExpression\n *   Evaluate an expression.\n * @property {EvaluateProgram} evaluateProgram\n *   Evaluate a program.\n *\n * @typedef {[string, Value]} Field\n *   Property field.\n *\n * @typedef {unknown} Fragment\n *   Represent the children, typically a symbol.\n *\n * @callback Jsx\n *   Create a production element.\n * @param {unknown} type\n *   Element type: `Fragment` symbol, tag name (`string`), component.\n * @param {Props} props\n *   Element props, `children`, and maybe `node`.\n * @param {string | undefined} [key]\n *   Dynamicly generated key to use.\n * @returns {JSX.Element}\n *   Element from your framework.\n *\n * @callback JsxDev\n *   Create a development element.\n * @param {unknown} type\n *   Element type: `Fragment` symbol, tag name (`string`), component.\n * @param {Props} props\n *   Element props, `children`, and maybe `node`.\n * @param {string | undefined} key\n *   Dynamicly generated key to use.\n * @param {boolean} isStaticChildren\n *   Whether two or more children are passed (in an array), which is whether\n *   `jsxs` or `jsx` would be used.\n * @param {Source} source\n *   Info about source.\n * @param {undefined} self\n *   Nothing (this is used by frameworks that have components, we don’t).\n * @returns {JSX.Element}\n *   Element from your framework.\n *\n * @typedef {{children?: Array<Child> | Child, node?: Element | MdxJsxFlowElement | MdxJsxTextElement | undefined, [prop: string]: Array<Child> | Child | Element | MdxJsxFlowElement | MdxJsxTextElement | Value | undefined}} Props\n *   Properties and children.\n *\n * @typedef RegularFields\n *   Configuration.\n * @property {Partial<Components> | null | undefined} [components]\n *   Components to use (optional).\n * @property {CreateEvaluater | null | undefined} [createEvaluater]\n *   Create an evaluator that turns ESTree ASTs into values (optional).\n * @property {ElementAttributeNameCase | null | undefined} [elementAttributeNameCase='react']\n *   Specify casing to use for attribute names (default: `'react'`).\n * @property {string | null | undefined} [filePath]\n *   File path to the original source file (optional).\n *\n *   Passed in source info to `jsxDEV` when using the automatic runtime with\n *   `development: true`.\n * @property {boolean | null | undefined} [ignoreInvalidStyle=false]\n *   Ignore invalid CSS in `style` props (default: `false`);\n *   the default behavior is to throw an error.\n * @property {boolean | null | undefined} [passKeys=true]\n *   Generate keys to optimize frameworks that support them (default: `true`).\n *\n *   > 👉 **Note**: Solid currently fails if keys are passed.\n * @property {boolean | null | undefined} [passNode=false]\n *   Pass the hast element node to components (default: `false`).\n * @property {Space | null | undefined} [space='html']\n *   Whether `tree` is in the `'html'` or `'svg'` space (default: `'html'`).\n *\n *   When an `<svg>` element is found in the HTML space, this package already\n *   automatically switches to and from the SVG space when entering and exiting\n *   it.\n * @property {StylePropertyNameCase | null | undefined} [stylePropertyNameCase='dom']\n *   Specify casing to use for property names in `style` objects (default:\n *   `'dom'`).\n * @property {boolean | null | undefined} [tableCellAlignToStyle=true]\n *   Turn obsolete `align` props on `td` and `th` into CSS `style` props\n *   (default: `true`).\n *\n * @typedef RuntimeDevelopment\n *   Runtime fields when development is on.\n * @property {Fragment} Fragment\n *   Fragment.\n * @property {true} development\n *   Whether to use `jsxDEV` (when on) or `jsx` and `jsxs` (when off).\n * @property {Jsx | null | undefined} [jsx]\n *   Dynamic JSX (optional).\n * @property {JsxDev} jsxDEV\n *   Development JSX.\n * @property {Jsx | null | undefined} [jsxs]\n *   Static JSX (optional).\n *\n * @typedef RuntimeProduction\n *   Runtime fields when development is off.\n * @property {Fragment} Fragment\n *   Fragment.\n * @property {false | null | undefined} [development]\n *   Whether to use `jsxDEV` (when on) or `jsx` and `jsxs` (when off) (optional).\n * @property {Jsx} jsx\n *   Dynamic JSX.\n * @property {JsxDev | null | undefined} [jsxDEV]\n *   Development JSX (optional).\n * @property {Jsx} jsxs\n *   Static JSX.\n *\n * @typedef RuntimeUnknown\n *   Runtime fields when development might be on or off.\n * @property {Fragment} Fragment\n *   Fragment.\n * @property {boolean} development\n *   Whether to use `jsxDEV` (when on) or `jsx` and `jsxs` (when off).\n * @property {Jsx | null | undefined} [jsx]\n *   Dynamic JSX (optional).\n * @property {JsxDev | null | undefined} [jsxDEV]\n *   Development JSX (optional).\n * @property {Jsx | null | undefined} [jsxs]\n *   Static JSX (optional).\n *\n * @typedef Source\n *   Info about source.\n * @property {number | undefined} columnNumber\n *   Column where thing starts (0-indexed).\n * @property {string | undefined} fileName\n *   Name of source file.\n * @property {number | undefined} lineNumber\n *   Line where thing starts (1-indexed).\n *\n * @typedef {'html' | 'svg'} Space\n *   Namespace.\n *\n *   > 👉 **Note**: hast is not XML.\n *   > It supports SVG as embedded in HTML.\n *   > It does not support the features available in XML.\n *   > Passing SVG might break but fragments of modern SVG should be fine.\n *   > Use `xast` if you need to support SVG as XML.\n *\n * @typedef State\n *   Info passed around.\n * @property {unknown} Fragment\n *   Fragment symbol.\n * @property {Array<Parents>} ancestors\n *   Stack of parents.\n * @property {Partial<Components>} components\n *   Components to swap.\n * @property {Create} create\n *   Create something in development or production.\n * @property {ElementAttributeNameCase} elementAttributeNameCase\n *   Casing to use for attribute names.\n * @property {Evaluater | undefined} evaluater\n *   Evaluator that turns ESTree ASTs into values.\n * @property {string | undefined} filePath\n *   File path.\n * @property {boolean} ignoreInvalidStyle\n *   Ignore invalid CSS in `style` props.\n * @property {boolean} passKeys\n *   Generate keys to optimize frameworks that support them.\n * @property {boolean} passNode\n *   Pass `node` to components.\n * @property {Schema} schema\n *   Current schema.\n * @property {StylePropertyNameCase} stylePropertyNameCase\n *   Casing to use for property names in `style` objects.\n * @property {boolean} tableCellAlignToStyle\n *   Turn obsolete `align` props on `td` and `th` into CSS `style` props.\n *\n * @typedef {Record<string, string>} Style\n *   Style map.\n *\n * @typedef {'css' | 'dom'} StylePropertyNameCase\n *   Casing to use for property names in `style` objects.\n *\n *   CSS casing is for example `background-color` and `-webkit-line-clamp`.\n *   DOM casing is for example `backgroundColor` and `WebkitLineClamp`.\n *\n * @typedef {Style | boolean | number | string} Value\n *   Primitive property value and `Style` map.\n */\n\n/**\n * @typedef {RuntimeDevelopment & RegularFields} Development\n *   Configuration (development).\n * @typedef {Development | Production | Unknown} Options\n *   Configuration.\n * @typedef {RegularFields & RuntimeProduction} Production\n *   Configuration (production).\n * @typedef {RegularFields & RuntimeUnknown} Unknown\n *   Configuration (production or development).\n */\n\nimport {stringify as commas} from 'comma-separated-tokens'\nimport {ok as assert} from 'devlop'\nimport {name as isIdentifierName} from 'estree-util-is-identifier-name'\nimport {whitespace} from 'hast-util-whitespace'\nimport {find, hastToReact, html, svg} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport styleToObject from 'style-to-object'\nimport {pointStart} from 'unist-util-position'\nimport {VFileMessage} from 'vfile-message'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Map<string, number>} */\nconst emptyMap = new Map()\n\nconst cap = /[A-Z]/g\nconst dashSomething = /-([a-z])/g\n\n// `react-dom` triggers a warning for *any* white space in tables.\n// To follow GFM, `mdast-util-to-hast` injects line endings between elements.\n// Other tools might do so too, but they don’t do here, so we remove all of\n// that.\n\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/rehypejs/rehype-react/pull/29>.\n// See: <https://github.com/rehypejs/rehype-react/pull/32>.\n// See: <https://github.com/rehypejs/rehype-react/pull/45>.\nconst tableElements = new Set(['table', 'tbody', 'thead', 'tfoot', 'tr'])\n\nconst tableCellElement = new Set(['td', 'th'])\n\nconst docs = 'https://github.com/syntax-tree/hast-util-to-jsx-runtime'\n\n/**\n * Transform a hast tree to preact, react, solid, svelte, vue, etc.,\n * with an automatic JSX runtime.\n *\n * @param {Nodes} tree\n *   Tree to transform.\n * @param {Options} options\n *   Configuration (required).\n * @returns {JSX.Element}\n *   JSX element.\n */\n\nexport function toJsxRuntime(tree, options) {\n  if (!options || options.Fragment === undefined) {\n    throw new TypeError('Expected `Fragment` in options')\n  }\n\n  const filePath = options.filePath || undefined\n  /** @type {Create} */\n  let create\n\n  if (options.development) {\n    if (typeof options.jsxDEV !== 'function') {\n      throw new TypeError(\n        'Expected `jsxDEV` in options when `development: true`'\n      )\n    }\n\n    create = developmentCreate(filePath, options.jsxDEV)\n  } else {\n    if (typeof options.jsx !== 'function') {\n      throw new TypeError('Expected `jsx` in production options')\n    }\n\n    if (typeof options.jsxs !== 'function') {\n      throw new TypeError('Expected `jsxs` in production options')\n    }\n\n    create = productionCreate(filePath, options.jsx, options.jsxs)\n  }\n\n  /** @type {State} */\n  const state = {\n    Fragment: options.Fragment,\n    ancestors: [],\n    components: options.components || {},\n    create,\n    elementAttributeNameCase: options.elementAttributeNameCase || 'react',\n    evaluater: options.createEvaluater ? options.createEvaluater() : undefined,\n    filePath,\n    ignoreInvalidStyle: options.ignoreInvalidStyle || false,\n    passKeys: options.passKeys !== false,\n    passNode: options.passNode || false,\n    schema: options.space === 'svg' ? svg : html,\n    stylePropertyNameCase: options.stylePropertyNameCase || 'dom',\n    tableCellAlignToStyle: options.tableCellAlignToStyle !== false\n  }\n\n  const result = one(state, tree, undefined)\n\n  // JSX element.\n  if (result && typeof result !== 'string') {\n    return result\n  }\n\n  // Text node or something that turned into nothing.\n  return state.create(\n    tree,\n    state.Fragment,\n    {children: result || undefined},\n    undefined\n  )\n}\n\n/**\n * Transform a node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Nodes} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction one(state, node, key) {\n  if (node.type === 'element') {\n    return element(state, node, key)\n  }\n\n  if (node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression') {\n    return mdxExpression(state, node)\n  }\n\n  if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {\n    return mdxJsxElement(state, node, key)\n  }\n\n  if (node.type === 'mdxjsEsm') {\n    return mdxEsm(state, node)\n  }\n\n  if (node.type === 'root') {\n    return root(state, node, key)\n  }\n\n  if (node.type === 'text') {\n    return text(state, node)\n  }\n}\n\n/**\n * Handle element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Element} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction element(state, node, key) {\n  const parentSchema = state.schema\n  let schema = parentSchema\n\n  if (node.tagName.toLowerCase() === 'svg' && parentSchema.space === 'html') {\n    schema = svg\n    state.schema = schema\n  }\n\n  state.ancestors.push(node)\n\n  const type = findComponentFromName(state, node.tagName, false)\n  const props = createElementProps(state, node)\n  let children = createChildren(state, node)\n\n  if (tableElements.has(node.tagName)) {\n    children = children.filter(function (child) {\n      return typeof child === 'string' ? !whitespace(child) : true\n    })\n  }\n\n  addNode(state, props, type, node)\n  addChildren(props, children)\n\n  // Restore.\n  state.ancestors.pop()\n  state.schema = parentSchema\n\n  return state.create(node, type, props, key)\n}\n\n/**\n * Handle MDX expression.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxFlowExpression | MdxTextExpression} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxExpression(state, node) {\n  if (node.data && node.data.estree && state.evaluater) {\n    const program = node.data.estree\n    const expression = program.body[0]\n    assert(expression.type === 'ExpressionStatement')\n\n    // Assume result is a child.\n    return /** @type {Child | undefined} */ (\n      state.evaluater.evaluateExpression(expression.expression)\n    )\n  }\n\n  crashEstree(state, node.position)\n}\n\n/**\n * Handle MDX ESM.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxjsEsm} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxEsm(state, node) {\n  if (node.data && node.data.estree && state.evaluater) {\n    // Assume result is a child.\n    return /** @type {Child | undefined} */ (\n      state.evaluater.evaluateProgram(node.data.estree)\n    )\n  }\n\n  crashEstree(state, node.position)\n}\n\n/**\n * Handle MDX JSX.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxJsxFlowElement | MdxJsxTextElement} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxJsxElement(state, node, key) {\n  const parentSchema = state.schema\n  let schema = parentSchema\n\n  if (node.name === 'svg' && parentSchema.space === 'html') {\n    schema = svg\n    state.schema = schema\n  }\n\n  state.ancestors.push(node)\n\n  const type =\n    node.name === null\n      ? state.Fragment\n      : findComponentFromName(state, node.name, true)\n  const props = createJsxElementProps(state, node)\n  const children = createChildren(state, node)\n\n  addNode(state, props, type, node)\n  addChildren(props, children)\n\n  // Restore.\n  state.ancestors.pop()\n  state.schema = parentSchema\n\n  return state.create(node, type, props, key)\n}\n\n/**\n * Handle root.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Root} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction root(state, node, key) {\n  /** @type {Props} */\n  const props = {}\n\n  addChildren(props, createChildren(state, node))\n\n  return state.create(node, state.Fragment, props, key)\n}\n\n/**\n * Handle text.\n *\n * @param {State} _\n *   Info passed around.\n * @param {Text} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction text(_, node) {\n  return node.value\n}\n\n/**\n * Add `node` to props.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Props} props\n *   Props.\n * @param {unknown} type\n *   Type.\n * @param {Element | MdxJsxFlowElement | MdxJsxTextElement} node\n *   Node.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addNode(state, props, type, node) {\n  // If this is swapped out for a component:\n  if (typeof type !== 'string' && type !== state.Fragment && state.passNode) {\n    props.node = node\n  }\n}\n\n/**\n * Add children to props.\n *\n * @param {Props} props\n *   Props.\n * @param {Array<Child>} children\n *   Children.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addChildren(props, children) {\n  if (children.length > 0) {\n    const value = children.length > 1 ? children : children[0]\n\n    if (value) {\n      props.children = value\n    }\n  }\n}\n\n/**\n * @param {string | undefined} _\n *   Path to file.\n * @param {Jsx} jsx\n *   Dynamic.\n * @param {Jsx} jsxs\n *   Static.\n * @returns {Create}\n *   Create a production element.\n */\nfunction productionCreate(_, jsx, jsxs) {\n  return create\n  /** @type {Create} */\n  function create(_, type, props, key) {\n    // Only an array when there are 2 or more children.\n    const isStaticChildren = Array.isArray(props.children)\n    const fn = isStaticChildren ? jsxs : jsx\n    return key ? fn(type, props, key) : fn(type, props)\n  }\n}\n\n/**\n * @param {string | undefined} filePath\n *   Path to file.\n * @param {JsxDev} jsxDEV\n *   Development.\n * @returns {Create}\n *   Create a development element.\n */\nfunction developmentCreate(filePath, jsxDEV) {\n  return create\n  /** @type {Create} */\n  function create(node, type, props, key) {\n    // Only an array when there are 2 or more children.\n    const isStaticChildren = Array.isArray(props.children)\n    const point = pointStart(node)\n    return jsxDEV(\n      type,\n      props,\n      key,\n      isStaticChildren,\n      {\n        columnNumber: point ? point.column - 1 : undefined,\n        fileName: filePath,\n        lineNumber: point ? point.line : undefined\n      },\n      undefined\n    )\n  }\n}\n\n/**\n * Create props from an element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Element} node\n *   Current element.\n * @returns {Props}\n *   Props.\n */\nfunction createElementProps(state, node) {\n  /** @type {Props} */\n  const props = {}\n  /** @type {string | undefined} */\n  let alignValue\n  /** @type {string} */\n  let prop\n\n  for (prop in node.properties) {\n    if (prop !== 'children' && own.call(node.properties, prop)) {\n      const result = createProperty(state, prop, node.properties[prop])\n\n      if (result) {\n        const [key, value] = result\n\n        if (\n          state.tableCellAlignToStyle &&\n          key === 'align' &&\n          typeof value === 'string' &&\n          tableCellElement.has(node.tagName)\n        ) {\n          alignValue = value\n        } else {\n          props[key] = value\n        }\n      }\n    }\n  }\n\n  if (alignValue) {\n    // Assume style is an object.\n    const style = /** @type {Style} */ (props.style || (props.style = {}))\n    style[state.stylePropertyNameCase === 'css' ? 'text-align' : 'textAlign'] =\n      alignValue\n  }\n\n  return props\n}\n\n/**\n * Create props from a JSX element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxJsxFlowElement | MdxJsxTextElement} node\n *   Current JSX element.\n * @returns {Props}\n *   Props.\n */\nfunction createJsxElementProps(state, node) {\n  /** @type {Props} */\n  const props = {}\n\n  for (const attribute of node.attributes) {\n    if (attribute.type === 'mdxJsxExpressionAttribute') {\n      if (attribute.data && attribute.data.estree && state.evaluater) {\n        const program = attribute.data.estree\n        const expression = program.body[0]\n        assert(expression.type === 'ExpressionStatement')\n        const objectExpression = expression.expression\n        assert(objectExpression.type === 'ObjectExpression')\n        const property = objectExpression.properties[0]\n        assert(property.type === 'SpreadElement')\n\n        Object.assign(\n          props,\n          state.evaluater.evaluateExpression(property.argument)\n        )\n      } else {\n        crashEstree(state, node.position)\n      }\n    } else {\n      // For JSX, the author is responsible of passing in the correct values.\n      const name = attribute.name\n      /** @type {unknown} */\n      let value\n\n      if (attribute.value && typeof attribute.value === 'object') {\n        if (\n          attribute.value.data &&\n          attribute.value.data.estree &&\n          state.evaluater\n        ) {\n          const program = attribute.value.data.estree\n          const expression = program.body[0]\n          assert(expression.type === 'ExpressionStatement')\n          value = state.evaluater.evaluateExpression(expression.expression)\n        } else {\n          crashEstree(state, node.position)\n        }\n      } else {\n        value = attribute.value === null ? true : attribute.value\n      }\n\n      // Assume a prop.\n      props[name] = /** @type {Props[keyof Props]} */ (value)\n    }\n  }\n\n  return props\n}\n\n/**\n * Create children.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Parents} node\n *   Current element.\n * @returns {Array<Child>}\n *   Children.\n */\nfunction createChildren(state, node) {\n  /** @type {Array<Child>} */\n  const children = []\n  let index = -1\n  /** @type {Map<string, number>} */\n  // Note: test this when Solid doesn’t want to merge my upcoming PR.\n  /* c8 ignore next */\n  const countsByName = state.passKeys ? new Map() : emptyMap\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n    /** @type {string | undefined} */\n    let key\n\n    if (state.passKeys) {\n      const name =\n        child.type === 'element'\n          ? child.tagName\n          : child.type === 'mdxJsxFlowElement' ||\n              child.type === 'mdxJsxTextElement'\n            ? child.name\n            : undefined\n\n      if (name) {\n        const count = countsByName.get(name) || 0\n        key = name + '-' + count\n        countsByName.set(name, count + 1)\n      }\n    }\n\n    const result = one(state, child, key)\n    if (result !== undefined) children.push(result)\n  }\n\n  return children\n}\n\n/**\n * Handle a property.\n *\n * @param {State} state\n *   Info passed around.\n * @param {string} prop\n *   Key.\n * @param {Array<number | string> | boolean | number | string | null | undefined} value\n *   hast property value.\n * @returns {Field | undefined}\n *   Field for runtime, optional.\n */\nfunction createProperty(state, prop, value) {\n  const info = find(state.schema, prop)\n\n  // Ignore nullish and `NaN` values.\n  if (\n    value === null ||\n    value === undefined ||\n    (typeof value === 'number' && Number.isNaN(value))\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  // React only accepts `style` as object.\n  if (info.property === 'style') {\n    let styleObject =\n      typeof value === 'object' ? value : parseStyle(state, String(value))\n\n    if (state.stylePropertyNameCase === 'css') {\n      styleObject = transformStylesToCssCasing(styleObject)\n    }\n\n    return ['style', styleObject]\n  }\n\n  return [\n    state.elementAttributeNameCase === 'react' && info.space\n      ? hastToReact[info.property] || info.property\n      : info.attribute,\n    value\n  ]\n}\n\n/**\n * Parse a CSS declaration to an object.\n *\n * @param {State} state\n *   Info passed around.\n * @param {string} value\n *   CSS declarations.\n * @returns {Style}\n *   Properties.\n * @throws\n *   Throws `VFileMessage` when CSS cannot be parsed.\n */\nfunction parseStyle(state, value) {\n  /** @type {Style} */\n  const result = {}\n\n  try {\n    // @ts-expect-error: `style-to-object` types are broken.\n    styleToObject(value, replacer)\n  } catch (error) {\n    if (!state.ignoreInvalidStyle) {\n      const cause = /** @type {Error} */ (error)\n      const message = new VFileMessage('Cannot parse `style` attribute', {\n        ancestors: state.ancestors,\n        cause,\n        ruleId: 'style',\n        source: 'hast-util-to-jsx-runtime'\n      })\n      message.file = state.filePath || undefined\n      message.url = docs + '#cannot-parse-style-attribute'\n\n      throw message\n    }\n  }\n\n  return result\n\n  /**\n   * Add a CSS property (normal, so with dashes) to `result` as a DOM CSS\n   * property.\n   *\n   * @param {string} name\n   *   Key.\n   * @param {string} value\n   *   Value\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function replacer(name, value) {\n    let key = name\n\n    if (key.slice(0, 2) !== '--') {\n      if (key.slice(0, 4) === '-ms-') key = 'ms-' + key.slice(4)\n      key = key.replace(dashSomething, toCamel)\n    }\n\n    result[key] = value\n  }\n}\n\n/**\n * Create a JSX name from a string.\n *\n * @param {State} state\n *   To do.\n * @param {string} name\n *   Name.\n * @param {boolean} allowExpression\n *   Allow member expressions and identifiers.\n * @returns {unknown}\n *   To do.\n */\nfunction findComponentFromName(state, name, allowExpression) {\n  /** @type {Identifier | Literal | MemberExpression} */\n  let result\n\n  if (!allowExpression) {\n    result = {type: 'Literal', value: name}\n  } else if (name.includes('.')) {\n    const identifiers = name.split('.')\n    let index = -1\n    /** @type {Identifier | Literal | MemberExpression | undefined} */\n    let node\n\n    while (++index < identifiers.length) {\n      /** @type {Identifier | Literal} */\n      const prop = isIdentifierName(identifiers[index])\n        ? {type: 'Identifier', name: identifiers[index]}\n        : {type: 'Literal', value: identifiers[index]}\n      node = node\n        ? {\n            type: 'MemberExpression',\n            object: node,\n            property: prop,\n            computed: Boolean(index && prop.type === 'Literal'),\n            optional: false\n          }\n        : prop\n    }\n\n    assert(node, 'always a result')\n    result = node\n  } else {\n    result =\n      isIdentifierName(name) && !/^[a-z]/.test(name)\n        ? {type: 'Identifier', name}\n        : {type: 'Literal', value: name}\n  }\n\n  // Only literals can be passed in `components` currently.\n  // No identifiers / member expressions.\n  if (result.type === 'Literal') {\n    const name = /** @type {keyof JSX.IntrinsicElements} */ (result.value)\n\n    return own.call(state.components, name) ? state.components[name] : name\n  }\n\n  // Assume component.\n  if (state.evaluater) {\n    return state.evaluater.evaluateExpression(result)\n  }\n\n  crashEstree(state)\n}\n\n/**\n * @param {State} state\n * @param {Position | undefined} [place]\n * @returns {never}\n */\nfunction crashEstree(state, place) {\n  const message = new VFileMessage(\n    'Cannot handle MDX estrees without `createEvaluater`',\n    {\n      ancestors: state.ancestors,\n      place,\n      ruleId: 'mdx-estree',\n      source: 'hast-util-to-jsx-runtime'\n    }\n  )\n  message.file = state.filePath || undefined\n  message.url = docs + '#cannot-handle-mdx-estrees-without-createevaluater'\n\n  throw message\n}\n\n/**\n * Transform a DOM casing style object to a CSS casing style object.\n *\n * @param {Style} domCasing\n * @returns {Style}\n */\nfunction transformStylesToCssCasing(domCasing) {\n  /** @type {Style} */\n  const cssCasing = {}\n  /** @type {string} */\n  let from\n\n  for (from in domCasing) {\n    if (own.call(domCasing, from)) {\n      cssCasing[transformStyleToCssCasing(from)] = domCasing[from]\n    }\n  }\n\n  return cssCasing\n}\n\n/**\n * Transform a DOM casing style field to a CSS casing style field.\n *\n * @param {string} from\n * @returns {string}\n */\nfunction transformStyleToCssCasing(from) {\n  let to = from.replace(cap, toDash)\n  // Handle `ms-xxx` -> `-ms-xxx`.\n  if (to.slice(0, 3) === 'ms-') to = '-' + to\n  return to\n}\n\n/**\n * Make `$1` capitalized.\n *\n * @param {string} _\n *   Whatever.\n * @param {string} $1\n *   Single ASCII alphabetical.\n * @returns {string}\n *   Capitalized `$1`.\n */\nfunction toCamel(_, $1) {\n  return $1.toUpperCase()\n}\n\n/**\n * Make `$0` dash cased.\n *\n * @param {string} $0\n *   Capitalized ASCII leter.\n * @returns {string}\n *   Dash and lower letter.\n */\nfunction toDash($0) {\n  return '-' + $0.toLowerCase()\n}\n","/**\n * HTML URL properties.\n *\n * Each key is a property name and each value is a list of tag names it applies\n * to or `null` if it applies to all elements.\n *\n * @type {Record<string, Array<string> | null>}\n */\nexport const urlAttributes = {\n  action: ['form'],\n  cite: ['blockquote', 'del', 'ins', 'q'],\n  data: ['object'],\n  formAction: ['button', 'input'],\n  href: ['a', 'area', 'base', 'link'],\n  icon: ['menuitem'],\n  itemId: null,\n  manifest: ['html'],\n  ping: ['a', 'area'],\n  poster: ['video'],\n  src: [\n    'audio',\n    'embed',\n    'iframe',\n    'img',\n    'input',\n    'script',\n    'source',\n    'track',\n    'video'\n  ]\n}\n","/**\n * Some of the internal operations of micromark do lots of editing\n * operations on very large arrays. This runs into problems with two\n * properties of most circa-2020 JavaScript interpreters:\n *\n *  - Array-length modifications at the high end of an array (push/pop) are\n *    expected to be common and are implemented in (amortized) time\n *    proportional to the number of elements added or removed, whereas\n *    other operations (shift/unshift and splice) are much less efficient.\n *  - Function arguments are passed on the stack, so adding tens of thousands\n *    of elements to an array with `arr.push[...newElements]` will frequently\n *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)\n *\n * SpliceBuffers are an implementation of gap buffers, which are a\n * generalization of the \"queue made of two stacks\" idea. The splice buffer\n * maintains a cursor, and moving the cursor has cost proportional to the\n * distance the cursor moves, but inserting, deleting, or splicing in\n * new information at the cursor is as efficient as the push/pop operation.\n * This allows for an efficient sequence of splices (or pushes, pops, shifts,\n * or unshifts) as long such edits happen at the same part of the array or\n * generally sweep through the array from the beginning to the end.\n *\n * The interface for splice buffers also supports large numbers of inputs by\n * passing a single array argument rather passing multiple arguments on the\n * function call stack.\n *\n * @template T\n *   Item type.\n */\nexport class SpliceBuffer {\n  /**\n   * @param {ReadonlyArray<T> | null | undefined} [initial]\n   *   Initial items (optional).\n   * @returns\n   *   Splice buffer.\n   */\n  constructor(initial) {\n    /** @type {Array<T>} */\n    this.left = initial ? [...initial] : [];\n    /** @type {Array<T>} */\n    this.right = [];\n  }\n\n  /**\n   * Array access;\n   * does not move the cursor.\n   *\n   * @param {number} index\n   *   Index.\n   * @return {T}\n   *   Item.\n   */\n  get(index) {\n    if (index < 0 || index >= this.left.length + this.right.length) {\n      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');\n    }\n    if (index < this.left.length) return this.left[index];\n    return this.right[this.right.length - index + this.left.length - 1];\n  }\n\n  /**\n   * The length of the splice buffer, one greater than the largest index in the\n   * array.\n   */\n  get length() {\n    return this.left.length + this.right.length;\n  }\n\n  /**\n   * Remove and return `list[0]`;\n   * moves the cursor to `0`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  shift() {\n    this.setCursor(0);\n    return this.right.pop();\n  }\n\n  /**\n   * Slice the buffer to get an array;\n   * does not move the cursor.\n   *\n   * @param {number} start\n   *   Start.\n   * @param {number | null | undefined} [end]\n   *   End (optional).\n   * @returns {Array<T>}\n   *   Array of items.\n   */\n  slice(start, end) {\n    /** @type {number} */\n    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;\n    if (stop < this.left.length) {\n      return this.left.slice(start, stop);\n    }\n    if (start > this.left.length) {\n      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();\n    }\n    return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());\n  }\n\n  /**\n   * Mimics the behavior of Array.prototype.splice() except for the change of\n   * interface necessary to avoid segfaults when patching in very large arrays.\n   *\n   * This operation moves cursor is moved to `start` and results in the cursor\n   * placed after any inserted items.\n   *\n   * @param {number} start\n   *   Start;\n   *   zero-based index at which to start changing the array;\n   *   negative numbers count backwards from the end of the array and values\n   *   that are out-of bounds are clamped to the appropriate end of the array.\n   * @param {number | null | undefined} [deleteCount=0]\n   *   Delete count (default: `0`);\n   *   maximum number of elements to delete, starting from start.\n   * @param {Array<T> | null | undefined} [items=[]]\n   *   Items to include in place of the deleted items (default: `[]`).\n   * @return {Array<T>}\n   *   Any removed items.\n   */\n  splice(start, deleteCount, items) {\n    /** @type {number} */\n    const count = deleteCount || 0;\n    this.setCursor(Math.trunc(start));\n    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);\n    if (items) chunkedPush(this.left, items);\n    return removed.reverse();\n  }\n\n  /**\n   * Remove and return the highest-numbered item in the array, so\n   * `list[list.length - 1]`;\n   * Moves the cursor to `length`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  pop() {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    return this.left.pop();\n  }\n\n  /**\n   * Inserts a single item to the high-numbered side of the array;\n   * moves the cursor to `length`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  push(item) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    this.left.push(item);\n  }\n\n  /**\n   * Inserts many items to the high-numbered side of the array.\n   * Moves the cursor to `length`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  pushMany(items) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    chunkedPush(this.left, items);\n  }\n\n  /**\n   * Inserts a single item to the low-numbered side of the array;\n   * Moves the cursor to `0`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshift(item) {\n    this.setCursor(0);\n    this.right.push(item);\n  }\n\n  /**\n   * Inserts many items to the low-numbered side of the array;\n   * moves the cursor to `0`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshiftMany(items) {\n    this.setCursor(0);\n    chunkedPush(this.right, items.reverse());\n  }\n\n  /**\n   * Move the cursor to a specific position in the array. Requires\n   * time proportional to the distance moved.\n   *\n   * If `n < 0`, the cursor will end up at the beginning.\n   * If `n > length`, the cursor will end up at the end.\n   *\n   * @param {number} n\n   *   Position.\n   * @return {undefined}\n   *   Nothing.\n   */\n  setCursor(n) {\n    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;\n    if (n < this.left.length) {\n      // Move cursor to the this.left\n      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.right, removed.reverse());\n    } else {\n      // Move cursor to the this.right\n      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.left, removed.reverse());\n    }\n  }\n}\n\n/**\n * Avoid stack overflow by pushing items onto the stack in segments\n *\n * @template T\n *   Item type.\n * @param {Array<T>} list\n *   List to inject into.\n * @param {ReadonlyArray<T>} right\n *   Items to inject.\n * @return {undefined}\n *   Nothing.\n */\nfunction chunkedPush(list, right) {\n  /** @type {number} */\n  let chunkStart = 0;\n  if (right.length < 10000) {\n    list.push(...right);\n  } else {\n    while (chunkStart < right.length) {\n      list.push(...right.slice(chunkStart, chunkStart + 10000));\n      chunkStart += 10000;\n    }\n  }\n}","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { SpliceBuffer } from './lib/splice-buffer.js';\n\n// Hidden API exposed for testing.\nexport { SpliceBuffer } from './lib/splice-buffer.js';\n\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} eventsArray\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\n// eslint-disable-next-line complexity\nexport function subtokenize(eventsArray) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n  let event;\n  /** @type {number | undefined} */\n  let lineIndex;\n  /** @type {number} */\n  let otherIndex;\n  /** @type {Event} */\n  let otherEvent;\n  /** @type {Array<Event>} */\n  let parameters;\n  /** @type {Array<Event>} */\n  let subevents;\n  /** @type {boolean | undefined} */\n  let more;\n  const events = new SpliceBuffer(eventsArray);\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n    event = events.get(index);\n\n    // 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    if (index && event[1].type === \"chunkFlow\" && events.get(index - 1)[1].type === \"listItemPrefix\") {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"lineEndingBlank\") {\n        otherIndex += 2;\n      }\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"content\") {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === \"content\") {\n            break;\n          }\n          if (subevents[otherIndex][1].type === \"chunkText\") {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    }\n\n    // Enter.\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    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n      while (otherIndex--) {\n        otherEvent = events.get(otherIndex);\n        if (otherEvent[1].type === \"lineEnding\" || otherEvent[1].type === \"lineEndingBlank\") {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events.get(lineIndex)[1].type = \"lineEndingBlank\";\n            }\n            otherEvent[1].type = \"lineEnding\";\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events.get(lineIndex)[1].start);\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        events.splice(lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  // The changes to the `events` buffer must be copied back into the eventsArray\n  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));\n  return !more;\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {SpliceBuffer<Event>} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\nfunction subcontent(events, eventIndex) {\n  const token = events.get(eventIndex)[1];\n  const context = events.get(eventIndex)[2];\n  let startPosition = eventIndex - 1;\n  /** @type {Array<number>} */\n  const startPositions = [];\n  const tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  const childEvents = tokenizer.events;\n  /** @type {Array<[number, number]>} */\n  const jumps = [];\n  /** @type {Record<string, number>} */\n  const gaps = {};\n  /** @type {Array<Chunk>} */\n  let stream;\n  /** @type {Token | undefined} */\n  let previous;\n  let index = -1;\n  /** @type {Token | undefined} */\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start];\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events.get(++startPosition)[1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n      if (!current.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    }\n\n    // Unravel the next token.\n    previous = current;\n    current = current.next;\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token;\n  while (++index < childEvents.length) {\n    if (\n    // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start);\n      // Help GC.\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = [];\n\n  // 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  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  }\n\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  index = breaks.length;\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.push([start, start + slice.length - 1]);\n    events.splice(start, 2, slice);\n  }\n  jumps.reverse();\n  index = -1;\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  return gaps;\n}","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * @param {Array<Event>} events\n * @returns {Array<Event>}\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events\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 * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n}\n\n/**\n * @this {TokenizeContext}\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  let previous\n  return contentStart\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    })\n    if (previous) {\n      previous.next = token\n    }\n    previous = token\n    return data(code)\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    }\n\n    // Data.\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n}\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeDocument(effects) {\n  const self = this\n  /** @type {Array<StackItem>} */\n  const stack = []\n  let continued = 0\n  /** @type {TokenizeContext | undefined} */\n  let childFlow\n  /** @type {Token | undefined} */\n  let childToken\n  /** @type {number} */\n  let lineStartOffset\n  return start\n\n  /** @type {State} */\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    }\n\n    // Done.\n    return checkNewContainers(code)\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++\n\n    // 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    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined\n      if (childFlow) {\n        closeFlow()\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {Point | undefined} */\n      let point\n\n      // Find the flow chunk.\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      exitContainers(continued)\n\n      // Fix positions.\n      let index = indexBeforeExits\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n      return checkNewContainers(code)\n    }\n    return start(code)\n  }\n\n  /** @type {State} */\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      }\n\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      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code)\n      }\n\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      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    }\n\n    // Check if there is a new container.\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(code)\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow()\n    exitContainers(continued)\n    return documentContinued(code)\n  }\n\n  /** @type {State} */\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\n  /** @type {State} */\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\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++\n    stack.push([self.currentConstruct, self.containerState])\n    // Try another.\n    return documentContinued(code)\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow()\n      exitContainers(0)\n      effects.consume(code)\n      return\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\n  /** @type {State} */\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    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      writeToChild(effects.exit('chunkFlow'))\n      // Get ready for the next line.\n      continued = 0\n      self.interrupt = undefined\n      return start\n    }\n    effects.consume(code)\n    return flowContinue\n  }\n\n  /**\n   * @param {Token} token\n   * @param {boolean | undefined} [eof]\n   * @returns {undefined}\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)\n\n    // 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    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length\n      while (index--) {\n        if (\n          // The token starts before the line ending…\n          childFlow.events[index][1].start.offset < lineStartOffset &&\n          // …and either is not ended yet…\n          (!childFlow.events[index][1].end ||\n            // …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      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {boolean | undefined} */\n      let seen\n      /** @type {Point | undefined} */\n      let point\n\n      // Find the previous chunk (the one before the lazy line).\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          seen = true\n        }\n      }\n      exitContainers(continued)\n\n      // Fix positions.\n      index = indexBeforeExits\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n    }\n  }\n\n  /**\n   * @param {number} size\n   * @returns {undefined}\n   */\n  function exitContainers(size) {\n    let index = stack.length\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index]\n      self.containerState = entry[1]\n      entry[0].exit.call(self, effects)\n    }\n    stack.length = size\n  }\n  function closeFlow() {\n    childFlow.write([null])\n    childToken = undefined\n    childFlow = undefined\n    self.containerState._closeFlow = undefined\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\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').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\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\n/** @type {Construct} */\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n};\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 */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\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 chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\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\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\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 * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n}\n\n/**\n * @this {TokenizeContext}\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,\n    // 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\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\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').Code} Code\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n\n/**\n * @param {'string' | 'text'} field\n * @returns {InitialConstruct}\n */\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n\n  /**\n   * @this {TokenizeContext}\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\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      }\n\n      // Data.\n      effects.consume(code)\n      return data\n    }\n\n    /**\n     * @param {Code} code\n     * @returns {boolean}\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true\n      }\n      const list = constructs[code]\n      let index = -1\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index]\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true\n          }\n        }\n      }\n      return false\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n * @returns {Resolver}\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1\n    /** @type {number | undefined} */\n    let enter\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\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        enter = undefined\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events\n  }\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 */\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      let tabs\n      while (index--) {\n        const chunk = chunks[index]\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n          if (bufferIndex) break\n          bufferIndex = -1\n        }\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      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        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      eventIndex++\n    }\n  }\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenType} TokenType\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * @callback Restore\n * @returns {undefined}\n *\n * @typedef Info\n * @property {Restore} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {undefined}\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\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, '_bufferIndex' | '_index'> | undefined} [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  const columnStart = {}\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = []\n  /** @type {Array<Chunk>} */\n  let chunks = []\n  /** @type {Array<Token>} */\n  let stack = []\n  /** @type {boolean | undefined} */\n  let consumed = true\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\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  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\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  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects)\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  }\n  return context\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice)\n    main()\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n    addResult(initialize, 0)\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs)\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {line, column, offset, _index, _bufferIndex} = point\n    return {\n      line,\n      column,\n      offset,\n      _index,\n      _bufferIndex\n    }\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  }\n\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 {undefined}\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index]\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\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  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {undefined}\n   */\n  function go(code) {\n    consumed = undefined\n    expectedCode = code\n    state = state(code)\n  }\n\n  /** @type {Effects['consume']} */\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    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++\n\n      // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code\n\n    // Mark as consumed.\n    consumed = true\n  }\n\n  /** @type {Effects['enter']} */\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\n  /** @type {Effects['exit']} */\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  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore()\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   */\n  function constructFactory(onreturn, fields) {\n    return hook\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | Construct | ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State | undefined} [bogusState]\n     * @returns {State}\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Array<Construct>} */\n      let listOfConstructs\n      /** @type {number} */\n      let constructIndex\n      /** @type {Construct} */\n      let currentConstruct\n      /** @type {Info} */\n      let info\n      return Array.isArray(constructs) /* c8 ignore next 1 */\n        ? handleListOfConstructs(constructs)\n        : 'tokenize' in constructs\n        ? // @ts-expect-error Looks like a construct.\n          handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n      function handleMapOfConstructs(map) {\n        return start\n\n        /** @type {State} */\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            /* 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      /**\n       * Handle a list of construct.\n       *\n       * @param {Array<Construct>} list\n       * @returns {State}\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n        if (list.length === 0) {\n          return bogusState\n        }\n        return handleConstruct(list[constructIndex])\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n      function handleConstruct(construct) {\n        return start\n\n        /** @type {State} */\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          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          // Always populated by defaults.\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\n            return nok(code)\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\n      /** @type {State} */\n      function ok(code) {\n        consumed = true\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true\n        info.restore()\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n        return bogusState\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {undefined}\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\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    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\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    /**\n     * Restore state.\n     *\n     * @returns {undefined}\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  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\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/**\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, 'end' | 'start'>} token\n * @returns {Array<Chunk>}\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  let view\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    if (startBufferIndex > -1) {\n      const head = view[0]\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex)\n      } else {\n        view.shift()\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  return view\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Array<Chunk>} chunks\n * @param {boolean | undefined} [expandTabs=false]\n * @returns {string}\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {Array<string>} */\n  const result = []\n  /** @type {boolean | undefined} */\n  let atTab\n  while (++index < chunks.length) {\n    const chunk = chunks[index]\n    /** @type {string} */\n    let value\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n        case -4: {\n          value = '\\n'\n          break\n        }\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n        default: {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk)\n        }\n      }\n    atTab = chunk === -2\n    result.push(value)\n  }\n  return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"thematicBreak\");\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code;\n    return atBreak(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter(\"thematicBreakSequence\");\n      return sequence(code);\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit(\"thematicBreak\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit(\"thematicBreakSequence\");\n    return markdownSpace(code) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\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\n/** @type {Construct} */\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\n    if (kind === \"listUnordered\" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n      if (kind === \"listUnordered\") {\n        effects.enter(\"listItemPrefix\");\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter(\"listItemPrefix\");\n        effects.enter(\"listItemValue\");\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit(\"listItemValue\");\n      return atMarker(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\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(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  /** @type {State} */\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    return nok(code);\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit(\"listItemPrefix\"), true).length;\n    return ok(code);\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(code);\n  }\n\n  /** @type {State} */\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    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true;\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined;\n    // Always populated by defaults.\n\n    return factorySpace(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\n/**\n * @type {Exiter}\n * @this {TokenizeContext}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n\n  // Always populated by defaults.\n\n  return factorySpace(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\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    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\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\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\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 enclosedBefore\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return raw(code)\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(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    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return enclosed(code)\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return enclosedBefore(code)\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? enclosedEscape : enclosed\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return enclosed\n    }\n    return enclosed(code)\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (\n      !balance &&\n      (code === null || code === 41 || markdownLineEndingOrSpace(code))\n    ) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code)\n      balance++\n      return raw\n    }\n    if (code === 41) {\n      effects.consume(code)\n      balance--\n      return raw\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? rawEscape : raw\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return raw\n    }\n    return raw(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').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\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  let seen\n  return start\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\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\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (\n      size > 999 ||\n      code === null ||\n      code === 91 ||\n      (code === 93 && !seen) ||\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      // Hidden footnotes hook.\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs)\n    ) {\n      return nok(code)\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    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return labelInside(code)\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(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    effects.consume(code)\n    if (!seen) seen = !markdownSpace(code)\n    return code === 92 ? labelEscape : labelInside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\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 labelInside\n    }\n    return labelInside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\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\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      marker = code === 40 ? 41 : code\n      return begin\n    }\n    return nok(code)\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(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    effects.enter(stringType)\n    return atBreak(code)\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return begin(marker)\n    }\n    if (code === null) {\n      return nok(code)\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atBreak, 'linePrefix')\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return inside(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? escape : inside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return inside\n    }\n    return inside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns {State}\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /** @type {State} */\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    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\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 { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  tokenize: tokenizeTitleBefore,\n  partial: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n\n/** @type {Construct} */\nconst furtherStart = {\n  tokenize: tokenizeFurtherStart,\n  partial: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter(\"codeIndented\");\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return inside(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return inside;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit(\"codeIndented\");\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this;\n  return furtherStart;\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\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    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return furtherStart;\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\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').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n};\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n  let content;\n  /** @type {Token} */\n  let text;\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === \"whitespace\") {\n    contentStart += 2;\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === \"atxHeadingSequence\" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === \"whitespace\")) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\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      contentType: \"text\"\n    };\n    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter(\"atxHeading\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"atxHeadingSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return sequenceOpen;\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingSequence\");\n      return atBreak(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter(\"atxHeadingSequence\");\n      return sequenceFurther(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"atxHeading\");\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, \"whitespace\")(code);\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter(\"atxHeadingText\");\n    return data(code);\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequenceFurther;\n    }\n    effects.exit(\"atxHeadingSequence\");\n    return atBreak(code);\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingText\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n};\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length;\n  /** @type {number | undefined} */\n  let content;\n  /** @type {number | undefined} */\n  let text;\n  /** @type {number | undefined} */\n  let definition;\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === \"content\") {\n        content = index;\n        break;\n      }\n      if (events[index][1].type === \"paragraph\") {\n        text = index;\n      }\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      if (!definition && events[index][1].type === \"definition\") {\n        definition = index;\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  };\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = \"setextHeadingText\";\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\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  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context]);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length;\n    /** @type {boolean | undefined} */\n    let paragraph;\n    // Find an opening.\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 (self.events[index][1].type !== \"lineEnding\" && self.events[index][1].type !== \"linePrefix\" && self.events[index][1].type !== \"content\") {\n        paragraph = self.events[index][1].type === \"paragraph\";\n        break;\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter(\"setextHeadingLine\");\n      marker = code;\n      return before(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"setextHeadingLineSequence\");\n    return inside(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    effects.exit(\"setextHeadingLineSequence\");\n    return markdownSpace(code) ? factorySpace(effects, after, \"lineSuffix\")(code) : after(code);\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"setextHeadingLine\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * 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 *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\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  'search',\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 “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { asciiAlpha, asciiAlphanumeric, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  tokenize: tokenizeBlankLineBefore,\n  partial: true\n};\nconst nonLazyContinuationStart = {\n  tokenize: tokenizeNonLazyContinuationStart,\n  partial: true\n};\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === \"htmlFlow\") {\n      break;\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;\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start;\n    // Remove the line prefix.\n    events.splice(index - 2, 2);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n  let marker;\n  /** @type {boolean} */\n  let closingTag;\n  /** @type {string} */\n  let buffer;\n  /** @type {number} */\n  let index;\n  /** @type {Code} */\n  let markerB;\n  return start;\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"htmlFlow\");\n    effects.enter(\"htmlFlowData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      closingTag = true;\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      marker = 3;\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // 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      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      marker = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      marker = 5;\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      marker = 4;\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation;\n      }\n      return cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      const slash = code === 47;\n      const name = buffer.toLowerCase();\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1;\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6;\n        if (slash) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      marker = 7;\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      markerB = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    return completeAttributeValueUnquoted(code);\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code);\n      markerB = null;\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code);\n      return continuationCdataInside;\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit(\"htmlFlowData\");\n      return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationStart(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return continuationBefore;\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code);\n    }\n    effects.enter(\"htmlFlowData\");\n    return continuation(code);\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase();\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code);\n        return continuationClose;\n      }\n      return continuation(code);\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      // @ts-expect-error: not null.\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationAfter(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit(\"htmlFlow\");\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\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      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start;\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return effects.attempt(blankLine, ok, nok);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  tokenize: tokenizeNonLazyContinuation,\n  partial: true\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    tokenize: tokenizeCloseStart,\n    partial: true\n  };\n  let initialPrefix = 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code);\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1];\n    initialPrefix = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n    marker = code;\n    effects.enter(\"codeFenced\");\n    effects.enter(\"codeFencedFence\");\n    effects.enter(\"codeFencedFenceSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++;\n      effects.consume(code);\n      return sequenceOpen;\n    }\n    if (sizeOpen < 3) {\n      return nok(code);\n    }\n    effects.exit(\"codeFencedFenceSequence\");\n    return markdownSpace(code) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : infoBefore(code);\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFencedFence\");\n      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFencedFenceInfo\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return info(code);\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return infoBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return factorySpace(effects, metaBefore, \"whitespace\")(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return info;\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code);\n    }\n    effects.enter(\"codeFencedFenceMeta\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\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 infoBefore(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code);\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return contentStart;\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : beforeContentChunk(code);\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return contentChunk(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit(\"codeFenced\");\n    return ok(code);\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0;\n    return startBefore;\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return start;\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter(\"codeFencedFence\");\n      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter(\"codeFencedFenceSequence\");\n        return sequenceClose(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size >= sizeOpen) {\n        effects.exit(\"codeFencedFenceSequence\");\n        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : sequenceCloseAfter(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit(\"codeFencedFence\");\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\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('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n  let max;\n  /** @type {(code: Code) => boolean} */\n  let test;\n  return start;\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\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\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\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    effects.enter(\"characterReferenceValue\");\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\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    effects.enter(\"characterReferenceValue\");\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit(\"characterReferenceValue\");\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter(\"characterReferenceMarker\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarker\");\n      effects.exit(\"characterReference\");\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\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 inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\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    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  /** @type {State} */\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 * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\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').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\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/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n};\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n};\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n};\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  while (++index < events.length) {\n    const token = events[index][1];\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      events.splice(index + 1, token.type === \"labelImage\" ? 4 : 2);\n      token.type = \"data\";\n      index++;\n    }\n  }\n  return events;\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n  let token;\n  /** @type {number | undefined} */\n  let open;\n  /** @type {number | undefined} */\n  let close;\n  /** @type {Array<Event>} */\n  let media;\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1];\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === \"link\" || token.type === \"labelLink\" && token._inactive) {\n        break;\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === \"labelLink\") {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === \"labelImage\" || token.type === \"labelLink\") && !token._balanced) {\n        open = index;\n        if (token.type !== \"labelLink\") {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === \"labelEnd\") {\n      close = index;\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 = [['enter', group, context], ['enter', label, context]];\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3));\n\n  // Text open.\n  media = push(media, [['enter', text, context]]);\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1));\n\n  // Media close.\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n  let labelStart;\n  /** @type {boolean} */\n  let defined;\n\n  // Find an opening.\n  while (index--) {\n    if ((self.events[index][1].type === \"labelImage\" || self.events[index][1].type === \"labelLink\") && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code);\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code);\n    }\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter(\"labelEnd\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelEnd\");\n    return after;\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code);\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code);\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code);\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart;\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter(\"resource\");\n    effects.enter(\"resourceMarker\");\n    effects.consume(code);\n    effects.exit(\"resourceMarker\");\n    return resourceBefore;\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code);\n    }\n    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(code);\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code);\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(code);\n    }\n    return resourceEnd(code);\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(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    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this;\n  return referenceFull;\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(code);\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart;\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter(\"reference\");\n    effects.enter(\"referenceMarker\");\n    effects.consume(code);\n    effects.exit(\"referenceMarker\");\n    return referenceCollapsedOpen;\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(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    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\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\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\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    return nok(code);\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Point} Point\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').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // 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  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index;\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\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 ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 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 = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\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\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !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/**\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 {undefined}\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { asciiAlpha, asciiAlphanumeric, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\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\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\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    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlpha, asciiAlphanumeric, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code> | undefined} */\n  let marker;\n  /** @type {number} */\n  let index;\n  /** @type {State} */\n  let returnState;\n  return start;\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\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\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return comment(code);\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code);\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === value.length ? cdata : cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      marker = undefined;\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\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    return nok(code);\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit(\"htmlTextData\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineEndingAfter;\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code);\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter(\"htmlTextData\");\n    return returnState(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\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\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Previous} Previous\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').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\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  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\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      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\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\n/** @satisfies {Extension['document']} */\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\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n}\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n\n/** @satisfies {Extension['flow']} */\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\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n\n/** @satisfies {Extension['text']} */\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\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n}\n","/**\n * @typedef {import('micromark-util-types').Create} Create\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n */\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 {string, text} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n * @returns {ParseContext}\n */\nexport function parse(options) {\n  const settings = options || {}\n  const constructs =\n    /** @type {FullNormalizedExtension} */\n    combineExtensions([defaultConstructs, ...(settings.extensions || [])])\n\n  /** @type {ParseContext} */\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  /**\n   * @param {InitialConstruct} initial\n   */\n  function create(initial) {\n    return creator\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {boolean | null | undefined} [end=false]\n * @returns {Array<Chunk>}\n */\n\nconst search = /[\\0\\t\\n\\r]/g\n\n/**\n * @returns {Preprocessor}\n */\nexport function preprocess() {\n  let column = 1\n  let buffer = ''\n  /** @type {boolean | undefined} */\n  let start = true\n  /** @type {boolean | undefined} */\n  let atCarriageReturn\n  return preprocessor\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = []\n    /** @type {RegExpMatchArray | null} */\n    let match\n    /** @type {number} */\n    let next\n    /** @type {number} */\n    let startPosition\n    /** @type {number} */\n    let endPosition\n    /** @type {Code} */\n    let code\n    value =\n      buffer +\n      (typeof value === 'string'\n        ? value.toString()\n        : new TextDecoder(encoding || undefined).decode(value))\n    startPosition = 0\n    buffer = ''\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n      start = undefined\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      if (!match) {\n        buffer = value.slice(startPosition)\n        break\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        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n        switch (code) {\n          case 0: {\n            chunks.push(65533)\n            column++\n            break\n          }\n          case 9: {\n            next = Math.ceil(column / 4) * 4\n            chunks.push(-2)\n            while (column++ < next) chunks.push(-1)\n            break\n          }\n          case 10: {\n            chunks.push(-4)\n            column = 1\n            break\n          }\n          default: {\n            atCarriageReturn = true\n            column = 1\n          }\n        }\n      }\n      startPosition = endPosition + 1\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\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 * Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space.\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of C0, and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55_295 && code < 57_344 ||\n  // Noncharacters.\n  code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */\n  (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */\n  // Out of range\n  code > 1_114_111) {\n    return \"\\uFFFD\";\n  }\n  return String.fromCodePoint(code);\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/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0)\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  return decodeNamedCharacterReference($2) || $0\n}\n","/**\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').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').ReferenceType} ReferenceType\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 {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 *\n * @typedef {import('unist').Point} Point\n *\n * @typedef {import('../index.js').CompileData} CompileData\n */\n\n/**\n * @typedef {Omit<Parent, 'children' | 'type'> & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @callback Transform\n *   Extra transform, to change the AST afterwards.\n * @param {Root} tree\n *   Tree to transform.\n * @returns {Root | null | undefined | void}\n *   New tree or nothing (in which case the current tree is used).\n *\n * @callback Handle\n *   Handle a token.\n * @param {CompileContext} this\n *   Context.\n * @param {Token} token\n *   Current token.\n * @returns {undefined | void}\n *   Nothing.\n *\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n *\n * @callback OnEnterError\n *   Handle the case where the `right` token is open, but it is closed (by the\n *   `left` token) or because we reached the end of the document.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token | undefined} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {undefined}\n *   Nothing.\n *\n * @callback OnExitError\n *   Handle the case where the `right` token is open but it is closed by\n *   exiting the `left` token.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef {[Token, OnEnterError | undefined]} TokenTuple\n *   Open token on the stack, with an optional error handler for when\n *   that token isn’t closed properly.\n */\n\n/**\n * @typedef Config\n *   Configuration.\n *\n *   We have our defaults, but extensions will add more.\n * @property {Array<string>} canContainEols\n *   Token types where line endings are used.\n * @property {Handles} enter\n *   Opening handles.\n * @property {Handles} exit\n *   Closing handles.\n * @property {Array<Transform>} transforms\n *   Tree transforms.\n *\n * @typedef {Partial<Config>} Extension\n *   Change how markdown tokens from micromark are turned into mdast.\n *\n * @typedef CompileContext\n *   mdast compiler context.\n * @property {Array<Fragment | Nodes>} stack\n *   Stack of nodes.\n * @property {Array<TokenTuple>} tokenStack\n *   Stack of tokens.\n * @property {(this: CompileContext) => undefined} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {(this: CompileContext, node: Nodes, token: Token, onError?: OnEnterError) => undefined} enter\n *   Enter a node.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => undefined} exit\n *   Exit a node.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {Config} config\n *   Configuration.\n * @property {CompileData} data\n *   Info passed around; key/value store.\n *\n * @typedef FromMarkdownOptions\n *   Configuration for how to build mdast.\n * @property {Array<Extension | Array<Extension>> | null | undefined} [mdastExtensions]\n *   Extensions for this utility to change how tokens are turned into a tree.\n *\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n *   Configuration.\n */\n\nimport { toString } from 'mdast-util-to-string';\nimport { parse, postprocess, preprocess } from 'micromark';\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/**\n * Turn markdown into a syntax tree.\n *\n * @overload\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @overload\n * @param {Value} value\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @param {Value} value\n *   Markdown to parse.\n * @param {Encoding | Options | null | undefined} [encoding]\n *   Character encoding for when `value` is `Buffer`.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Root}\n *   mdast tree.\n */\nexport function fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));\n}\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\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      characterReference: onexitcharacterreference,\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  configure(config, (options || {}).mdastExtensions || []);\n\n  /** @type {CompileData} */\n  const data = {};\n  return compile;\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    };\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      data\n    };\n    /** @type {Array<number>} */\n    const listStack = [];\n    let index = -1;\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 (events[index][1].type === \"listOrdered\" || events[index][1].type === \"listUnordered\") {\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    index = -1;\n    while (++index < events.length) {\n      const handler = config[events[index][0]];\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(Object.assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1];\n      const handler = tail[1] || defaultOnError;\n      handler.call(context, undefined, tail[0]);\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(events.length > 0 ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length > 0 ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n\n    // Call transforms.\n    index = -1;\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\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    let listItem;\n    /** @type {number | undefined} */\n    let lineIndex;\n    /** @type {number | undefined} */\n    let firstBlankLineIndex;\n    /** @type {boolean | undefined} */\n    let atMarker;\n    while (++index <= length) {\n      const event = events[index];\n      switch (event[1].type) {\n        case \"listUnordered\":\n        case \"listOrdered\":\n        case \"blockQuote\":\n          {\n            if (event[0] === 'enter') {\n              containerBalance++;\n            } else {\n              containerBalance--;\n            }\n            atMarker = undefined;\n            break;\n          }\n        case \"lineEndingBlank\":\n          {\n            if (event[0] === 'enter') {\n              if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n                firstBlankLineIndex = index;\n              }\n              atMarker = undefined;\n            }\n            break;\n          }\n        case \"linePrefix\":\n        case \"listItemValue\":\n        case \"listItemMarker\":\n        case \"listItemPrefix\":\n        case \"listItemPrefixWhitespace\":\n          {\n            // Empty.\n\n            break;\n          }\n        default:\n          {\n            atMarker = undefined;\n          }\n      }\n      if (!containerBalance && event[0] === 'enter' && event[1].type === \"listItemPrefix\" || containerBalance === -1 && event[0] === 'exit' && (event[1].type === \"listUnordered\" || event[1].type === \"listOrdered\")) {\n        if (listItem) {\n          let tailIndex = index;\n          lineIndex = undefined;\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex];\n            if (tailEvent[1].type === \"lineEnding\" || tailEvent[1].type === \"lineEndingBlank\") {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = \"lineEndingBlank\";\n                listSpread = true;\n              }\n              tailEvent[1].type = \"lineEnding\";\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === \"linePrefix\" || tailEvent[1].type === \"blockQuotePrefix\" || tailEvent[1].type === \"blockQuotePrefixWhitespace\" || tailEvent[1].type === \"blockQuoteMarker\" || tailEvent[1].type === \"listItemIndent\") {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\n          listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        }\n\n        // Create a new list item.\n        if (event[1].type === \"listItemPrefix\") {\n          /** @type {Token} */\n          const item = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          };\n          listItem = item;\n          events.splice(index, 0, ['enter', item, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Nodes} create\n   *   Create a node.\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {undefined}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Nodes} node\n   *   Node to enter.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnEnterError | undefined} [errorHandler]\n   *   Handle the case where this token is open, but it is closed by something else.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children;\n    siblings.push(node);\n    this.stack.push(node);\n    this.tokenStack.push([token, errorHandler]);\n    node.position = {\n      start: point(token.start),\n      // @ts-expect-error: `end` will be patched later.\n      end: undefined\n    };\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnExitError | undefined} [onExitError]\n   *   Handle the case where another token is open.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop();\n    const open = this.tokenStack.pop();\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\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    node.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n  function resume() {\n    return toString(this.stack.pop());\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    this.data.expectingFirstListItemValue = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (this.data.expectingFirstListItemValue) {\n      const ancestor = this.stack[this.stack.length - 2];\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);\n      this.data.expectingFirstListItemValue = undefined;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.lang = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.meta = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (this.data.flowCodeInside) return;\n    this.buffer();\n    this.data.flowCodeInside = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    this.data.flowCodeInside = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '');\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length;\n      node.depth = depth;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    this.data.setextHeadingSlurpLineEnding = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    this.data.setextHeadingSlurpLineEnding = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = node.children;\n    let tail = siblings[siblings.length - 1];\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start),\n        // @ts-expect-error: we’ll add `end` later.\n        end: undefined\n      };\n      siblings.push(tail);\n    }\n    this.stack.push(tail);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\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\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1];\n    // If we’re at a hard break, include the line ending in there.\n    if (this.data.atHardBreak) {\n      const tail = context.children[context.children.length - 1];\n      tail.position.end = point(token.end);\n      this.data.atHardBreak = undefined;\n      return;\n    }\n    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    this.data.atHardBreak = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token);\n    const ancestor = this.stack[this.stack.length - 2];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string);\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1];\n    const value = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // Assume a reference.\n    this.data.inReference = true;\n    if (node.type === 'link') {\n      /** @type {Array<PhrasingContent>} */\n      const children = fragment.children;\n      node.children = children;\n    } else {\n      node.alt = value;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    this.data.inReference = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    this.data.referenceType = 'collapsed';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label;\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    this.data.referenceType = 'full';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    this.data.characterReferenceType = token.type;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token);\n    const type = this.data.characterReferenceType;\n    /** @type {string} */\n    let value;\n    if (type) {\n      value = decodeNumericCharacterReference(data, type === \"characterReferenceMarkerNumeric\" ? 10 : 16);\n      this.data.characterReferenceType = undefined;\n    } else {\n      const result = decodeNamedCharacterReference(data);\n      value = result;\n    }\n    const tail = this.stack[this.stack.length - 1];\n    tail.value += value;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreference(token) {\n    const tail = this.stack.pop();\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = this.sliceSerialize(token);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    return {\n      type: 'heading',\n      // @ts-expect-error `depth` will be set later.\n      depth: 0,\n      children: []\n    };\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  /** @returns {Html} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  };\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Array<Extension> | Extension>} extensions\n * @returns {undefined}\n */\nfunction configure(combined, extensions) {\n  let index = -1;\n  while (++index < extensions.length) {\n    const value = extensions[index];\n    if (Array.isArray(value)) {\n      configure(combined, value);\n    } else {\n      extension(combined, value);\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {undefined}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key;\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      switch (key) {\n        case 'canContainEols':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'transforms':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'enter':\n        case 'exit':\n          {\n            const right = extension[key];\n            if (right) {\n              Object.assign(combined[key], right);\n            }\n            break;\n          }\n        // No default\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error('Cannot close `' + left.type + '` (' + stringifyPosition({\n      start: left.start,\n      end: left.end\n    }) + '): a different token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is open');\n  } else {\n    throw new Error('Cannot close document, a token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is still open');\n  }\n}","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions\n * @typedef {import('unified').Parser<Root>} Parser\n * @typedef {import('unified').Processor<Root>} Processor\n */\n\n/**\n * @typedef {Omit<FromMarkdownOptions, 'extensions' | 'mdastExtensions'>} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/**\n * Aadd support for parsing from markdown.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkParse(options) {\n  /** @type {Processor} */\n  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.\n  const self = this\n\n  self.parser = parser\n\n  /**\n   * @type {Parser}\n   */\n  function parser(doc) {\n    return fromMarkdown(doc, {\n      ...self.data('settings'),\n      ...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: self.data('micromarkExtensions') || [],\n      mdastExtensions: self.data('fromMarkdownExtensions') || []\n    })\n  }\n}\n","import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\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`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * 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]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\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 | null | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n  if (!protocol) {\n    return value\n  }\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 ||\n    // 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) ||\n    // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n  return ''\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\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  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n    let replace = ''\n\n    // A correct percent encoded value.\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    }\n    // Astral.\n    else if (code > 55_295 && code < 57_344) {\n      const next = value.charCodeAt(index + 1)\n\n      // A correct surrogate pair.\n      if (code < 56_320 && next > 56_319 && next < 57_344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      }\n      // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n  return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('./state.js').State} State\n */\n\n/**\n * @callback FootnoteBackContentTemplate\n *   Generate content for the backreference dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent> | ElementContent | string}\n *   Content for the backreference when linking back from definitions to their\n *   reference.\n *\n * @callback FootnoteBackLabelTemplate\n *   Generate a back label dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Back label to use when linking back from definitions to their reference.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Generate the default content that GitHub uses on backreferences.\n *\n * @param {number} _\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent>}\n *   Content.\n */\nexport function defaultFootnoteBackContent(_, rereferenceIndex) {\n  /** @type {Array<ElementContent>} */\n  const result = [{type: 'text', value: '↩'}]\n\n  if (rereferenceIndex > 1) {\n    result.push({\n      type: 'element',\n      tagName: 'sup',\n      properties: {},\n      children: [{type: 'text', value: String(rereferenceIndex)}]\n    })\n  }\n\n  return result\n}\n\n/**\n * Generate the default label that GitHub uses on backreferences.\n *\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Label.\n */\nexport function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n  return (\n    'Back to reference ' +\n    (referenceIndex + 1) +\n    (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n  )\n}\n\n/**\n * Generate a hast footer for called footnote definitions.\n *\n * @param {State} state\n *   Info passed around.\n * @returns {Element | undefined}\n *   `section` element or `undefined`.\n */\n// eslint-disable-next-line complexity\nexport function footer(state) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const footnoteBackContent =\n    state.options.footnoteBackContent || defaultFootnoteBackContent\n  const footnoteBackLabel =\n    state.options.footnoteBackLabel || defaultFootnoteBackLabel\n  const footnoteLabel = state.options.footnoteLabel || 'Footnotes'\n  const footnoteLabelTagName = state.options.footnoteLabelTagName || 'h2'\n  const footnoteLabelProperties = state.options.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n  let referenceIndex = -1\n\n  while (++referenceIndex < state.footnoteOrder.length) {\n    const definition = state.footnoteById.get(\n      state.footnoteOrder[referenceIndex]\n    )\n\n    if (!definition) {\n      continue\n    }\n\n    const content = state.all(definition)\n    const id = String(definition.identifier).toUpperCase()\n    const safeId = normalizeUri(id.toLowerCase())\n    let rereferenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n    const counts = state.footnoteCounts.get(id)\n\n    // eslint-disable-next-line no-unmodified-loop-condition\n    while (counts !== undefined && ++rereferenceIndex <= counts) {\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      let children =\n        typeof footnoteBackContent === 'string'\n          ? footnoteBackContent\n          : footnoteBackContent(referenceIndex, rereferenceIndex)\n\n      if (typeof children === 'string') {\n        children = {type: 'text', value: children}\n      }\n\n      backReferences.push({\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            clobberPrefix +\n            'fnref-' +\n            safeId +\n            (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''),\n          dataFootnoteBackref: '',\n          ariaLabel:\n            typeof footnoteBackLabel === 'string'\n              ? footnoteBackLabel\n              : footnoteBackLabel(referenceIndex, rereferenceIndex),\n          className: ['data-footnote-backref']\n        },\n        children: Array.isArray(children) ? children : [children]\n      })\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: clobberPrefix + 'fn-' + safeId},\n      children: state.wrap(content, true)\n    }\n\n    state.patch(definition, listItem)\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: footnoteLabelTagName,\n        properties: {\n          ...structuredClone(footnoteLabelProperties),\n          id: 'footnote-label'\n        },\n        children: [{type: 'text', value: footnoteLabel}]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: state.wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `blockquote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Blockquote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function blockquote(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'blockquote',\n    properties: {},\n    children: state.wrap(state.all(node), true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `break` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Break} node\n *   mdast node.\n * @returns {Array<Element | Text>}\n *   hast element content.\n */\nexport function hardBreak(state, node) {\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'br', properties: {}, children: []}\n  state.patch(node, result)\n  return [state.applyData(node, result), {type: 'text', value: '\\n'}]\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Code} Code\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `code` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Code} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function code(state, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  /** @type {Properties} */\n  const properties = {}\n\n  if (node.lang) {\n    properties.className = ['language-' + node.lang]\n  }\n\n  // Create `<code>`.\n  /** @type {Element} */\n  let result = {\n    type: 'element',\n    tagName: 'code',\n    properties,\n    children: [{type: 'text', value}]\n  }\n\n  if (node.meta) {\n    result.data = {meta: node.meta}\n  }\n\n  state.patch(node, result)\n  result = state.applyData(node, result)\n\n  // Create `<pre>`.\n  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}\n  state.patch(node, result)\n  return result\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `delete` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Delete} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strikethrough(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'del',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `emphasis` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Emphasis} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function emphasis(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'em',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `footnoteReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {FootnoteReference} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnoteReference(state, node) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const id = String(node.identifier).toUpperCase()\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = state.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  let reuseCounter = state.footnoteCounts.get(id)\n\n  if (reuseCounter === undefined) {\n    reuseCounter = 0\n    state.footnoteOrder.push(id)\n    counter = state.footnoteOrder.length\n  } else {\n    counter = index + 1\n  }\n\n  reuseCounter += 1\n  state.footnoteCounts.set(id, reuseCounter)\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + clobberPrefix + 'fn-' + safeId,\n      id:\n        clobberPrefix +\n        'fnref-' +\n        safeId +\n        (reuseCounter > 1 ? '-' + reuseCounter : ''),\n      dataFootnoteRef: true,\n      ariaDescribedBy: ['footnote-label']\n    },\n    children: [{type: 'text', value: String(counter)}]\n  }\n  state.patch(node, link)\n\n  /** @type {Element} */\n  const sup = {\n    type: 'element',\n    tagName: 'sup',\n    properties: {},\n    children: [link]\n  }\n  state.patch(node, sup)\n  return state.applyData(node, sup)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `heading` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Heading} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function heading(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'h' + node.depth,\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Html} Html\n * @typedef {import('../state.js').State} State\n * @typedef {import('../../index.js').Raw} Raw\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise\n * nothing).\n *\n * @param {State} state\n *   Info passed around.\n * @param {Html} node\n *   mdast node.\n * @returns {Element | Raw | undefined}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.options.allowDangerousHtml) {\n    /** @type {Raw} */\n    const result = {type: 'raw', value: node.value}\n    state.patch(node, result)\n    return state.applyData(node, result)\n  }\n\n  return undefined\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Reference} Reference\n *\n * @typedef {import('./state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, 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 [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\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({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `imageReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ImageReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Image} Image\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `image` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Image} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function image(state, node) {\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(node.url)}\n\n  if (node.alt !== null && node.alt !== undefined) {\n    properties.alt = node.alt\n  }\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `inlineCode` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {InlineCode} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function inlineCode(state, node) {\n  /** @type {Text} */\n  const text = {type: 'text', value: node.value.replace(/\\r?\\n|\\r/g, ' ')}\n  state.patch(node, text)\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'code',\n    properties: {},\n    children: [text]\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `linkReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {LinkReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(definition.url || '')}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Link} Link\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `link` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Link} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function link(state, node) {\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[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      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === null || spread === undefined\n    ? node.children.length > 1\n    : spread\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').List} List\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Parents} HastParents\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastParents}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointEnd, pointStart} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start && end) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  // To do: option to use `style`?\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(cell, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\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","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastElement | HastText}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\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 {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 {tableRow} from './table-row.js'\nimport {tableCell} from './table-cell.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default handlers for nodes.\n *\n * @satisfies {import('../state.js').Handlers}\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  // @ts-expect-error: root is different, but hard to type.\n  root,\n  strong,\n  table,\n  tableCell,\n  tableRow,\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 undefined\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').RootContent} HastRootContent\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('mdast').Parents} MdastParents\n *\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate\n * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate\n */\n\n/**\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed)\n *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function all(parent) {\n    /** @type {Array<HastElementContent>} */\n    const values = []\n\n    if ('children' in parent) {\n      const nodes = parent.children\n      let index = -1\n      while (++index < nodes.length) {\n        const result = state.one(nodes[index], parent)\n\n        // To do: see if we van clean this? Can we merge texts?\n        if (result) {\n          if (index && nodes[index - 1].type === 'break') {\n            if (!Array.isArray(result) && result.type === 'text') {\n              result.value = trimMarkdownSpaceStart(result.value)\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 = trimMarkdownSpaceStart(head.value)\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}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: state.all(node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n","/**\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('./state.js').Options} Options\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n","// Include `data` fields in mdast and `raw` nodes in hast.\n/// <reference types=\"mdast-util-to-hast\" />\n\n/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('mdast-util-to-hast').Options} ToHastOptions\n * @typedef {import('unified').Processor} Processor\n * @typedef {import('vfile').VFile} VFile\n */\n\n/**\n * @typedef {Omit<ToHastOptions, 'file'>} Options\n *\n * @callback TransformBridge\n *   Bridge-mode.\n *\n *   Runs the destination with the new hast tree.\n *   Discards result.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {Promise<undefined>}\n *   Nothing.\n *\n * @callback TransformMutate\n *  Mutate-mode.\n *\n *  Further transformers run on the hast tree.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {HastRoot}\n *   Tree (hast).\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n/**\n * Turn markdown into HTML.\n *\n * ##### Notes\n *\n * ###### Signature\n *\n * *   if a processor is given, runs the (rehype) plugins used on it with a\n *     hast tree, then discards the result (*bridge mode*)\n * *   otherwise, returns a hast tree, the plugins used after `remarkRehype`\n *     are rehype plugins (*mutate mode*)\n *\n * > 👉 **Note**: It’s highly unlikely that you want to pass a `processor`.\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most plugins ignore `raw` nodes but two notable ones don’t:\n *\n * *   `rehype-stringify` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful if\n *     you completely trust authors\n * *   `rehype-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only way\n *     to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `remark-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * *Example: headings (DOM clobbering)* in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @overload\n * @param {Processor} processor\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformBridge}\n *\n * @overload\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformMutate}\n *\n * @param {Readonly<Options> | Processor | null | undefined} [destination]\n *   Processor or configuration (optional).\n * @param {Readonly<Options> | null | undefined} [options]\n *   When a processor was given, configuration (optional).\n * @returns {TransformBridge | TransformMutate}\n *   Transform.\n */\nexport default function remarkRehype(destination, options) {\n  if (destination && 'run' in destination) {\n    /**\n     * @type {TransformBridge}\n     */\n    return async function (tree, file) {\n      // Cast because root in -> root out.\n      const hastTree = /** @type {HastRoot} */ (\n        toHast(tree, {file, ...options})\n      )\n      await destination.run(hastTree, file)\n    }\n  }\n\n  /**\n   * @type {TransformMutate}\n   */\n  return function (tree, file) {\n    // Cast because root in -> root out.\n    return /** @type {HastRoot} */ (\n      toHast(tree, {file, ...(options || destination)})\n    )\n  }\n}\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","// To do: remove `void`s\n// To do: remove `null` from output of our APIs, allow it as user APIs.\n\n/**\n * @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback\n *   Callback.\n *\n * @typedef {(...input: Array<any>) => any} Middleware\n *   Ware.\n *\n * @typedef Pipeline\n *   Pipeline.\n * @property {Run} run\n *   Run the pipeline.\n * @property {Use} use\n *   Add middleware.\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n *\n *   Calls `done` on completion with either an error or the output of the\n *   last middleware.\n *\n *   > 👉 **Note**: as the length of input defines whether async functions get a\n *   > `next` function,\n *   > it’s recommended to keep `input` at one value normally.\n\n *\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n *   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` into a uniform interface.\n *\n * You can pass all input to the resulting function.\n * `callback` is then called with the output of `middleware`.\n *\n * If `middleware` accepts more arguments than the later given in input,\n * an extra `done` function is passed to it after that input,\n * which must be called by `middleware`.\n *\n * The first value in `input` is the main input value.\n * All other input values are the rest input values.\n * The values given to `callback` are the input values,\n * merged with every non-nullish output value.\n *\n * * if `middleware` throws an error,\n *   returns a promise that is rejected,\n *   or calls the given `done` function with an error,\n *   `callback` is called with that error\n * * if `middleware` returns a value or returns a promise that is resolved,\n *   that value is the main output value\n * * if `middleware` calls `done`,\n *   all non-nullish values except for the first one (the error) overwrite the\n *   output values\n *\n * @param {Middleware} middleware\n *   Function to wrap.\n * @param {Callback} callback\n *   Callback called with the output of `middleware`.\n * @returns {Run}\n *   Wrapped middleware.\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 && result.then && typeof result.then === 'function') {\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   *\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","// 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 minpath = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * Get the basename from a path.\n *\n * @param {string} path\n *   File path.\n * @param {string | null | undefined} [extname]\n *   Extension to strip.\n * @returns {string}\n *   Stem or basename.\n */\nfunction basename(path, extname) {\n  if (extname !== undefined && typeof extname !== '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 (\n    extname === undefined ||\n    extname.length === 0 ||\n    extname.length > path.length\n  ) {\n    while (index--) {\n      if (path.codePointAt(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 (extname === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extnameIndex = extname.length - 1\n\n  while (index--) {\n    if (path.codePointAt(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 (extnameIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.codePointAt(index) === extname.codePointAt(extnameIndex--)) {\n          if (extnameIndex < 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          extnameIndex = -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 * Get the dirname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\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.codePointAt(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.codePointAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.codePointAt(0) === 47 /* `/` */\n      ? '//'\n      : path.slice(0, end)\n}\n\n/**\n * Get an extname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   Extname.\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.codePointAt(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 * Join segments from a path.\n *\n * @param {Array<string>} segments\n *   Path segments.\n * @returns {string}\n *   File path.\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 * Normalize a basic file path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.codePointAt(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.codePointAt(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 *   File path.\n * @param {boolean} allowAboveRoot\n *   Whether `..` can move above root.\n * @returns {string}\n *   File path.\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.codePointAt(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.codePointAt(result.length - 1) !== 46 /* `.` */ ||\n          result.codePointAt(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 * Make sure `path` is a string.\n *\n * @param {string} path\n *   File path.\n * @returns {asserts path is string}\n *   Nothing.\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 minproc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * Checks if a value has the shape of a WHATWG URL object.\n *\n * Using a symbol or instanceof would not be able to recognize URL objects\n * coming from other implementations (e.g. in Electron), so instead we are\n * checking some well known properties for a lack of a better test.\n *\n * We use `href` and `protocol` as they are the only properties that are\n * easy to retrieve and calculate due to the lazy nature of the getters.\n *\n * We check for auth attribute to distinguish legacy url instance with\n * WHATWG URL instance.\n *\n * @param {unknown} fileUrlOrPath\n *   File path or URL.\n * @returns {fileUrlOrPath is URL}\n *   Whether it’s a URL.\n */\n// From: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js#L720>\nexport function isUrl(fileUrlOrPath) {\n  return Boolean(\n    fileUrlOrPath !== null &&\n      typeof fileUrlOrPath === 'object' &&\n      'href' in fileUrlOrPath &&\n      fileUrlOrPath.href &&\n      'protocol' in fileUrlOrPath &&\n      fileUrlOrPath.protocol &&\n      // @ts-expect-error: indexing is fine.\n      fileUrlOrPath.auth === undefined\n  )\n}\n","import {isUrl} from './minurl.shared.js'\n\nexport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js>\n\n/**\n * @param {URL | string} path\n *   File URL.\n * @returns {string}\n *   File URL.\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 * Get a path from a POSIX URL.\n *\n * @param {URL} url\n *   URL.\n * @returns {string}\n *   File path.\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.codePointAt(index) === 37 /* `%` */ &&\n      pathname.codePointAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.codePointAt(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","/**\n * @import {Node, Point, Position} from 'unist'\n * @import {Options as MessageOptions} from 'vfile-message'\n * @import {Compatible, Data, Map, Options, Value} from 'vfile'\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {VFileMessage} from 'vfile-message'\nimport {minpath} from '#minpath'\nimport {minproc} from '#minproc'\nimport {urlToPath, isUrl} from '#minurl'\n\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.\n */\nconst order = /** @type {const} */ ([\n  'history',\n  'path',\n  'basename',\n  'stem',\n  'extname',\n  'dirname'\n])\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * `options` is treated as:\n   *\n   * *   `string` or `Uint8Array` — `{value: options}`\n   * *   `URL` — `{path: options}`\n   * *   `VFile` — shallow copies its data over to the new file\n   * *   `object` — all fields are shallow copied over to the new file\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   * You cannot set `dirname` or `extname` without setting either `history`,\n   * `path`, `basename`, or `stem` too.\n   *\n   * @param {Compatible | null | undefined} [value]\n   *   File value.\n   * @returns\n   *   New instance.\n   */\n  constructor(value) {\n    /** @type {Options | VFile} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else if (typeof value === 'string' || isUint8Array(value)) {\n      options = {value}\n    } else {\n      options = value\n    }\n\n    /* eslint-disable no-unused-expressions */\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     *\n     * @type {string}\n     */\n    // Prevent calling `cwd` (which could be expensive) if it’s not needed;\n    // the empty string will be overridden in the next block.\n    this.cwd = 'cwd' in options ? '' : minproc.cwd()\n\n    /**\n     * Place to store custom info (default: `{}`).\n     *\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     *\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of file paths the file moved between.\n     *\n     * The first is the original path and the last is the current path.\n     *\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * List of messages associated with the file.\n     *\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * Raw value.\n     *\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     * Source map.\n     *\n     * This type is equivalent to the `RawSourceMap` type from the `source-map`\n     * module.\n     *\n     * @type {Map | null | undefined}\n     */\n    this.map\n\n    /**\n     * Custom, non-string, compiled, representation.\n     *\n     * This is used by unified to store non-string results.\n     * One example is when turning markdown into React nodes.\n     *\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Whether a file was saved to disk.\n     *\n     * This is used by vfile reporters.\n     *\n     * @type {boolean}\n     */\n    this.stored\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 field = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        field in options &&\n        options[field] !== undefined &&\n        options[field] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[field] = field === 'history' ? [...options[field]] : options[field]\n      }\n    }\n\n    /** @type {string} */\n    let field\n\n    // Set non-path related properties.\n    for (field in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(field)) {\n        // @ts-expect-error: fine to set other things.\n        this[field] = options[field]\n      }\n    }\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   *\n   * @returns {string | undefined}\n   *   Basename.\n   */\n  get basename() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path)\n      : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   *\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   * @param {string} basename\n   *   Basename.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = minpath.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   *\n   * @returns {string | undefined}\n   *   Dirname.\n   */\n  get dirname() {\n    return typeof this.path === 'string'\n      ? minpath.dirname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   *\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} dirname\n   *   Dirname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = minpath.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   *\n   * @returns {string | undefined}\n   *   Extname.\n   */\n  get extname() {\n    return typeof this.path === 'string'\n      ? minpath.extname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   *\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   * @param {string | undefined} extname\n   *   Extname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.codePointAt(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 = minpath.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   *\n   * @returns {string}\n   *   Path.\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   *\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   *\n   * @param {URL | string} path\n   *   Path.\n   * @returns {undefined}\n   *   Nothing.\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 stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * @returns {string | undefined}\n   *   Stem.\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   *\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   * @param {string} stem\n   *   Stem.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = minpath.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  // Normal prototypal methods.\n  /**\n   * Create a fatal message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `true` (error; file not usable)\n   * and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {never}\n   *   Never.\n   * @throws {VFileMessage}\n   *   Message.\n   */\n  fail(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n\n  /**\n   * Create an info message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `undefined` (info; change\n   * likely not needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = undefined\n\n    return message\n  }\n\n  /**\n   * Create a message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `false` (warning; change may be\n   * needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(causeOrReason, optionsOrParentOrPlace, origin) {\n    const message = new VFileMessage(\n      // @ts-expect-error: the overloads are fine.\n      causeOrReason,\n      optionsOrParentOrPlace,\n      origin\n    )\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   * Serialize the file.\n   *\n   * > **Note**: which encodings are supported depends on the engine.\n   * > For info on Node.js, see:\n   * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.\n   *\n   * @param {string | null | undefined} [encoding='utf8']\n   *   Character encoding to understand `value` as when it’s a `Uint8Array`\n   *   (default: `'utf-8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    if (this.value === undefined) {\n      return ''\n    }\n\n    if (typeof this.value === 'string') {\n      return this.value\n    }\n\n    const decoder = new TextDecoder(encoding || undefined)\n    return decoder.decode(this.value)\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n *   File path part.\n * @param {string} name\n *   Part name.\n * @returns {undefined}\n *   Nothing.\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(minpath.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + minpath.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n *   Thing.\n * @param {string} name\n *   Part name.\n * @returns {asserts part is string}\n *   Nothing.\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 *   Path.\n * @param {string} name\n *   Dependency name.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","export const CallableInstance =\n  /**\n   * @type {new <Parameters extends Array<unknown>, Result>(property: string | symbol) => (...parameters: Parameters) => Result}\n   */\n  (\n    /** @type {unknown} */\n    (\n      /**\n       * @this {Function}\n       * @param {string | symbol} property\n       * @returns {(...parameters: Array<unknown>) => unknown}\n       */\n      function (property) {\n        const self = this\n        const constr = self.constructor\n        const proto = /** @type {Record<string | symbol, Function>} */ (\n          // Prototypes do exist.\n          // type-coverage:ignore-next-line\n          constr.prototype\n        )\n        const value = proto[property]\n        /** @type {(...parameters: Array<unknown>) => unknown} */\n        const apply = function () {\n          return value.apply(apply, arguments)\n        }\n\n        Object.setPrototypeOf(apply, proto)\n\n        // Not needed for us in `unified`: we only call this on the `copy`\n        // function,\n        // and we don't need to add its fields (`length`, `name`)\n        // over.\n        // See also: GH-246.\n        // const names = Object.getOwnPropertyNames(value)\n        //\n        // for (const p of names) {\n        //   const descriptor = Object.getOwnPropertyDescriptor(value, p)\n        //   if (descriptor) Object.defineProperty(apply, p, descriptor)\n        // }\n\n        return apply\n      }\n    )\n  )\n","/**\n * @typedef {import('trough').Pipeline} Pipeline\n *\n * @typedef {import('unist').Node} Node\n *\n * @typedef {import('vfile').Compatible} Compatible\n * @typedef {import('vfile').Value} Value\n *\n * @typedef {import('../index.js').CompileResultMap} CompileResultMap\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Settings} Settings\n */\n\n/**\n * @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults\n *   Acceptable results from compilers.\n *\n *   To register custom results, add them to\n *   {@linkcode CompileResultMap}.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the compiler receives (default: `Node`).\n * @template {CompileResults} [Result=CompileResults]\n *   The thing that the compiler yields (default: `CompileResults`).\n * @callback Compiler\n *   A **compiler** handles the compiling of a syntax tree to something else\n *   (in most cases, text) (TypeScript type).\n *\n *   It is used in the stringify phase and called with a {@linkcode Node}\n *   and {@linkcode VFile} representation of the document to compile.\n *   It should return the textual representation of the given tree (typically\n *   `string`).\n *\n *   > **Note**: unified typically compiles by serializing: most compilers\n *   > return `string` (or `Uint8Array`).\n *   > Some compilers, such as the one configured with\n *   > [`rehype-react`][rehype-react], return other values (in this case, a\n *   > React tree).\n *   > If you’re using a compiler that doesn’t serialize, expect different\n *   > result values.\n *   >\n *   > To register custom results in TypeScript, add them to\n *   > {@linkcode CompileResultMap}.\n *\n *   [rehype-react]: https://github.com/rehypejs/rehype-react\n * @param {Tree} tree\n *   Tree to compile.\n * @param {VFile} file\n *   File associated with `tree`.\n * @returns {Result}\n *   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or\n *   something else (for `file.result`).\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the parser yields (default: `Node`)\n * @callback Parser\n *   A **parser** handles the parsing of text to a syntax tree.\n *\n *   It is used in the parse phase and is called with a `string` and\n *   {@linkcode VFile} of the document to parse.\n *   It must return the syntax tree representation of the given file\n *   ({@linkcode Node}).\n * @param {string} document\n *   Document to parse.\n * @param {VFile} file\n *   File associated with `document`.\n * @returns {Tree}\n *   Node representing the given file.\n */\n\n/**\n * @typedef {(\n *   Plugin<Array<any>, any, any> |\n *   PluginTuple<Array<any>, any, any> |\n *   Preset\n * )} Pluggable\n *   Union of the different ways to add plugins and settings.\n */\n\n/**\n * @typedef {Array<Pluggable>} PluggableList\n *   List of plugins and presets.\n */\n\n// Note: we can’t use `callback` yet as it messes up `this`:\n//  <https://github.com/microsoft/TypeScript/issues/55197>.\n/**\n * @template {Array<unknown>} [PluginParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=Node]\n *   Value that is expected as input (default: `Node`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=Input]\n *   Value that is yielded as output (default: `Input`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   (this: Processor, ...parameters: PluginParameters) =>\n *     Input extends string ? // Parser.\n *        Output extends Node | undefined ? undefined | void : never :\n *     Output extends CompileResults ? // Compiler.\n *        Input extends Node | undefined ? undefined | void : never :\n *     Transformer<\n *       Input extends Node ? Input : Node,\n *       Output extends Node ? Output : Node\n *     > | undefined | void\n * )} Plugin\n *   Single plugin.\n *\n *   Plugins configure the processors they are applied on in the following\n *   ways:\n *\n *   *   they change the processor, such as the parser, the compiler, or by\n *       configuring data\n *   *   they specify how to handle trees and files\n *\n *   In practice, they are functions that can receive options and configure the\n *   processor (`this`).\n *\n *   > **Note**: plugins are called when the processor is *frozen*, not when\n *   > they are applied.\n */\n\n/**\n * Tuple of a plugin and its configuration.\n *\n * The first item is a plugin, the rest are its parameters.\n *\n * @template {Array<unknown>} [TupleParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=undefined]\n *   Value that is expected as input (optional).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=undefined] (optional).\n *   Value that is yielded as output.\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   [\n *     plugin: Plugin<TupleParameters, Input, Output>,\n *     ...parameters: TupleParameters\n *   ]\n * )} PluginTuple\n */\n\n/**\n * @typedef Preset\n *   Sharable configuration.\n *\n *   They can contain plugins and settings.\n * @property {PluggableList | undefined} [plugins]\n *   List of plugins and presets (optional).\n * @property {Settings | undefined} [settings]\n *   Shared settings for parsers and compilers (optional).\n */\n\n/**\n * @template {VFile} [File=VFile]\n *   The file that the callback receives (default: `VFile`).\n * @callback ProcessCallback\n *   Callback called when the process is done.\n *\n *   Called with either an error or a result.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {File | undefined} [file]\n *   Processed file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The tree that the callback receives (default: `Node`).\n * @callback RunCallback\n *   Callback called when transformers are done.\n *\n *   Called with either an error or results.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {Tree | undefined} [tree]\n *   Transformed tree (optional).\n * @param {VFile | undefined} [file]\n *   File (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Output=Node]\n *   Node type that the transformer yields (default: `Node`).\n * @callback TransformCallback\n *   Callback passed to transforms.\n *\n *   If the signature of a `transformer` accepts a third argument, the\n *   transformer may perform asynchronous operations, and must call it.\n * @param {Error | undefined} [error]\n *   Fatal error to stop the process (optional).\n * @param {Output | undefined} [tree]\n *   New, changed, tree (optional).\n * @param {VFile | undefined} [file]\n *   New, changed, file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Input=Node]\n *   Node type that the transformer expects (default: `Node`).\n * @template {Node} [Output=Input]\n *   Node type that the transformer yields (default: `Input`).\n * @callback Transformer\n *   Transformers handle syntax trees and files.\n *\n *   They are functions that are called each time a syntax tree and file are\n *   passed through the run phase.\n *   When an error occurs in them (either because it’s thrown, returned,\n *   rejected, or passed to `next`), the process stops.\n *\n *   The run phase is handled by [`trough`][trough], see its documentation for\n *   the exact semantics of these functions.\n *\n *   > **Note**: you should likely ignore `next`: don’t accept it.\n *   > it supports callback-style async work.\n *   > But promises are likely easier to reason about.\n *\n *   [trough]: https://github.com/wooorm/trough#function-fninput-next\n * @param {Input} tree\n *   Tree to handle.\n * @param {VFile} file\n *   File to handle.\n * @param {TransformCallback<Output>} next\n *   Callback.\n * @returns {(\n *   Promise<Output | undefined | void> |\n *   Promise<never> | // For some reason this is needed separately.\n *   Output |\n *   Error |\n *   undefined |\n *   void\n * )}\n *   If you accept `next`, nothing.\n *   Otherwise:\n *\n *   *   `Error` — fatal error to stop the process\n *   *   `Promise<undefined>` or `undefined` — the next transformer keeps using\n *       same tree\n *   *   `Promise<Node>` or `Node` — new, changed, tree\n */\n\n/**\n * @template {Node | undefined} ParseTree\n *   Output of `parse`.\n * @template {Node | undefined} HeadTree\n *   Input for `run`.\n * @template {Node | undefined} TailTree\n *   Output for `run`.\n * @template {Node | undefined} CompileTree\n *   Input of `stringify`.\n * @template {CompileResults | undefined} CompileResult\n *   Output of `stringify`.\n * @template {Node | string | undefined} Input\n *   Input of plugin.\n * @template Output\n *   Output of plugin (optional).\n * @typedef {(\n *   Input extends string\n *     ? Output extends Node | undefined\n *       ? // Parser.\n *         Processor<\n *           Output extends undefined ? ParseTree : Output,\n *           HeadTree,\n *           TailTree,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Output extends CompileResults\n *     ? Input extends Node | undefined\n *       ? // Compiler.\n *         Processor<\n *           ParseTree,\n *           HeadTree,\n *           TailTree,\n *           Input extends undefined ? CompileTree : Input,\n *           Output extends undefined ? CompileResult : Output\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Input extends Node | undefined\n *     ? Output extends Node | undefined\n *       ? // Transform.\n *         Processor<\n *           ParseTree,\n *           HeadTree extends undefined ? Input : HeadTree,\n *           Output extends undefined ? TailTree : Output,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : // Unknown.\n *       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n * )} UsePlugin\n *   Create a processor based on the input/output of a {@link Plugin plugin}.\n */\n\n/**\n * @template {CompileResults | undefined} Result\n *   Node type that the transformer yields.\n * @typedef {(\n *   Result extends Value | undefined ?\n *     VFile :\n *     VFile & {result: Result}\n *   )} VFileWithOutput\n *   Type to generate a {@linkcode VFile} corresponding to a compiler result.\n *\n *   If a result that is not acceptable on a `VFile` is used, that will\n *   be stored on the `result` field of {@linkcode VFile}.\n */\n\nimport {bail} from 'bail'\nimport extend from 'extend'\nimport {ok as assert} from 'devlop'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\nimport {CallableInstance} from './callable-instance.js'\n\n// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.\n\n// To do: we could start yielding `never` in TS when a parser is missing and\n// `parse` is called.\n// Currently, we allow directly setting `processor.parser`, which is untyped.\n\nconst own = {}.hasOwnProperty\n\n/**\n * @template {Node | undefined} [ParseTree=undefined]\n *   Output of `parse` (optional).\n * @template {Node | undefined} [HeadTree=undefined]\n *   Input for `run` (optional).\n * @template {Node | undefined} [TailTree=undefined]\n *   Output for `run` (optional).\n * @template {Node | undefined} [CompileTree=undefined]\n *   Input of `stringify` (optional).\n * @template {CompileResults | undefined} [CompileResult=undefined]\n *   Output of `stringify` (optional).\n * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}\n */\nexport class Processor extends CallableInstance {\n  /**\n   * Create a processor.\n   */\n  constructor() {\n    // If `Processor()` is called (w/o new), `copy` is called instead.\n    super('copy')\n\n    /**\n     * Compiler to use (deprecated).\n     *\n     * @deprecated\n     *   Use `compiler` instead.\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.Compiler = undefined\n\n    /**\n     * Parser to use (deprecated).\n     *\n     * @deprecated\n     *   Use `parser` instead.\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.Parser = undefined\n\n    // Note: the following fields are considered private.\n    // However, they are needed for tests, and TSC generates an untyped\n    // `private freezeIndex` field for, which trips `type-coverage` up.\n    // Instead, we use `@deprecated` to visualize that they shouldn’t be used.\n    /**\n     * Internal list of configured plugins.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Array<PluginTuple<Array<unknown>>>}\n     */\n    this.attachers = []\n\n    /**\n     * Compiler to use.\n     *\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.compiler = undefined\n\n    /**\n     * Internal state to track where we are while freezing.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {number}\n     */\n    this.freezeIndex = -1\n\n    /**\n     * Internal state to track whether we’re frozen.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {boolean | undefined}\n     */\n    this.frozen = undefined\n\n    /**\n     * Internal state.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Data}\n     */\n    this.namespace = {}\n\n    /**\n     * Parser to use.\n     *\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.parser = undefined\n\n    /**\n     * Internal list of configured transformers.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Pipeline}\n     */\n    this.transformers = trough()\n  }\n\n  /**\n   * Copy a processor.\n   *\n   * @deprecated\n   *   This is a private internal method and should not be used.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   New *unfrozen* processor ({@linkcode Processor}) that is\n   *   configured to work the same as its ancestor.\n   *   When the descendant processor is configured in the future it does not\n   *   affect the ancestral processor.\n   */\n  copy() {\n    // Cast as the type parameters will be the same after attaching.\n    const destination =\n      /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */ (\n        new Processor()\n      )\n    let index = -1\n\n    while (++index < this.attachers.length) {\n      const attacher = this.attachers[index]\n      destination.use(...attacher)\n    }\n\n    destination.data(extend(true, {}, this.namespace))\n\n    return destination\n  }\n\n  /**\n   * Configure the processor with info available to all plugins.\n   * Information is stored in an object.\n   *\n   * Typically, options can be given to a specific plugin, but sometimes it\n   * makes sense to have information shared with several plugins.\n   * For example, a list of HTML elements that are self-closing, which is\n   * needed during all phases.\n   *\n   * > **Note**: setting information cannot occur on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * > **Note**: to register custom data in TypeScript, augment the\n   * > {@linkcode Data} interface.\n   *\n   * @example\n   *   This example show how to get and set info:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   const processor = unified().data('alpha', 'bravo')\n   *\n   *   processor.data('alpha') // => 'bravo'\n   *\n   *   processor.data() // => {alpha: 'bravo'}\n   *\n   *   processor.data({charlie: 'delta'})\n   *\n   *   processor.data() // => {charlie: 'delta'}\n   *   ```\n   *\n   * @template {keyof Data} Key\n   *\n   * @overload\n   * @returns {Data}\n   *\n   * @overload\n   * @param {Data} dataset\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Key} key\n   * @returns {Data[Key]}\n   *\n   * @overload\n   * @param {Key} key\n   * @param {Data[Key]} value\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @param {Data | Key} [key]\n   *   Key to get or set, or entire dataset to set, or nothing to get the\n   *   entire dataset (optional).\n   * @param {Data[Key]} [value]\n   *   Value to set (optional).\n   * @returns {unknown}\n   *   The current processor when setting, the value at `key` when getting, or\n   *   the entire dataset when getting without key.\n   */\n  data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', this.frozen)\n        this.namespace[key] = value\n        return this\n      }\n\n      // Get `key`.\n      return (own.call(this.namespace, key) && this.namespace[key]) || undefined\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', this.frozen)\n      this.namespace = key\n      return this\n    }\n\n    // Get space.\n    return this.namespace\n  }\n\n  /**\n   * Freeze a processor.\n   *\n   * Frozen processors are meant to be extended and not to be configured\n   * directly.\n   *\n   * When a processor is frozen it cannot be unfrozen.\n   * New processors working the same way can be created by calling the\n   * processor.\n   *\n   * It’s possible to freeze processors explicitly by calling `.freeze()`.\n   * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,\n   * `.stringify()`, `.process()`, or `.processSync()` are called.\n   *\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   The current processor.\n   */\n  freeze() {\n    if (this.frozen) {\n      return this\n    }\n\n    // Cast so that we can type plugins easier.\n    // Plugins are supposed to be usable on different processors, not just on\n    // this exact processor.\n    const self = /** @type {Processor} */ (/** @type {unknown} */ (this))\n\n    while (++this.freezeIndex < this.attachers.length) {\n      const [attacher, ...options] = this.attachers[this.freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      const transformer = attacher.call(self, ...options)\n\n      if (typeof transformer === 'function') {\n        this.transformers.use(transformer)\n      }\n    }\n\n    this.frozen = true\n    this.freezeIndex = Number.POSITIVE_INFINITY\n\n    return this\n  }\n\n  /**\n   * Parse text to a syntax tree.\n   *\n   * > **Note**: `parse` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `parse` performs the parse phase, not the run phase or other\n   * > phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   file to parse (optional); typically `string` or `VFile`; any value\n   *   accepted as `x` in `new VFile(x)`.\n   * @returns {ParseTree extends undefined ? Node : ParseTree}\n   *   Syntax tree representing `file`.\n   */\n  parse(file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const parser = this.parser || this.Parser\n    assertParser('parse', parser)\n    return parser(String(realFile), realFile)\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * > **Note**: `process` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `process` performs the parse, run, and stringify phases.\n   *\n   * @overload\n   * @param {Compatible | undefined} file\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<VFileWithOutput<CompileResult>>}\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`]; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]\n   *   Callback (optional).\n   * @returns {Promise<VFile> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise a promise, rejected with a fatal error or resolved with the\n   *   processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  process(file, done) {\n    const self = this\n\n    this.freeze()\n    assertParser('process', this.parser || this.Parser)\n    assertCompiler('process', this.compiler || this.Compiler)\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve\n     * @param {(error: Error | undefined) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      const realFile = vfile(file)\n      // Assume `ParseTree` (the result of the parser) matches `HeadTree` (the\n      // input of the first transform).\n      const parseTree =\n        /** @type {HeadTree extends undefined ? Node : HeadTree} */ (\n          /** @type {unknown} */ (self.parse(realFile))\n        )\n\n      self.run(parseTree, realFile, function (error, tree, file) {\n        if (error || !tree || !file) {\n          return realDone(error)\n        }\n\n        // Assume `TailTree` (the output of the last transform) matches\n        // `CompileTree` (the input of the compiler).\n        const compileTree =\n          /** @type {CompileTree extends undefined ? Node : CompileTree} */ (\n            /** @type {unknown} */ (tree)\n          )\n\n        const compileResult = self.stringify(compileTree, file)\n\n        if (looksLikeAValue(compileResult)) {\n          file.value = compileResult\n        } else {\n          file.result = compileResult\n        }\n\n        realDone(error, /** @type {VFileWithOutput<CompileResult>} */ (file))\n      })\n\n      /**\n       * @param {Error | undefined} error\n       * @param {VFileWithOutput<CompileResult> | undefined} [file]\n       * @returns {undefined}\n       */\n      function realDone(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `processSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `processSync` performs the parse, run, and stringify phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @returns {VFileWithOutput<CompileResult>}\n   *   The processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  processSync(file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {VFileWithOutput<CompileResult> | undefined} */\n    let result\n\n    this.freeze()\n    assertParser('processSync', this.parser || this.Parser)\n    assertCompiler('processSync', this.compiler || this.Compiler)\n\n    this.process(file, realDone)\n    assertDone('processSync', 'process', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n\n    return result\n\n    /**\n     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}\n     */\n    function realDone(error, file) {\n      complete = true\n      bail(error)\n      result = file\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * > **Note**: `run` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `run` performs the run phase, not other phases.\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} file\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree>}\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {(\n   *   RunCallback<TailTree extends undefined ? Node : TailTree> |\n   *   Compatible\n   * )} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]\n   *   Callback (optional).\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise, a promise rejected with a fatal error or resolved with the\n   *   transformed tree.\n   */\n  run(tree, file, done) {\n    assertNode(tree)\n    this.freeze()\n\n    const transformers = this.transformers\n\n    if (!done && typeof file === 'function') {\n      done = file\n      file = undefined\n    }\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {(\n     *   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |\n     *   undefined\n     * )} resolve\n     * @param {(error: Error) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      assert(\n        typeof file !== 'function',\n        '`file` can’t be a `done` anymore, we checked'\n      )\n      const realFile = vfile(file)\n      transformers.run(tree, realFile, realDone)\n\n      /**\n       * @param {Error | undefined} error\n       * @param {Node} outputTree\n       * @param {VFile} file\n       * @returns {undefined}\n       */\n      function realDone(error, outputTree, file) {\n        const resultingTree =\n          /** @type {TailTree extends undefined ? Node : TailTree} */ (\n            outputTree || tree\n          )\n\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(resultingTree)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, resultingTree, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `runSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `runSync` performs the run phase, not other phases.\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {TailTree extends undefined ? Node : TailTree}\n   *   Transformed tree.\n   */\n  runSync(tree, file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */\n    let result\n\n    this.run(tree, file, realDone)\n\n    assertDone('runSync', 'run', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n    return result\n\n    /**\n     * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}\n     */\n    function realDone(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * Compile a syntax tree.\n   *\n   * > **Note**: `stringify` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `stringify` performs the stringify phase, not the run phase\n   * > or other phases.\n   *\n   * @param {CompileTree extends undefined ? Node : CompileTree} tree\n   *   Tree to compile.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {CompileResult extends undefined ? Value : CompileResult}\n   *   Textual representation of the tree (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most compilers\n   *   > return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  stringify(tree, file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const compiler = this.compiler || this.Compiler\n    assertCompiler('stringify', compiler)\n    assertNode(tree)\n\n    return compiler(tree, realFile)\n  }\n\n  /**\n   * Configure the processor to use a plugin, a list of usable values, or a\n   * preset.\n   *\n   * If the processor is already using a plugin, the previous plugin\n   * configuration is changed based on the options that are passed in.\n   * In other words, the plugin is not added a second time.\n   *\n   * > **Note**: `use` cannot be called on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * @example\n   *   There are many ways to pass plugins to `.use()`.\n   *   This example gives an overview:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   unified()\n   *     // Plugin with options:\n   *     .use(pluginA, {x: true, y: true})\n   *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):\n   *     .use(pluginA, {y: false, z: true})\n   *     // Plugins:\n   *     .use([pluginB, pluginC])\n   *     // Two plugins, the second with options:\n   *     .use([pluginD, [pluginE, {}]])\n   *     // Preset with plugins and settings:\n   *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})\n   *     // Settings only:\n   *     .use({settings: {position: false}})\n   *   ```\n   *\n   * @template {Array<unknown>} [Parameters=[]]\n   * @template {Node | string | undefined} [Input=undefined]\n   * @template [Output=Input]\n   *\n   * @overload\n   * @param {Preset | null | undefined} [preset]\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {PluggableList} list\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Plugin<Parameters, Input, Output>} plugin\n   * @param {...(Parameters | [boolean])} parameters\n   * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}\n   *\n   * @param {PluggableList | Plugin | Preset | null | undefined} value\n   *   Usable value.\n   * @param {...unknown} parameters\n   *   Parameters, when a plugin is given as a usable value.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   Current processor.\n   */\n  use(value, ...parameters) {\n    const attachers = this.attachers\n    const namespace = this.namespace\n\n    assertUnfrozen('use', this.frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, parameters)\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    return this\n\n    /**\n     * @param {Pluggable} value\n     * @returns {undefined}\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, ...parameters] =\n            /** @type {PluginTuple<Array<unknown>>} */ (value)\n          addPlugin(plugin, parameters)\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 {undefined}\n     */\n    function addPreset(result) {\n      if (!('plugins' in result) && !('settings' in result)) {\n        throw new Error(\n          'Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither'\n        )\n      }\n\n      addList(result.plugins)\n\n      if (result.settings) {\n        namespace.settings = extend(true, namespace.settings, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList | null | undefined} plugins\n     * @returns {undefined}\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 {Array<unknown>} parameters\n     * @returns {undefined}\n     */\n    function addPlugin(plugin, parameters) {\n      let index = -1\n      let entryIndex = -1\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entryIndex = index\n          break\n        }\n      }\n\n      if (entryIndex === -1) {\n        attachers.push([plugin, ...parameters])\n      }\n      // Only set if there was at least a `primary` value, otherwise we’d change\n      // `arguments.length`.\n      else if (parameters.length > 0) {\n        let [primary, ...rest] = parameters\n        const currentPrimary = attachers[entryIndex][1]\n        if (isPlainObj(currentPrimary) && isPlainObj(primary)) {\n          primary = extend(true, currentPrimary, primary)\n        }\n\n        attachers[entryIndex] = [plugin, primary, ...rest]\n      }\n    }\n  }\n}\n\n// Note: this returns a *callable* instance.\n// That’s why it’s documented as a function.\n/**\n * Create a new processor.\n *\n * @example\n *   This example shows how a new processor can be created (from `remark`) and linked\n *   to **stdin**(4) and **stdout**(4).\n *\n *   ```js\n *   import process from 'node:process'\n *   import concatStream from 'concat-stream'\n *   import {remark} from 'remark'\n *\n *   process.stdin.pipe(\n *     concatStream(function (buf) {\n *       process.stdout.write(String(remark().processSync(buf)))\n *     })\n *   )\n *   ```\n *\n * @returns\n *   New *unfrozen* processor (`processor`).\n *\n *   This processor is configured to work the same as its ancestor.\n *   When the descendant processor is configured in the future it does not\n *   affect the ancestral processor.\n */\nexport const unified = new Processor().freeze()\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 {Compatible | undefined} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {Compatible | undefined} [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 Value}\n */\nfunction looksLikeAValue(value) {\n  return typeof value === 'string' || isUint8Array(value)\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","// Register `Raw` in tree:\n/// <reference types=\"mdast-util-to-hast\" />\n\n/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Parents} Parents\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast-util-to-jsx-runtime').Components} JsxRuntimeComponents\n * @typedef {import('remark-rehype').Options} RemarkRehypeOptions\n * @typedef {import('unist-util-visit').BuildVisitor<Root>} Visitor\n * @typedef {import('unified').PluggableList} PluggableList\n */\n\n/**\n * @callback AllowElement\n *   Filter elements.\n * @param {Readonly<Element>} element\n *   Element to check.\n * @param {number} index\n *   Index of `element` in `parent`.\n * @param {Readonly<Parents> | undefined} parent\n *   Parent of `element`.\n * @returns {boolean | null | undefined}\n *   Whether to allow `element` (default: `false`).\n *\n * @typedef {Partial<JsxRuntimeComponents>} Components\n *   Map tag names to components.\n *\n * @typedef Deprecation\n *   Deprecation.\n * @property {string} from\n *   Old field.\n * @property {string} id\n *   ID in readme.\n * @property {keyof Options} [to]\n *   New field.\n *\n * @typedef Options\n *   Configuration.\n * @property {AllowElement | null | undefined} [allowElement]\n *   Filter elements (optional);\n *   `allowedElements` / `disallowedElements` is used first.\n * @property {ReadonlyArray<string> | null | undefined} [allowedElements]\n *   Tag names to allow (default: all tag names);\n *   cannot combine w/ `disallowedElements`.\n * @property {string | null | undefined} [children]\n *   Markdown.\n * @property {string | null | undefined} [className]\n *   Wrap in a `div` with this class name.\n * @property {Components | null | undefined} [components]\n *   Map tag names to components.\n * @property {ReadonlyArray<string> | null | undefined} [disallowedElements]\n *   Tag names to disallow (default: `[]`);\n *   cannot combine w/ `allowedElements`.\n * @property {PluggableList | null | undefined} [rehypePlugins]\n *   List of rehype plugins to use.\n * @property {PluggableList | null | undefined} [remarkPlugins]\n *   List of remark plugins to use.\n * @property {Readonly<RemarkRehypeOptions> | null | undefined} [remarkRehypeOptions]\n *   Options to pass through to `remark-rehype`.\n * @property {boolean | null | undefined} [skipHtml=false]\n *   Ignore HTML in markdown completely (default: `false`).\n * @property {boolean | null | undefined} [unwrapDisallowed=false]\n *   Extract (unwrap) what’s in disallowed elements (default: `false`);\n *   normally when say `strong` is not allowed, it and it’s children are dropped,\n *   with `unwrapDisallowed` the element itself is replaced by its children.\n * @property {UrlTransform | null | undefined} [urlTransform]\n *   Change URLs (default: `defaultUrlTransform`)\n *\n * @callback UrlTransform\n *   Transform all URLs.\n * @param {string} url\n *   URL.\n * @param {string} key\n *   Property name (example: `'href'`).\n * @param {Readonly<Element>} node\n *   Node.\n * @returns {string | null | undefined}\n *   Transformed URL (optional).\n */\n\nimport {unreachable} from 'devlop'\nimport {toJsxRuntime} from 'hast-util-to-jsx-runtime'\nimport {urlAttributes} from 'html-url-attributes'\n// @ts-expect-error: untyped.\nimport {Fragment, jsx, jsxs} from 'react/jsx-runtime'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport {unified} from 'unified'\nimport {visit} from 'unist-util-visit'\nimport {VFile} from 'vfile'\n\nconst changelog =\n  'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {PluggableList} */\nconst emptyPlugins = []\n/** @type {Readonly<RemarkRehypeOptions>} */\nconst emptyRemarkRehypeOptions = {allowDangerousHtml: true}\nconst safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i\n\n// Mutable because we `delete` any time it’s used and a message is sent.\n/** @type {ReadonlyArray<Readonly<Deprecation>>} */\nconst deprecations = [\n  {from: 'astPlugins', id: 'remove-buggy-html-in-markdown-parser'},\n  {from: 'allowDangerousHtml', id: 'remove-buggy-html-in-markdown-parser'},\n  {\n    from: 'allowNode',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'allowElement'\n  },\n  {\n    from: 'allowedTypes',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'allowedElements'\n  },\n  {\n    from: 'disallowedTypes',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'disallowedElements'\n  },\n  {from: 'escapeHtml', id: 'remove-buggy-html-in-markdown-parser'},\n  {from: 'includeElementIndex', id: '#remove-includeelementindex'},\n  {\n    from: 'includeNodeIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  },\n  {from: 'linkTarget', id: 'remove-linktarget'},\n  {from: 'plugins', id: 'change-plugins-to-remarkplugins', to: 'remarkPlugins'},\n  {from: 'rawSourcePos', id: '#remove-rawsourcepos'},\n  {from: 'renderers', id: 'change-renderers-to-components', to: 'components'},\n  {from: 'source', id: 'change-source-to-children', to: 'children'},\n  {from: 'sourcePos', id: '#remove-sourcepos'},\n  {from: 'transformImageUri', id: '#add-urltransform', to: 'urlTransform'},\n  {from: 'transformLinkUri', id: '#add-urltransform', to: 'urlTransform'}\n]\n\n/**\n * Component to render markdown.\n *\n * @param {Readonly<Options>} options\n *   Props.\n * @returns {JSX.Element}\n *   React element.\n */\nexport function Markdown(options) {\n  const allowedElements = options.allowedElements\n  const allowElement = options.allowElement\n  const children = options.children || ''\n  const className = options.className\n  const components = options.components\n  const disallowedElements = options.disallowedElements\n  const rehypePlugins = options.rehypePlugins || emptyPlugins\n  const remarkPlugins = options.remarkPlugins || emptyPlugins\n  const remarkRehypeOptions = options.remarkRehypeOptions\n    ? {...options.remarkRehypeOptions, ...emptyRemarkRehypeOptions}\n    : emptyRemarkRehypeOptions\n  const skipHtml = options.skipHtml\n  const unwrapDisallowed = options.unwrapDisallowed\n  const urlTransform = options.urlTransform || defaultUrlTransform\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(remarkPlugins)\n    .use(remarkRehype, remarkRehypeOptions)\n    .use(rehypePlugins)\n\n  const file = new VFile()\n\n  if (typeof children === 'string') {\n    file.value = children\n  } else {\n    unreachable(\n      'Unexpected value `' +\n        children +\n        '` for `children` prop, expected `string`'\n    )\n  }\n\n  if (allowedElements && disallowedElements) {\n    unreachable(\n      'Unexpected combined `allowedElements` and `disallowedElements`, expected one or the other'\n    )\n  }\n\n  for (const deprecation of deprecations) {\n    if (Object.hasOwn(options, deprecation.from)) {\n      unreachable(\n        'Unexpected `' +\n          deprecation.from +\n          '` prop, ' +\n          (deprecation.to\n            ? 'use `' + deprecation.to + '` instead'\n            : 'remove it') +\n          ' (see <' +\n          changelog +\n          '#' +\n          deprecation.id +\n          '> for more info)'\n      )\n    }\n  }\n\n  const mdastTree = processor.parse(file)\n  /** @type {Nodes} */\n  let hastTree = processor.runSync(mdastTree, file)\n\n  // Wrap in `div` if there’s a class name.\n  if (className) {\n    hastTree = {\n      type: 'element',\n      tagName: 'div',\n      properties: {className},\n      // Assume no doctypes.\n      children: /** @type {Array<ElementContent>} */ (\n        hastTree.type === 'root' ? hastTree.children : [hastTree]\n      )\n    }\n  }\n\n  visit(hastTree, transform)\n\n  return toJsxRuntime(hastTree, {\n    Fragment,\n    components,\n    ignoreInvalidStyle: true,\n    jsx,\n    jsxs,\n    passKeys: true,\n    passNode: true\n  })\n\n  /** @type {Visitor} */\n  function transform(node, index, parent) {\n    if (node.type === 'raw' && parent && typeof index === 'number') {\n      if (skipHtml) {\n        parent.children.splice(index, 1)\n      } else {\n        parent.children[index] = {type: 'text', value: node.value}\n      }\n\n      return index\n    }\n\n    if (node.type === 'element') {\n      /** @type {string} */\n      let key\n\n      for (key in urlAttributes) {\n        if (\n          Object.hasOwn(urlAttributes, key) &&\n          Object.hasOwn(node.properties, key)\n        ) {\n          const value = node.properties[key]\n          const test = urlAttributes[key]\n          if (test === null || test.includes(node.tagName)) {\n            node.properties[key] = urlTransform(String(value || ''), key, node)\n          }\n        }\n      }\n    }\n\n    if (node.type === 'element') {\n      let remove = allowedElements\n        ? !allowedElements.includes(node.tagName)\n        : disallowedElements\n        ? disallowedElements.includes(node.tagName)\n        : false\n\n      if (!remove && allowElement && typeof index === 'number') {\n        remove = !allowElement(node, index, parent)\n      }\n\n      if (remove && parent && typeof index === 'number') {\n        if (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  }\n}\n\n/**\n * Make a URL safe.\n *\n * @satisfies {UrlTransform}\n * @param {string} value\n *   URL.\n * @returns {string}\n *   Safe URL.\n */\nexport function defaultUrlTransform(value) {\n  // Same as:\n  // <https://github.com/micromark/micromark/blob/929275e/packages/micromark-util-sanitize-uri/dev/index.js#L34>\n  // But without the `encode` part.\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 ||\n    // 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) ||\n    // It is a protocol, it should be allowed.\n    safeProtocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n\n  return ''\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n */\n\n/**\n * @template {string} SimpleSelector\n *   Selector type.\n * @template {string} DefaultTagName\n *   Default tag name.\n * @typedef {(\n *   SimpleSelector extends ''\n *     ? DefaultTagName\n *     : SimpleSelector extends `${infer TagName}.${infer Rest}`\n *     ? ExtractTagName<TagName, DefaultTagName>\n *     : SimpleSelector extends `${infer TagName}#${infer Rest}`\n *     ? ExtractTagName<TagName, DefaultTagName>\n *     : SimpleSelector extends string\n *     ? SimpleSelector\n *     : DefaultTagName\n * )} ExtractTagName\n *   Extract tag name from a simple selector.\n */\n\nconst search = /[#.]/g\n\n/**\n * Create a hast element from a simple CSS selector.\n *\n * @template {string} Selector\n *   Type of selector.\n * @template {string} [DefaultTagName='div']\n *   Type of default tag name (default: `'div'`).\n * @param {Selector | null | undefined} [selector]\n *   Simple CSS selector (optional).\n *\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 | null | undefined} [defaultTagName='div']\n *   Tag name to use if `selector` does not specify one (default: `'div'`).\n * @returns {Element & {tagName: ExtractTagName<Selector, DefaultTagName>}}\n *   Built element.\n */\nexport function parseSelector(selector, defaultTagName) {\n  const value = selector || ''\n  /** @type {Properties} */\n  const props = {}\n  let start = 0\n  /** @type {string | undefined} */\n  let previous\n  /** @type {string | undefined} */\n  let tagName\n\n  while (start < value.length) {\n    search.lastIndex = start\n    const match = search.exec(value)\n    const subvalue = value.slice(start, match ? match.index : value.length)\n\n    if (subvalue) {\n      if (!previous) {\n        tagName = 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    // @ts-expect-error: tag name is parsed.\n    tagName: tagName || defaultTagName || 'div',\n    properties: props,\n    children: []\n  }\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').RootContent} RootContent\n *\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n */\n\n/**\n * @typedef {Element | Root} Result\n *   Result from a `h` (or `s`) call.\n *\n * @typedef {number | string} StyleValue\n *   Value for a CSS style field.\n * @typedef {Record<string, StyleValue>} Style\n *   Supported value of a `style` prop.\n * @typedef {boolean | number | string | null | undefined} PrimitiveValue\n *   Primitive property value.\n * @typedef {Array<number | string>} ArrayValue\n *   List of property values for space- or comma separated values (such as `className`).\n * @typedef {ArrayValue | PrimitiveValue} PropertyValue\n *   Primitive value or list value.\n * @typedef {{[property: string]: PropertyValue | Style}} Properties\n *   Acceptable value for element properties.\n *\n * @typedef {number | string | null | undefined} PrimitiveChild\n *   Primitive children, either ignored (nullish), or turned into text nodes.\n * @typedef {Array<ArrayChildNested | Nodes | PrimitiveChild>} ArrayChild\n *   List of children.\n * @typedef {Array<Nodes | PrimitiveChild>} ArrayChildNested\n *   List of children (deep).\n * @typedef {ArrayChild | Nodes | PrimitiveChild} Child\n *   Acceptable child value.\n */\n\nimport {parse as commas} from 'comma-separated-tokens'\nimport {parseSelector} from 'hast-util-parse-selector'\nimport {find, normalize} from 'property-information'\nimport {parse as spaces} from 'space-separated-tokens'\n\nconst buttonTypes = new Set(['button', 'menu', 'reset', 'submit'])\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Schema} schema\n *   Schema to use.\n * @param {string} defaultTagName\n *   Default tag name.\n * @param {Array<string> | undefined} [caseSensitive]\n *   Case-sensitive tag names (default: `undefined`).\n * @returns\n *   `h`.\n */\nexport function createH(schema, defaultTagName, caseSensitive) {\n  const adjust = caseSensitive && createAdjustMap(caseSensitive)\n\n  /**\n   * Hyperscript compatible DSL for creating virtual hast trees.\n   *\n   * @overload\n   * @param {null | undefined} [selector]\n   * @param {...Child} children\n   * @returns {Root}\n   *\n   * @overload\n   * @param {string} selector\n   * @param {Properties} properties\n   * @param {...Child} children\n   * @returns {Element}\n   *\n   * @overload\n   * @param {string} selector\n   * @param {...Child} children\n   * @returns {Element}\n   *\n   * @param {string | null | undefined} [selector]\n   *   Selector.\n   * @param {Child | Properties | null | undefined} [properties]\n   *   Properties (or first child) (default: `undefined`).\n   * @param {...Child} children\n   *   Children.\n   * @returns {Result}\n   *   Result.\n   */\n  function h(selector, properties, ...children) {\n    let index = -1\n    /** @type {Result} */\n    let node\n\n    if (selector === undefined || selector === null) {\n      node = {type: 'root', children: []}\n      // Properties are not supported for roots.\n      const child = /** @type {Child} */ (properties)\n      children.unshift(child)\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            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  return h\n}\n\n/**\n * Check if something is properties or a child.\n *\n * @param {Child | Properties} value\n *   Value to check.\n * @param {string} name\n *   Tag name.\n * @returns {value is Properties}\n *   Whether `value` is a properties object.\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 *   Schema.\n * @param {Properties} properties\n *   Properties object.\n * @param {string} key\n *   Property name.\n * @param {PropertyValue | Style} value\n *   Property value.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addProperty(schema, properties, key, value) {\n  const info = find(schema, key)\n  let index = -1\n  /** @type {PropertyValue} */\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<number | string>} */\n    const finalResult = []\n\n    while (++index < result.length) {\n      // Assume no booleans in array.\n      const value = /** @type {number | string} */ (\n        parsePrimitive(info, info.property, result[index])\n      )\n      finalResult[index] = value\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    // Assume no booleans in `className`.\n    const value = /** @type {number | string} */ (result)\n    result = properties.className.concat(value)\n  }\n\n  properties[info.property] = result\n}\n\n/**\n * @param {Array<RootContent>} nodes\n *   Children.\n * @param {Child} value\n *   Child.\n * @returns {undefined}\n *   Nothing.\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 *   Property information.\n * @param {string} name\n *   Property name.\n * @param {PrimitiveValue} value\n *   Property value.\n * @returns {PrimitiveValue}\n *   Property value.\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 * Serialize a `style` object as a string.\n *\n * @param {Style} value\n *   Style object.\n * @returns {string}\n *   CSS 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 * Create a map to adjust casing.\n *\n * @param {Array<string>} values\n *   List of properly cased keys.\n * @returns {Record<string, string>}\n *   Map of lowercase keys to uppercase keys.\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","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 * @typedef {import('./create-h.js').Child} Child\n *   Acceptable child value.\n * @typedef {import('./create-h.js').Properties} Properties\n *   Acceptable value for element properties.\n * @typedef {import('./create-h.js').Result} Result\n *   Result from a `h` (or `s`) call.\n */\n\n// Register the JSX namespace on `h`.\n/**\n * @typedef {import('./jsx-classic.js').Element} h.JSX.Element\n * @typedef {import('./jsx-classic.js').ElementChildrenAttribute} h.JSX.ElementChildrenAttribute\n * @typedef {import('./jsx-classic.js').IntrinsicAttributes} h.JSX.IntrinsicAttributes\n * @typedef {import('./jsx-classic.js').IntrinsicElements} h.JSX.IntrinsicElements\n */\n\n// Register the JSX namespace on `s`.\n/**\n * @typedef {import('./jsx-classic.js').Element} s.JSX.Element\n * @typedef {import('./jsx-classic.js').ElementChildrenAttribute} s.JSX.ElementChildrenAttribute\n * @typedef {import('./jsx-classic.js').IntrinsicAttributes} s.JSX.IntrinsicAttributes\n * @typedef {import('./jsx-classic.js').IntrinsicElements} s.JSX.IntrinsicElements\n */\n\nimport {html, svg} from 'property-information'\nimport {createH} from './create-h.js'\nimport {svgCaseSensitiveTagNames} from './svg-case-sensitive-tag-names.js'\n\n// Note: this explicit type is needed, otherwise TS creates broken types.\n/** @type {ReturnType<createH>} */\nexport const h = createH(html, 'div')\n\n// Note: this explicit type is needed, otherwise TS creates broken types.\n/** @type {ReturnType<createH>} */\nexport const s = createH(svg, 'g', svgCaseSensitiveTagNames)\n","/**\n * @import {VFile, Value} from 'vfile'\n * @import {Location} from 'vfile-location'\n */\n\n/**\n * Create an index of the given document to translate between line/column and\n * offset based positional info.\n *\n * Also implemented in Rust in [`wooorm/markdown-rs`][markdown-rs].\n *\n * [markdown-rs]: https://github.com/wooorm/markdown-rs/blob/main/src/util/location.rs\n *\n * @param {VFile | Value} file\n *   File to index.\n * @returns {Location}\n *   Accessors for index.\n */\nexport function location(file) {\n  const value = String(file)\n  /**\n   * List, where each index is a line number (0-based), and each value is the\n   * byte index *after* where the line ends.\n   *\n   * @type {Array<number>}\n   */\n  const indices = []\n\n  return {toOffset, toPoint}\n\n  /** @type {Location['toPoint']} */\n  function toPoint(offset) {\n    if (typeof offset === 'number' && offset > -1 && offset <= value.length) {\n      let index = 0\n\n      while (true) {\n        let end = indices[index]\n\n        if (end === undefined) {\n          const eol = next(value, indices[index - 1])\n          end = eol === -1 ? value.length + 1 : eol + 1\n          indices[index] = end\n        }\n\n        if (end > offset) {\n          return {\n            line: index + 1,\n            column: offset - (index > 0 ? indices[index - 1] : 0) + 1,\n            offset\n          }\n        }\n\n        index++\n      }\n    }\n  }\n\n  /** @type {Location['toOffset']} */\n  function toOffset(point) {\n    if (\n      point &&\n      typeof point.line === 'number' &&\n      typeof point.column === 'number' &&\n      !Number.isNaN(point.line) &&\n      !Number.isNaN(point.column)\n    ) {\n      while (indices.length < point.line) {\n        const from = indices[indices.length - 1]\n        const eol = next(value, from)\n        const end = eol === -1 ? value.length + 1 : eol + 1\n        if (from === end) break\n        indices.push(end)\n      }\n\n      const offset =\n        (point.line > 1 ? indices[point.line - 2] : 0) + point.column - 1\n      // The given `column` could not exist on this line.\n      if (offset < indices[point.line - 1]) return offset\n    }\n  }\n}\n\n/**\n * @param {string} value\n * @param {number} from\n */\nfunction next(value, from) {\n  const cr = value.indexOf('\\r', from)\n  const lf = value.indexOf('\\n', from)\n  if (lf === -1) return cr\n  if (cr === -1 || cr + 1 === lf) return lf\n  return cr < lf ? cr : lf\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('hast').Element} Element\n * @typedef {import('hast').ElementData} ElementData\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').RootContent} RootContent\n *\n * @typedef {import('parse5').DefaultTreeAdapterMap} DefaultTreeAdapterMap\n * @typedef {import('parse5').Token.ElementLocation} P5ElementLocation\n * @typedef {import('parse5').Token.Location} P5Location\n *\n * @typedef {import('property-information').Schema} Schema\n *\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n *\n * @typedef {import('vfile').VFile} VFile\n */\n\n/**\n * @typedef {DefaultTreeAdapterMap['document']} P5Document\n * @typedef {DefaultTreeAdapterMap['documentFragment']} P5DocumentFragment\n * @typedef {DefaultTreeAdapterMap['documentType']} P5DocumentType\n * @typedef {DefaultTreeAdapterMap['commentNode']} P5Comment\n * @typedef {DefaultTreeAdapterMap['textNode']} P5Text\n * @typedef {DefaultTreeAdapterMap['element']} P5Element\n * @typedef {DefaultTreeAdapterMap['node']} P5Node\n * @typedef {DefaultTreeAdapterMap['template']} P5Template\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {Space | null | undefined} [space='html']\n *   Which space the document is in (default: `'html'`).\n *\n *   When an `<svg>` element is found in the HTML space, this package already\n *   automatically switches to and from the SVG space when entering and exiting\n *   it.\n * @property {VFile | null | undefined} [file]\n *   File used to add positional info to nodes (optional).\n *\n *   If given, the file should represent the original HTML source.\n * @property {boolean | null | undefined} [verbose=false]\n *   Whether to add extra positional info about starting tags, closing tags,\n *   and attributes to elements (default: `false`).\n *\n *   > 👉 **Note**: only used when `file` is given.\n *\n * @typedef {'html' | 'svg'} Space\n *   Namespace.\n *\n * @typedef State\n *   Info passed around about the current state.\n * @property {VFile | undefined} file\n *   Corresponding file.\n * @property {boolean} location\n *   Whether location info was found.\n * @property {Schema} schema\n *   Current schema.\n * @property {boolean | undefined} verbose\n *   Add extra positional info.\n */\n\nimport {ok as assert} from 'devlop'\nimport {h, s} from 'hastscript'\nimport {find, html, svg} from 'property-information'\nimport {location} from 'vfile-location'\nimport {webNamespaces} from 'web-namespaces'\n\nconst own = {}.hasOwnProperty\n/** @type {unknown} */\n// type-coverage:ignore-next-line\nconst proto = Object.prototype\n\n/**\n * Transform a `parse5` AST to hast.\n *\n * @param {P5Node} tree\n *   `parse5` tree to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {Nodes}\n *   hast tree.\n */\nexport function fromParse5(tree, options) {\n  const settings = options || {}\n\n  return one(\n    {\n      file: settings.file || undefined,\n      location: false,\n      schema: settings.space === 'svg' ? svg : html,\n      verbose: settings.verbose || false\n    },\n    tree\n  )\n}\n\n/**\n * Transform a node.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {P5Node} node\n *   p5 node.\n * @returns {Nodes}\n *   hast node.\n */\nfunction one(state, node) {\n  /** @type {Nodes} */\n  let result\n\n  switch (node.nodeName) {\n    case '#comment': {\n      const reference = /** @type {P5Comment} */ (node)\n      result = {type: 'comment', value: reference.data}\n      patch(state, reference, result)\n      return result\n    }\n\n    case '#document':\n    case '#document-fragment': {\n      const reference = /** @type {P5Document | P5DocumentFragment} */ (node)\n      const quirksMode =\n        'mode' in reference\n          ? reference.mode === 'quirks' || reference.mode === 'limited-quirks'\n          : false\n\n      result = {\n        type: 'root',\n        children: all(state, node.childNodes),\n        data: {quirksMode}\n      }\n\n      if (state.file && state.location) {\n        const doc = String(state.file)\n        const loc = location(doc)\n        const start = loc.toPoint(0)\n        const end = loc.toPoint(doc.length)\n        // Always defined as we give valid input.\n        assert(start, 'expected `start`')\n        assert(end, 'expected `end`')\n        result.position = {start, end}\n      }\n\n      return result\n    }\n\n    case '#documentType': {\n      const reference = /** @type {P5DocumentType} */ (node)\n      result = {type: 'doctype'}\n      patch(state, reference, result)\n      return result\n    }\n\n    case '#text': {\n      const reference = /** @type {P5Text} */ (node)\n      result = {type: 'text', value: reference.value}\n      patch(state, reference, result)\n      return result\n    }\n\n    // Element.\n    default: {\n      const reference = /** @type {P5Element} */ (node)\n      result = element(state, reference)\n      return result\n    }\n  }\n}\n\n/**\n * Transform children.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Array<P5Node>} nodes\n *   Nodes.\n * @returns {Array<RootContent>}\n *   hast nodes.\n */\nfunction all(state, nodes) {\n  let index = -1\n  /** @type {Array<RootContent>} */\n  const results = []\n\n  while (++index < nodes.length) {\n    // Assume no roots in `nodes`.\n    const result = /** @type {RootContent} */ (one(state, nodes[index]))\n    results.push(result)\n  }\n\n  return results\n}\n\n/**\n * Transform an element.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {P5Element} node\n *   `parse5` node to transform.\n * @returns {Element}\n *   hast node.\n */\nfunction element(state, node) {\n  const schema = state.schema\n\n  state.schema = node.namespaceURI === webNamespaces.svg ? svg : html\n\n  // Props.\n  let index = -1\n  /** @type {Record<string, string>} */\n  const props = {}\n\n  while (++index < node.attrs.length) {\n    const attribute = node.attrs[index]\n    const name =\n      (attribute.prefix ? attribute.prefix + ':' : '') + attribute.name\n    if (!own.call(proto, name)) {\n      props[name] = attribute.value\n    }\n  }\n\n  // Build.\n  const fn = state.schema.space === 'svg' ? s : h\n  const result = fn(node.tagName, props, all(state, node.childNodes))\n  patch(state, node, result)\n\n  // Switch content.\n  if (result.tagName === 'template') {\n    const reference = /** @type {P5Template} */ (node)\n    const pos = reference.sourceCodeLocation\n    const startTag = pos && pos.startTag && position(pos.startTag)\n    const endTag = pos && pos.endTag && position(pos.endTag)\n\n    // Root in, root out.\n    const content = /** @type {Root} */ (one(state, reference.content))\n\n    if (startTag && endTag && state.file) {\n      content.position = {start: startTag.end, end: endTag.start}\n    }\n\n    result.content = content\n  }\n\n  state.schema = schema\n\n  return result\n}\n\n/**\n * Patch positional info from `from` onto `to`.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {P5Node} from\n *   p5 node.\n * @param {Nodes} to\n *   hast node.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(state, from, to) {\n  if ('sourceCodeLocation' in from && from.sourceCodeLocation && state.file) {\n    const position = createLocation(state, to, from.sourceCodeLocation)\n\n    if (position) {\n      state.location = true\n      to.position = position\n    }\n  }\n}\n\n/**\n * Create clean positional information.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Nodes} node\n *   hast node.\n * @param {P5ElementLocation} location\n *   p5 location info.\n * @returns {Position | undefined}\n *   Position, or nothing.\n */\nfunction createLocation(state, 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 (state.verbose) {\n      /** @type {Record<string, Position | undefined>} */\n      const props = {}\n      /** @type {string} */\n      let key\n\n      if (location.attrs) {\n        for (key in location.attrs) {\n          if (own.call(location.attrs, key)) {\n            props[find(state.schema, key).property] = position(\n              location.attrs[key]\n            )\n          }\n        }\n      }\n\n      assert(location.startTag, 'a start tag should exist')\n      const opening = position(location.startTag)\n      const closing = location.endTag ? position(location.endTag) : undefined\n      /** @type {ElementData['position']} */\n      const data = {opening}\n      if (closing) data.closing = closing\n      data.properties = props\n\n      node.data = {position: data}\n    }\n  }\n\n  return result\n}\n\n/**\n * Turn a p5 location into a position.\n *\n * @param {P5Location} loc\n *   Location.\n * @returns {Position | undefined}\n *   Position or nothing.\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\n  // @ts-expect-error: we do use `undefined` for points if one or the other\n  // exists.\n  return start || end ? {start, end} : undefined\n}\n\n/**\n * Filter out invalid points.\n *\n * @param {Point} point\n *   Point with potentially `undefined` values.\n * @returns {Point | undefined}\n *   Point or nothing.\n */\nfunction point(point) {\n  return point.line && point.column ? point : undefined\n}\n","/**\n * @callback Handler\n *   Handle a value, with a certain ID field set to a certain value.\n *   The ID field is passed to `zwitch`, and it’s value is this function’s\n *   place on the `handlers` record.\n * @param {...any} parameters\n *   Arbitrary parameters passed to the zwitch.\n *   The first will be an object with a certain ID field set to a certain value.\n * @returns {any}\n *   Anything!\n */\n\n/**\n * @callback UnknownHandler\n *   Handle values that do have a certain ID field, but it’s set to a value\n *   that is not listed in the `handlers` record.\n * @param {unknown} value\n *   An object with a certain ID field set to an unknown value.\n * @param {...any} rest\n *   Arbitrary parameters passed to the zwitch.\n * @returns {any}\n *   Anything!\n */\n\n/**\n * @callback InvalidHandler\n *   Handle values that do not have a certain ID field.\n * @param {unknown} value\n *   Any unknown value.\n * @param {...any} rest\n *   Arbitrary parameters passed to the zwitch.\n * @returns {void|null|undefined|never}\n *   This should crash or return nothing.\n */\n\n/**\n * @template {InvalidHandler} [Invalid=InvalidHandler]\n * @template {UnknownHandler} [Unknown=UnknownHandler]\n * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]\n * @typedef Options\n *   Configuration (required).\n * @property {Invalid} [invalid]\n *   Handler to use for invalid values.\n * @property {Unknown} [unknown]\n *   Handler to use for unknown values.\n * @property {Handlers} [handlers]\n *   Handlers to use.\n */\n\nconst own = {}.hasOwnProperty\n\n/**\n * Handle values based on a field.\n *\n * @template {InvalidHandler} [Invalid=InvalidHandler]\n * @template {UnknownHandler} [Unknown=UnknownHandler]\n * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]\n * @param {string} key\n *   Field to switch on.\n * @param {Options<Invalid, Unknown, Handlers>} [options]\n *   Configuration (required).\n * @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters<Handlers[keyof Handlers]>): ReturnType<Handlers[keyof Handlers]>, (...parameters: Parameters<Unknown>): ReturnType<Unknown>}}\n */\nexport function zwitch(key, options) {\n  const settings = options || {}\n\n  /**\n   * Handle one value.\n   *\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   * @this {unknown}\n   *   Any context object.\n   * @param {unknown} [value]\n   *   Any value.\n   * @param {...unknown} parameters\n   *   Arbitrary parameters passed to the zwitch.\n   * @property {Handler} invalid\n   *   Handle for values that do not have a certain ID field.\n   * @property {Handler} unknown\n   *   Handle values that do have a certain ID field, but it’s set to a value\n   *   that is not listed in the `handlers` record.\n   * @property {Handlers} handlers\n   *   Record of handlers.\n   * @returns {unknown}\n   *   Anything.\n   */\n  function one(value, ...parameters) {\n    /** @type {Handler|undefined} */\n    let fn = one.invalid\n    const handlers = one.handlers\n\n    if (value && own.call(value, key)) {\n      // @ts-expect-error Indexable.\n      const id = String(value[key])\n      // @ts-expect-error Indexable.\n      fn = own.call(handlers, id) ? handlers[id] : one.unknown\n    }\n\n    if (fn) {\n      return fn.call(this, value, ...parameters)\n    }\n  }\n\n  one.handlers = settings.handlers || {}\n  one.invalid = settings.invalid\n  one.unknown = settings.unknown\n\n  // @ts-expect-error: matches!\n  return one\n}\n","/**\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Doctype} Doctype\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').RootContent} RootContent\n * @typedef {import('hast').Text} Text\n *\n * @typedef {import('parse5').DefaultTreeAdapterMap['document']} Parse5Document\n * @typedef {import('parse5').DefaultTreeAdapterMap['documentFragment']} Parse5Fragment\n * @typedef {import('parse5').DefaultTreeAdapterMap['element']} Parse5Element\n * @typedef {import('parse5').DefaultTreeAdapterMap['node']} Parse5Nodes\n * @typedef {import('parse5').DefaultTreeAdapterMap['documentType']} Parse5Doctype\n * @typedef {import('parse5').DefaultTreeAdapterMap['commentNode']} Parse5Comment\n * @typedef {import('parse5').DefaultTreeAdapterMap['textNode']} Parse5Text\n * @typedef {import('parse5').DefaultTreeAdapterMap['parentNode']} Parse5Parent\n * @typedef {import('parse5').Token.Attribute} Parse5Attribute\n *\n * @typedef {import('property-information').Schema} Schema\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {Space | null | undefined} [space='html']\n *   Which space the document is in (default: `'html'`).\n *\n *   When an `<svg>` element is found in the HTML space, this package already\n *   automatically switches to and from the SVG space when entering and exiting\n *   it.\n *\n * @typedef {Exclude<Parse5Nodes, Parse5Document | Parse5Fragment>} Parse5Content\n *\n * @typedef {'html' | 'svg'} Space\n */\n\nimport {stringify as commas} from 'comma-separated-tokens'\nimport {ok as assert} from 'devlop'\nimport {find, html, svg} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {webNamespaces} from 'web-namespaces'\nimport {zwitch} from 'zwitch'\n\n/** @type {Options} */\nconst emptyOptions = {}\n\nconst own = {}.hasOwnProperty\n\nconst one = zwitch('type', {handlers: {root, element, text, comment, doctype}})\n\n/**\n * Transform a hast tree to a `parse5` AST.\n *\n * @param {Nodes} tree\n *   Tree to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {Parse5Nodes}\n *   `parse5` node.\n */\nexport function toParse5(tree, options) {\n  const settings = options || emptyOptions\n  const space = settings.space\n  return one(tree, space === 'svg' ? svg : html)\n}\n\n/**\n * @param {Root} node\n *   Node (hast) to transform.\n * @param {Schema} schema\n *   Current schema.\n * @returns {Parse5Document}\n *   Parse5 node.\n */\nfunction root(node, schema) {\n  /** @type {Parse5Document} */\n  const result = {\n    nodeName: '#document',\n    // @ts-expect-error: `parse5` uses enums, which are actually strings.\n    mode: (node.data || {}).quirksMode ? 'quirks' : 'no-quirks',\n    childNodes: []\n  }\n  result.childNodes = all(node.children, result, schema)\n  patch(node, result)\n  return result\n}\n\n/**\n * @param {Root} node\n *   Node (hast) to transform.\n * @param {Schema} schema\n *   Current schema.\n * @returns {Parse5Fragment}\n *   Parse5 node.\n */\nfunction fragment(node, schema) {\n  /** @type {Parse5Fragment} */\n  const result = {nodeName: '#document-fragment', childNodes: []}\n  result.childNodes = all(node.children, result, schema)\n  patch(node, result)\n  return result\n}\n\n/**\n * @param {Doctype} node\n *   Node (hast) to transform.\n * @returns {Parse5Doctype}\n *   Parse5 node.\n */\nfunction doctype(node) {\n  /** @type {Parse5Doctype} */\n  const result = {\n    nodeName: '#documentType',\n    name: 'html',\n    publicId: '',\n    systemId: '',\n    parentNode: null\n  }\n\n  patch(node, result)\n  return result\n}\n\n/**\n * @param {Text} node\n *   Node (hast) to transform.\n * @returns {Parse5Text}\n *   Parse5 node.\n */\nfunction text(node) {\n  /** @type {Parse5Text} */\n  const result = {\n    nodeName: '#text',\n    value: node.value,\n    parentNode: null\n  }\n  patch(node, result)\n  return result\n}\n\n/**\n * @param {Comment} node\n *   Node (hast) to transform.\n * @returns {Parse5Comment}\n *   Parse5 node.\n */\nfunction comment(node) {\n  /** @type {Parse5Comment} */\n  const result = {\n    nodeName: '#comment',\n    data: node.value,\n    parentNode: null\n  }\n\n  patch(node, result)\n\n  return result\n}\n\n/**\n * @param {Element} node\n *   Node (hast) to transform.\n * @param {Schema} schema\n *   Current schema.\n * @returns {Parse5Element}\n *   Parse5 node.\n */\nfunction element(node, schema) {\n  const parentSchema = schema\n  let currentSchema = parentSchema\n\n  if (\n    node.type === 'element' &&\n    node.tagName.toLowerCase() === 'svg' &&\n    parentSchema.space === 'html'\n  ) {\n    currentSchema = svg\n  }\n\n  /** @type {Array<Parse5Attribute>} */\n  const attrs = []\n  /** @type {string} */\n  let prop\n\n  if (node.properties) {\n    for (prop in node.properties) {\n      if (prop !== 'children' && own.call(node.properties, prop)) {\n        const result = createProperty(\n          currentSchema,\n          prop,\n          node.properties[prop]\n        )\n\n        if (result) {\n          attrs.push(result)\n        }\n      }\n    }\n  }\n\n  const space = currentSchema.space\n  // `html` and `svg` both have a space.\n  assert(space)\n\n  /** @type {Parse5Element} */\n  const result = {\n    nodeName: node.tagName,\n    tagName: node.tagName,\n    attrs,\n    // @ts-expect-error: `parse5` types are wrong.\n    namespaceURI: webNamespaces[space],\n    childNodes: [],\n    parentNode: null\n  }\n  result.childNodes = all(node.children, result, currentSchema)\n  patch(node, result)\n\n  if (node.tagName === 'template' && node.content) {\n    // @ts-expect-error: `parse5` types are wrong.\n    result.content = fragment(node.content, currentSchema)\n  }\n\n  return result\n}\n\n/**\n * Handle a property.\n *\n * @param {Schema} schema\n *   Current schema.\n * @param {string} prop\n *   Key.\n * @param {Array<number | string> | boolean | number | string | null | undefined} value\n *   hast property value.\n * @returns {Parse5Attribute | undefined}\n *   Field for runtime, optional.\n */\nfunction createProperty(schema, prop, value) {\n  const info = find(schema, prop)\n\n  // Ignore nullish and `NaN` values.\n  if (\n    value === false ||\n    value === null ||\n    value === undefined ||\n    (typeof value === 'number' && Number.isNaN(value)) ||\n    (!value && info.boolean)\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  /** @type {Parse5Attribute} */\n  const attribute = {\n    name: info.attribute,\n    value: value === true ? '' : String(value)\n  }\n\n  if (info.space && info.space !== 'html' && info.space !== 'svg') {\n    const index = attribute.name.indexOf(':')\n\n    if (index < 0) {\n      attribute.prefix = ''\n    } else {\n      attribute.name = attribute.name.slice(index + 1)\n      attribute.prefix = info.attribute.slice(0, index)\n    }\n\n    attribute.namespace = webNamespaces[info.space]\n  }\n\n  return attribute\n}\n\n/**\n * Transform all hast nodes.\n *\n * @param {Array<RootContent>} children\n *   List of children.\n * @param {Parse5Parent} parentNode\n *   `parse5` parent node.\n * @param {Schema} schema\n *   Current schema.\n * @returns {Array<Parse5Content>}\n *   Transformed children.\n */\nfunction all(children, parentNode, schema) {\n  let index = -1\n  /** @type {Array<Parse5Content>} */\n  const results = []\n\n  if (children) {\n    while (++index < children.length) {\n      /** @type {Parse5Content} */\n      const child = one(children[index], schema)\n\n      child.parentNode = parentNode\n\n      results.push(child)\n    }\n  }\n\n  return results\n}\n\n/**\n * Add position info from `from` to `to`.\n *\n * @param {Nodes} from\n *   hast node.\n * @param {Parse5Nodes} to\n *   `parse5` node.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  const position = from.position\n\n  if (position && position.start && position.end) {\n    assert(typeof position.start.offset === 'number')\n    assert(typeof position.end.offset === 'number')\n\n    to.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","/**\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  'keygen',\n  'link',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr'\n]\n","const UNDEFINED_CODE_POINTS = new Set([\n    65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214,\n    393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894,\n    720895, 786430, 786431, 851966, 851967, 917502, 917503, 983038, 983039, 1048574,\n    1048575, 1114110, 1114111,\n]);\nexport const REPLACEMENT_CHARACTER = '\\uFFFD';\nexport var CODE_POINTS;\n(function (CODE_POINTS) {\n    CODE_POINTS[CODE_POINTS[\"EOF\"] = -1] = \"EOF\";\n    CODE_POINTS[CODE_POINTS[\"NULL\"] = 0] = \"NULL\";\n    CODE_POINTS[CODE_POINTS[\"TABULATION\"] = 9] = \"TABULATION\";\n    CODE_POINTS[CODE_POINTS[\"CARRIAGE_RETURN\"] = 13] = \"CARRIAGE_RETURN\";\n    CODE_POINTS[CODE_POINTS[\"LINE_FEED\"] = 10] = \"LINE_FEED\";\n    CODE_POINTS[CODE_POINTS[\"FORM_FEED\"] = 12] = \"FORM_FEED\";\n    CODE_POINTS[CODE_POINTS[\"SPACE\"] = 32] = \"SPACE\";\n    CODE_POINTS[CODE_POINTS[\"EXCLAMATION_MARK\"] = 33] = \"EXCLAMATION_MARK\";\n    CODE_POINTS[CODE_POINTS[\"QUOTATION_MARK\"] = 34] = \"QUOTATION_MARK\";\n    CODE_POINTS[CODE_POINTS[\"NUMBER_SIGN\"] = 35] = \"NUMBER_SIGN\";\n    CODE_POINTS[CODE_POINTS[\"AMPERSAND\"] = 38] = \"AMPERSAND\";\n    CODE_POINTS[CODE_POINTS[\"APOSTROPHE\"] = 39] = \"APOSTROPHE\";\n    CODE_POINTS[CODE_POINTS[\"HYPHEN_MINUS\"] = 45] = \"HYPHEN_MINUS\";\n    CODE_POINTS[CODE_POINTS[\"SOLIDUS\"] = 47] = \"SOLIDUS\";\n    CODE_POINTS[CODE_POINTS[\"DIGIT_0\"] = 48] = \"DIGIT_0\";\n    CODE_POINTS[CODE_POINTS[\"DIGIT_9\"] = 57] = \"DIGIT_9\";\n    CODE_POINTS[CODE_POINTS[\"SEMICOLON\"] = 59] = \"SEMICOLON\";\n    CODE_POINTS[CODE_POINTS[\"LESS_THAN_SIGN\"] = 60] = \"LESS_THAN_SIGN\";\n    CODE_POINTS[CODE_POINTS[\"EQUALS_SIGN\"] = 61] = \"EQUALS_SIGN\";\n    CODE_POINTS[CODE_POINTS[\"GREATER_THAN_SIGN\"] = 62] = \"GREATER_THAN_SIGN\";\n    CODE_POINTS[CODE_POINTS[\"QUESTION_MARK\"] = 63] = \"QUESTION_MARK\";\n    CODE_POINTS[CODE_POINTS[\"LATIN_CAPITAL_A\"] = 65] = \"LATIN_CAPITAL_A\";\n    CODE_POINTS[CODE_POINTS[\"LATIN_CAPITAL_F\"] = 70] = \"LATIN_CAPITAL_F\";\n    CODE_POINTS[CODE_POINTS[\"LATIN_CAPITAL_X\"] = 88] = \"LATIN_CAPITAL_X\";\n    CODE_POINTS[CODE_POINTS[\"LATIN_CAPITAL_Z\"] = 90] = \"LATIN_CAPITAL_Z\";\n    CODE_POINTS[CODE_POINTS[\"RIGHT_SQUARE_BRACKET\"] = 93] = \"RIGHT_SQUARE_BRACKET\";\n    CODE_POINTS[CODE_POINTS[\"GRAVE_ACCENT\"] = 96] = \"GRAVE_ACCENT\";\n    CODE_POINTS[CODE_POINTS[\"LATIN_SMALL_A\"] = 97] = \"LATIN_SMALL_A\";\n    CODE_POINTS[CODE_POINTS[\"LATIN_SMALL_F\"] = 102] = \"LATIN_SMALL_F\";\n    CODE_POINTS[CODE_POINTS[\"LATIN_SMALL_X\"] = 120] = \"LATIN_SMALL_X\";\n    CODE_POINTS[CODE_POINTS[\"LATIN_SMALL_Z\"] = 122] = \"LATIN_SMALL_Z\";\n    CODE_POINTS[CODE_POINTS[\"REPLACEMENT_CHARACTER\"] = 65533] = \"REPLACEMENT_CHARACTER\";\n})(CODE_POINTS = CODE_POINTS || (CODE_POINTS = {}));\nexport const SEQUENCES = {\n    DASH_DASH: '--',\n    CDATA_START: '[CDATA[',\n    DOCTYPE: 'doctype',\n    SCRIPT: 'script',\n    PUBLIC: 'public',\n    SYSTEM: 'system',\n};\n//Surrogates\nexport function isSurrogate(cp) {\n    return cp >= 55296 && cp <= 57343;\n}\nexport function isSurrogatePair(cp) {\n    return cp >= 56320 && cp <= 57343;\n}\nexport function getSurrogatePairCodePoint(cp1, cp2) {\n    return (cp1 - 55296) * 1024 + 9216 + cp2;\n}\n//NOTE: excluding NULL and ASCII whitespace\nexport function isControlCodePoint(cp) {\n    return ((cp !== 0x20 && cp !== 0x0a && cp !== 0x0d && cp !== 0x09 && cp !== 0x0c && cp >= 0x01 && cp <= 0x1f) ||\n        (cp >= 0x7f && cp <= 0x9f));\n}\nexport function isUndefinedCodePoint(cp) {\n    return (cp >= 64976 && cp <= 65007) || UNDEFINED_CODE_POINTS.has(cp);\n}\n//# sourceMappingURL=unicode.js.map","export var ERR;\n(function (ERR) {\n    ERR[\"controlCharacterInInputStream\"] = \"control-character-in-input-stream\";\n    ERR[\"noncharacterInInputStream\"] = \"noncharacter-in-input-stream\";\n    ERR[\"surrogateInInputStream\"] = \"surrogate-in-input-stream\";\n    ERR[\"nonVoidHtmlElementStartTagWithTrailingSolidus\"] = \"non-void-html-element-start-tag-with-trailing-solidus\";\n    ERR[\"endTagWithAttributes\"] = \"end-tag-with-attributes\";\n    ERR[\"endTagWithTrailingSolidus\"] = \"end-tag-with-trailing-solidus\";\n    ERR[\"unexpectedSolidusInTag\"] = \"unexpected-solidus-in-tag\";\n    ERR[\"unexpectedNullCharacter\"] = \"unexpected-null-character\";\n    ERR[\"unexpectedQuestionMarkInsteadOfTagName\"] = \"unexpected-question-mark-instead-of-tag-name\";\n    ERR[\"invalidFirstCharacterOfTagName\"] = \"invalid-first-character-of-tag-name\";\n    ERR[\"unexpectedEqualsSignBeforeAttributeName\"] = \"unexpected-equals-sign-before-attribute-name\";\n    ERR[\"missingEndTagName\"] = \"missing-end-tag-name\";\n    ERR[\"unexpectedCharacterInAttributeName\"] = \"unexpected-character-in-attribute-name\";\n    ERR[\"unknownNamedCharacterReference\"] = \"unknown-named-character-reference\";\n    ERR[\"missingSemicolonAfterCharacterReference\"] = \"missing-semicolon-after-character-reference\";\n    ERR[\"unexpectedCharacterAfterDoctypeSystemIdentifier\"] = \"unexpected-character-after-doctype-system-identifier\";\n    ERR[\"unexpectedCharacterInUnquotedAttributeValue\"] = \"unexpected-character-in-unquoted-attribute-value\";\n    ERR[\"eofBeforeTagName\"] = \"eof-before-tag-name\";\n    ERR[\"eofInTag\"] = \"eof-in-tag\";\n    ERR[\"missingAttributeValue\"] = \"missing-attribute-value\";\n    ERR[\"missingWhitespaceBetweenAttributes\"] = \"missing-whitespace-between-attributes\";\n    ERR[\"missingWhitespaceAfterDoctypePublicKeyword\"] = \"missing-whitespace-after-doctype-public-keyword\";\n    ERR[\"missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers\"] = \"missing-whitespace-between-doctype-public-and-system-identifiers\";\n    ERR[\"missingWhitespaceAfterDoctypeSystemKeyword\"] = \"missing-whitespace-after-doctype-system-keyword\";\n    ERR[\"missingQuoteBeforeDoctypePublicIdentifier\"] = \"missing-quote-before-doctype-public-identifier\";\n    ERR[\"missingQuoteBeforeDoctypeSystemIdentifier\"] = \"missing-quote-before-doctype-system-identifier\";\n    ERR[\"missingDoctypePublicIdentifier\"] = \"missing-doctype-public-identifier\";\n    ERR[\"missingDoctypeSystemIdentifier\"] = \"missing-doctype-system-identifier\";\n    ERR[\"abruptDoctypePublicIdentifier\"] = \"abrupt-doctype-public-identifier\";\n    ERR[\"abruptDoctypeSystemIdentifier\"] = \"abrupt-doctype-system-identifier\";\n    ERR[\"cdataInHtmlContent\"] = \"cdata-in-html-content\";\n    ERR[\"incorrectlyOpenedComment\"] = \"incorrectly-opened-comment\";\n    ERR[\"eofInScriptHtmlCommentLikeText\"] = \"eof-in-script-html-comment-like-text\";\n    ERR[\"eofInDoctype\"] = \"eof-in-doctype\";\n    ERR[\"nestedComment\"] = \"nested-comment\";\n    ERR[\"abruptClosingOfEmptyComment\"] = \"abrupt-closing-of-empty-comment\";\n    ERR[\"eofInComment\"] = \"eof-in-comment\";\n    ERR[\"incorrectlyClosedComment\"] = \"incorrectly-closed-comment\";\n    ERR[\"eofInCdata\"] = \"eof-in-cdata\";\n    ERR[\"absenceOfDigitsInNumericCharacterReference\"] = \"absence-of-digits-in-numeric-character-reference\";\n    ERR[\"nullCharacterReference\"] = \"null-character-reference\";\n    ERR[\"surrogateCharacterReference\"] = \"surrogate-character-reference\";\n    ERR[\"characterReferenceOutsideUnicodeRange\"] = \"character-reference-outside-unicode-range\";\n    ERR[\"controlCharacterReference\"] = \"control-character-reference\";\n    ERR[\"noncharacterCharacterReference\"] = \"noncharacter-character-reference\";\n    ERR[\"missingWhitespaceBeforeDoctypeName\"] = \"missing-whitespace-before-doctype-name\";\n    ERR[\"missingDoctypeName\"] = \"missing-doctype-name\";\n    ERR[\"invalidCharacterSequenceAfterDoctypeName\"] = \"invalid-character-sequence-after-doctype-name\";\n    ERR[\"duplicateAttribute\"] = \"duplicate-attribute\";\n    ERR[\"nonConformingDoctype\"] = \"non-conforming-doctype\";\n    ERR[\"missingDoctype\"] = \"missing-doctype\";\n    ERR[\"misplacedDoctype\"] = \"misplaced-doctype\";\n    ERR[\"endTagWithoutMatchingOpenElement\"] = \"end-tag-without-matching-open-element\";\n    ERR[\"closingOfElementWithOpenChildElements\"] = \"closing-of-element-with-open-child-elements\";\n    ERR[\"disallowedContentInNoscriptInHead\"] = \"disallowed-content-in-noscript-in-head\";\n    ERR[\"openElementsLeftAfterEof\"] = \"open-elements-left-after-eof\";\n    ERR[\"abandonedHeadElementChild\"] = \"abandoned-head-element-child\";\n    ERR[\"misplacedStartTagForHeadElement\"] = \"misplaced-start-tag-for-head-element\";\n    ERR[\"nestedNoscriptInHead\"] = \"nested-noscript-in-head\";\n    ERR[\"eofInElementThatCanContainOnlyText\"] = \"eof-in-element-that-can-contain-only-text\";\n})(ERR = ERR || (ERR = {}));\n//# sourceMappingURL=error-codes.js.map","import { CODE_POINTS as $, getSurrogatePairCodePoint, isControlCodePoint, isSurrogate, isSurrogatePair, isUndefinedCodePoint, } from '../common/unicode.js';\nimport { ERR } from '../common/error-codes.js';\n//Const\nconst DEFAULT_BUFFER_WATERLINE = 1 << 16;\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)\nexport class Preprocessor {\n    constructor(handler) {\n        this.handler = handler;\n        this.html = '';\n        this.pos = -1;\n        // NOTE: Initial `lastGapPos` is -2, to ensure `col` on initialisation is 0\n        this.lastGapPos = -2;\n        this.gapStack = [];\n        this.skipNextNewLine = false;\n        this.lastChunkWritten = false;\n        this.endOfChunkHit = false;\n        this.bufferWaterline = DEFAULT_BUFFER_WATERLINE;\n        this.isEol = false;\n        this.lineStartPos = 0;\n        this.droppedBufferSize = 0;\n        this.line = 1;\n        //NOTE: avoid reporting errors twice on advance/retreat\n        this.lastErrOffset = -1;\n    }\n    /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */\n    get col() {\n        return this.pos - this.lineStartPos + Number(this.lastGapPos !== this.pos);\n    }\n    get offset() {\n        return this.droppedBufferSize + this.pos;\n    }\n    getError(code) {\n        const { line, col, offset } = this;\n        return {\n            code,\n            startLine: line,\n            endLine: line,\n            startCol: col,\n            endCol: col,\n            startOffset: offset,\n            endOffset: offset,\n        };\n    }\n    _err(code) {\n        if (this.handler.onParseError && this.lastErrOffset !== this.offset) {\n            this.lastErrOffset = this.offset;\n            this.handler.onParseError(this.getError(code));\n        }\n    }\n    _addGap() {\n        this.gapStack.push(this.lastGapPos);\n        this.lastGapPos = this.pos;\n    }\n    _processSurrogate(cp) {\n        //NOTE: try to peek a surrogate pair\n        if (this.pos !== this.html.length - 1) {\n            const nextCp = this.html.charCodeAt(this.pos + 1);\n            if (isSurrogatePair(nextCp)) {\n                //NOTE: we have a surrogate pair. Peek pair character and recalculate code point.\n                this.pos++;\n                //NOTE: add a gap that should be avoided during retreat\n                this._addGap();\n                return getSurrogatePairCodePoint(cp, nextCp);\n            }\n        }\n        //NOTE: we are at the end of a chunk, therefore we can't infer the surrogate pair yet.\n        else if (!this.lastChunkWritten) {\n            this.endOfChunkHit = true;\n            return $.EOF;\n        }\n        //NOTE: isolated surrogate\n        this._err(ERR.surrogateInInputStream);\n        return cp;\n    }\n    willDropParsedChunk() {\n        return this.pos > this.bufferWaterline;\n    }\n    dropParsedChunk() {\n        if (this.willDropParsedChunk()) {\n            this.html = this.html.substring(this.pos);\n            this.lineStartPos -= this.pos;\n            this.droppedBufferSize += this.pos;\n            this.pos = 0;\n            this.lastGapPos = -2;\n            this.gapStack.length = 0;\n        }\n    }\n    write(chunk, isLastChunk) {\n        if (this.html.length > 0) {\n            this.html += chunk;\n        }\n        else {\n            this.html = chunk;\n        }\n        this.endOfChunkHit = false;\n        this.lastChunkWritten = isLastChunk;\n    }\n    insertHtmlAtCurrentPos(chunk) {\n        this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1);\n        this.endOfChunkHit = false;\n    }\n    startsWith(pattern, caseSensitive) {\n        // Check if our buffer has enough characters\n        if (this.pos + pattern.length > this.html.length) {\n            this.endOfChunkHit = !this.lastChunkWritten;\n            return false;\n        }\n        if (caseSensitive) {\n            return this.html.startsWith(pattern, this.pos);\n        }\n        for (let i = 0; i < pattern.length; i++) {\n            const cp = this.html.charCodeAt(this.pos + i) | 0x20;\n            if (cp !== pattern.charCodeAt(i)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    peek(offset) {\n        const pos = this.pos + offset;\n        if (pos >= this.html.length) {\n            this.endOfChunkHit = !this.lastChunkWritten;\n            return $.EOF;\n        }\n        const code = this.html.charCodeAt(pos);\n        return code === $.CARRIAGE_RETURN ? $.LINE_FEED : code;\n    }\n    advance() {\n        this.pos++;\n        //NOTE: LF should be in the last column of the line\n        if (this.isEol) {\n            this.isEol = false;\n            this.line++;\n            this.lineStartPos = this.pos;\n        }\n        if (this.pos >= this.html.length) {\n            this.endOfChunkHit = !this.lastChunkWritten;\n            return $.EOF;\n        }\n        let cp = this.html.charCodeAt(this.pos);\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.isEol = true;\n            this.skipNextNewLine = true;\n            return $.LINE_FEED;\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 (cp === $.LINE_FEED) {\n            this.isEol = true;\n            if (this.skipNextNewLine) {\n                // `line` will be bumped again in the recursive call.\n                this.line--;\n                this.skipNextNewLine = false;\n                this._addGap();\n                return this.advance();\n            }\n        }\n        this.skipNextNewLine = false;\n        if (isSurrogate(cp)) {\n            cp = this._processSurrogate(cp);\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 = this.handler.onParseError === null ||\n            (cp > 0x1f && cp < 0x7f) ||\n            cp === $.LINE_FEED ||\n            cp === $.CARRIAGE_RETURN ||\n            (cp > 0x9f && cp < 64976);\n        if (!isCommonValidRange) {\n            this._checkForProblematicCharacters(cp);\n        }\n        return cp;\n    }\n    _checkForProblematicCharacters(cp) {\n        if (isControlCodePoint(cp)) {\n            this._err(ERR.controlCharacterInInputStream);\n        }\n        else if (isUndefinedCodePoint(cp)) {\n            this._err(ERR.noncharacterInInputStream);\n        }\n    }\n    retreat(count) {\n        this.pos -= count;\n        while (this.pos < this.lastGapPos) {\n            this.lastGapPos = this.gapStack.pop();\n            this.pos--;\n        }\n        this.isEol = false;\n    }\n}\n//# sourceMappingURL=preprocessor.js.map","export var TokenType;\n(function (TokenType) {\n    TokenType[TokenType[\"CHARACTER\"] = 0] = \"CHARACTER\";\n    TokenType[TokenType[\"NULL_CHARACTER\"] = 1] = \"NULL_CHARACTER\";\n    TokenType[TokenType[\"WHITESPACE_CHARACTER\"] = 2] = \"WHITESPACE_CHARACTER\";\n    TokenType[TokenType[\"START_TAG\"] = 3] = \"START_TAG\";\n    TokenType[TokenType[\"END_TAG\"] = 4] = \"END_TAG\";\n    TokenType[TokenType[\"COMMENT\"] = 5] = \"COMMENT\";\n    TokenType[TokenType[\"DOCTYPE\"] = 6] = \"DOCTYPE\";\n    TokenType[TokenType[\"EOF\"] = 7] = \"EOF\";\n    TokenType[TokenType[\"HIBERNATION\"] = 8] = \"HIBERNATION\";\n})(TokenType = TokenType || (TokenType = {}));\nexport function getTokenAttr(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    return null;\n}\n//# sourceMappingURL=token.js.map","// Generated using scripts/write-decode-map.ts\nexport default new Uint16Array(\n// prettier-ignore\n\"\\u1d41<\\xd5\\u0131\\u028a\\u049d\\u057b\\u05d0\\u0675\\u06de\\u07a2\\u07d6\\u080f\\u0a4a\\u0a91\\u0da1\\u0e6d\\u0f09\\u0f26\\u10ca\\u1228\\u12e1\\u1415\\u149d\\u14c3\\u14df\\u1525\\0\\0\\0\\0\\0\\0\\u156b\\u16cd\\u198d\\u1c12\\u1ddd\\u1f7e\\u2060\\u21b0\\u228d\\u23c0\\u23fb\\u2442\\u2824\\u2912\\u2d08\\u2e48\\u2fce\\u3016\\u32ba\\u3639\\u37ac\\u38fe\\u3a28\\u3a71\\u3ae0\\u3b2e\\u0800EMabcfglmnoprstu\\\\bfms\\x7f\\x84\\x8b\\x90\\x95\\x98\\xa6\\xb3\\xb9\\xc8\\xcflig\\u803b\\xc6\\u40c6P\\u803b&\\u4026cute\\u803b\\xc1\\u40c1reve;\\u4102\\u0100iyx}rc\\u803b\\xc2\\u40c2;\\u4410r;\\uc000\\ud835\\udd04rave\\u803b\\xc0\\u40c0pha;\\u4391acr;\\u4100d;\\u6a53\\u0100gp\\x9d\\xa1on;\\u4104f;\\uc000\\ud835\\udd38plyFunction;\\u6061ing\\u803b\\xc5\\u40c5\\u0100cs\\xbe\\xc3r;\\uc000\\ud835\\udc9cign;\\u6254ilde\\u803b\\xc3\\u40c3ml\\u803b\\xc4\\u40c4\\u0400aceforsu\\xe5\\xfb\\xfe\\u0117\\u011c\\u0122\\u0127\\u012a\\u0100cr\\xea\\xf2kslash;\\u6216\\u0176\\xf6\\xf8;\\u6ae7ed;\\u6306y;\\u4411\\u0180crt\\u0105\\u010b\\u0114ause;\\u6235noullis;\\u612ca;\\u4392r;\\uc000\\ud835\\udd05pf;\\uc000\\ud835\\udd39eve;\\u42d8c\\xf2\\u0113mpeq;\\u624e\\u0700HOacdefhilorsu\\u014d\\u0151\\u0156\\u0180\\u019e\\u01a2\\u01b5\\u01b7\\u01ba\\u01dc\\u0215\\u0273\\u0278\\u027ecy;\\u4427PY\\u803b\\xa9\\u40a9\\u0180cpy\\u015d\\u0162\\u017aute;\\u4106\\u0100;i\\u0167\\u0168\\u62d2talDifferentialD;\\u6145leys;\\u612d\\u0200aeio\\u0189\\u018e\\u0194\\u0198ron;\\u410cdil\\u803b\\xc7\\u40c7rc;\\u4108nint;\\u6230ot;\\u410a\\u0100dn\\u01a7\\u01adilla;\\u40b8terDot;\\u40b7\\xf2\\u017fi;\\u43a7rcle\\u0200DMPT\\u01c7\\u01cb\\u01d1\\u01d6ot;\\u6299inus;\\u6296lus;\\u6295imes;\\u6297o\\u0100cs\\u01e2\\u01f8kwiseContourIntegral;\\u6232eCurly\\u0100DQ\\u0203\\u020foubleQuote;\\u601duote;\\u6019\\u0200lnpu\\u021e\\u0228\\u0247\\u0255on\\u0100;e\\u0225\\u0226\\u6237;\\u6a74\\u0180git\\u022f\\u0236\\u023aruent;\\u6261nt;\\u622fourIntegral;\\u622e\\u0100fr\\u024c\\u024e;\\u6102oduct;\\u6210nterClockwiseContourIntegral;\\u6233oss;\\u6a2fcr;\\uc000\\ud835\\udc9ep\\u0100;C\\u0284\\u0285\\u62d3ap;\\u624d\\u0580DJSZacefios\\u02a0\\u02ac\\u02b0\\u02b4\\u02b8\\u02cb\\u02d7\\u02e1\\u02e6\\u0333\\u048d\\u0100;o\\u0179\\u02a5trahd;\\u6911cy;\\u4402cy;\\u4405cy;\\u440f\\u0180grs\\u02bf\\u02c4\\u02c7ger;\\u6021r;\\u61a1hv;\\u6ae4\\u0100ay\\u02d0\\u02d5ron;\\u410e;\\u4414l\\u0100;t\\u02dd\\u02de\\u6207a;\\u4394r;\\uc000\\ud835\\udd07\\u0100af\\u02eb\\u0327\\u0100cm\\u02f0\\u0322ritical\\u0200ADGT\\u0300\\u0306\\u0316\\u031ccute;\\u40b4o\\u0174\\u030b\\u030d;\\u42d9bleAcute;\\u42ddrave;\\u4060ilde;\\u42dcond;\\u62c4ferentialD;\\u6146\\u0470\\u033d\\0\\0\\0\\u0342\\u0354\\0\\u0405f;\\uc000\\ud835\\udd3b\\u0180;DE\\u0348\\u0349\\u034d\\u40a8ot;\\u60dcqual;\\u6250ble\\u0300CDLRUV\\u0363\\u0372\\u0382\\u03cf\\u03e2\\u03f8ontourIntegra\\xec\\u0239o\\u0274\\u0379\\0\\0\\u037b\\xbb\\u0349nArrow;\\u61d3\\u0100eo\\u0387\\u03a4ft\\u0180ART\\u0390\\u0396\\u03a1rrow;\\u61d0ightArrow;\\u61d4e\\xe5\\u02cang\\u0100LR\\u03ab\\u03c4eft\\u0100AR\\u03b3\\u03b9rrow;\\u67f8ightArrow;\\u67faightArrow;\\u67f9ight\\u0100AT\\u03d8\\u03derrow;\\u61d2ee;\\u62a8p\\u0241\\u03e9\\0\\0\\u03efrrow;\\u61d1ownArrow;\\u61d5erticalBar;\\u6225n\\u0300ABLRTa\\u0412\\u042a\\u0430\\u045e\\u047f\\u037crrow\\u0180;BU\\u041d\\u041e\\u0422\\u6193ar;\\u6913pArrow;\\u61f5reve;\\u4311eft\\u02d2\\u043a\\0\\u0446\\0\\u0450ightVector;\\u6950eeVector;\\u695eector\\u0100;B\\u0459\\u045a\\u61bdar;\\u6956ight\\u01d4\\u0467\\0\\u0471eeVector;\\u695fector\\u0100;B\\u047a\\u047b\\u61c1ar;\\u6957ee\\u0100;A\\u0486\\u0487\\u62a4rrow;\\u61a7\\u0100ct\\u0492\\u0497r;\\uc000\\ud835\\udc9frok;\\u4110\\u0800NTacdfglmopqstux\\u04bd\\u04c0\\u04c4\\u04cb\\u04de\\u04e2\\u04e7\\u04ee\\u04f5\\u0521\\u052f\\u0536\\u0552\\u055d\\u0560\\u0565G;\\u414aH\\u803b\\xd0\\u40d0cute\\u803b\\xc9\\u40c9\\u0180aiy\\u04d2\\u04d7\\u04dcron;\\u411arc\\u803b\\xca\\u40ca;\\u442dot;\\u4116r;\\uc000\\ud835\\udd08rave\\u803b\\xc8\\u40c8ement;\\u6208\\u0100ap\\u04fa\\u04fecr;\\u4112ty\\u0253\\u0506\\0\\0\\u0512mallSquare;\\u65fberySmallSquare;\\u65ab\\u0100gp\\u0526\\u052aon;\\u4118f;\\uc000\\ud835\\udd3csilon;\\u4395u\\u0100ai\\u053c\\u0549l\\u0100;T\\u0542\\u0543\\u6a75ilde;\\u6242librium;\\u61cc\\u0100ci\\u0557\\u055ar;\\u6130m;\\u6a73a;\\u4397ml\\u803b\\xcb\\u40cb\\u0100ip\\u056a\\u056fsts;\\u6203onentialE;\\u6147\\u0280cfios\\u0585\\u0588\\u058d\\u05b2\\u05ccy;\\u4424r;\\uc000\\ud835\\udd09lled\\u0253\\u0597\\0\\0\\u05a3mallSquare;\\u65fcerySmallSquare;\\u65aa\\u0370\\u05ba\\0\\u05bf\\0\\0\\u05c4f;\\uc000\\ud835\\udd3dAll;\\u6200riertrf;\\u6131c\\xf2\\u05cb\\u0600JTabcdfgorst\\u05e8\\u05ec\\u05ef\\u05fa\\u0600\\u0612\\u0616\\u061b\\u061d\\u0623\\u066c\\u0672cy;\\u4403\\u803b>\\u403emma\\u0100;d\\u05f7\\u05f8\\u4393;\\u43dcreve;\\u411e\\u0180eiy\\u0607\\u060c\\u0610dil;\\u4122rc;\\u411c;\\u4413ot;\\u4120r;\\uc000\\ud835\\udd0a;\\u62d9pf;\\uc000\\ud835\\udd3eeater\\u0300EFGLST\\u0635\\u0644\\u064e\\u0656\\u065b\\u0666qual\\u0100;L\\u063e\\u063f\\u6265ess;\\u62dbullEqual;\\u6267reater;\\u6aa2ess;\\u6277lantEqual;\\u6a7eilde;\\u6273cr;\\uc000\\ud835\\udca2;\\u626b\\u0400Aacfiosu\\u0685\\u068b\\u0696\\u069b\\u069e\\u06aa\\u06be\\u06caRDcy;\\u442a\\u0100ct\\u0690\\u0694ek;\\u42c7;\\u405eirc;\\u4124r;\\u610clbertSpace;\\u610b\\u01f0\\u06af\\0\\u06b2f;\\u610dizontalLine;\\u6500\\u0100ct\\u06c3\\u06c5\\xf2\\u06a9rok;\\u4126mp\\u0144\\u06d0\\u06d8ownHum\\xf0\\u012fqual;\\u624f\\u0700EJOacdfgmnostu\\u06fa\\u06fe\\u0703\\u0707\\u070e\\u071a\\u071e\\u0721\\u0728\\u0744\\u0778\\u078b\\u078f\\u0795cy;\\u4415lig;\\u4132cy;\\u4401cute\\u803b\\xcd\\u40cd\\u0100iy\\u0713\\u0718rc\\u803b\\xce\\u40ce;\\u4418ot;\\u4130r;\\u6111rave\\u803b\\xcc\\u40cc\\u0180;ap\\u0720\\u072f\\u073f\\u0100cg\\u0734\\u0737r;\\u412ainaryI;\\u6148lie\\xf3\\u03dd\\u01f4\\u0749\\0\\u0762\\u0100;e\\u074d\\u074e\\u622c\\u0100gr\\u0753\\u0758ral;\\u622bsection;\\u62c2isible\\u0100CT\\u076c\\u0772omma;\\u6063imes;\\u6062\\u0180gpt\\u077f\\u0783\\u0788on;\\u412ef;\\uc000\\ud835\\udd40a;\\u4399cr;\\u6110ilde;\\u4128\\u01eb\\u079a\\0\\u079ecy;\\u4406l\\u803b\\xcf\\u40cf\\u0280cfosu\\u07ac\\u07b7\\u07bc\\u07c2\\u07d0\\u0100iy\\u07b1\\u07b5rc;\\u4134;\\u4419r;\\uc000\\ud835\\udd0dpf;\\uc000\\ud835\\udd41\\u01e3\\u07c7\\0\\u07ccr;\\uc000\\ud835\\udca5rcy;\\u4408kcy;\\u4404\\u0380HJacfos\\u07e4\\u07e8\\u07ec\\u07f1\\u07fd\\u0802\\u0808cy;\\u4425cy;\\u440cppa;\\u439a\\u0100ey\\u07f6\\u07fbdil;\\u4136;\\u441ar;\\uc000\\ud835\\udd0epf;\\uc000\\ud835\\udd42cr;\\uc000\\ud835\\udca6\\u0580JTaceflmost\\u0825\\u0829\\u082c\\u0850\\u0863\\u09b3\\u09b8\\u09c7\\u09cd\\u0a37\\u0a47cy;\\u4409\\u803b<\\u403c\\u0280cmnpr\\u0837\\u083c\\u0841\\u0844\\u084dute;\\u4139bda;\\u439bg;\\u67ealacetrf;\\u6112r;\\u619e\\u0180aey\\u0857\\u085c\\u0861ron;\\u413ddil;\\u413b;\\u441b\\u0100fs\\u0868\\u0970t\\u0500ACDFRTUVar\\u087e\\u08a9\\u08b1\\u08e0\\u08e6\\u08fc\\u092f\\u095b\\u0390\\u096a\\u0100nr\\u0883\\u088fgleBracket;\\u67e8row\\u0180;BR\\u0899\\u089a\\u089e\\u6190ar;\\u61e4ightArrow;\\u61c6eiling;\\u6308o\\u01f5\\u08b7\\0\\u08c3bleBracket;\\u67e6n\\u01d4\\u08c8\\0\\u08d2eeVector;\\u6961ector\\u0100;B\\u08db\\u08dc\\u61c3ar;\\u6959loor;\\u630aight\\u0100AV\\u08ef\\u08f5rrow;\\u6194ector;\\u694e\\u0100er\\u0901\\u0917e\\u0180;AV\\u0909\\u090a\\u0910\\u62a3rrow;\\u61a4ector;\\u695aiangle\\u0180;BE\\u0924\\u0925\\u0929\\u62b2ar;\\u69cfqual;\\u62b4p\\u0180DTV\\u0937\\u0942\\u094cownVector;\\u6951eeVector;\\u6960ector\\u0100;B\\u0956\\u0957\\u61bfar;\\u6958ector\\u0100;B\\u0965\\u0966\\u61bcar;\\u6952ight\\xe1\\u039cs\\u0300EFGLST\\u097e\\u098b\\u0995\\u099d\\u09a2\\u09adqualGreater;\\u62daullEqual;\\u6266reater;\\u6276ess;\\u6aa1lantEqual;\\u6a7dilde;\\u6272r;\\uc000\\ud835\\udd0f\\u0100;e\\u09bd\\u09be\\u62d8ftarrow;\\u61daidot;\\u413f\\u0180npw\\u09d4\\u0a16\\u0a1bg\\u0200LRlr\\u09de\\u09f7\\u0a02\\u0a10eft\\u0100AR\\u09e6\\u09ecrrow;\\u67f5ightArrow;\\u67f7ightArrow;\\u67f6eft\\u0100ar\\u03b3\\u0a0aight\\xe1\\u03bfight\\xe1\\u03caf;\\uc000\\ud835\\udd43er\\u0100LR\\u0a22\\u0a2ceftArrow;\\u6199ightArrow;\\u6198\\u0180cht\\u0a3e\\u0a40\\u0a42\\xf2\\u084c;\\u61b0rok;\\u4141;\\u626a\\u0400acefiosu\\u0a5a\\u0a5d\\u0a60\\u0a77\\u0a7c\\u0a85\\u0a8b\\u0a8ep;\\u6905y;\\u441c\\u0100dl\\u0a65\\u0a6fiumSpace;\\u605flintrf;\\u6133r;\\uc000\\ud835\\udd10nusPlus;\\u6213pf;\\uc000\\ud835\\udd44c\\xf2\\u0a76;\\u439c\\u0480Jacefostu\\u0aa3\\u0aa7\\u0aad\\u0ac0\\u0b14\\u0b19\\u0d91\\u0d97\\u0d9ecy;\\u440acute;\\u4143\\u0180aey\\u0ab4\\u0ab9\\u0aberon;\\u4147dil;\\u4145;\\u441d\\u0180gsw\\u0ac7\\u0af0\\u0b0eative\\u0180MTV\\u0ad3\\u0adf\\u0ae8ediumSpace;\\u600bhi\\u0100cn\\u0ae6\\u0ad8\\xeb\\u0ad9eryThi\\xee\\u0ad9ted\\u0100GL\\u0af8\\u0b06reaterGreate\\xf2\\u0673essLes\\xf3\\u0a48Line;\\u400ar;\\uc000\\ud835\\udd11\\u0200Bnpt\\u0b22\\u0b28\\u0b37\\u0b3areak;\\u6060BreakingSpace;\\u40a0f;\\u6115\\u0680;CDEGHLNPRSTV\\u0b55\\u0b56\\u0b6a\\u0b7c\\u0ba1\\u0beb\\u0c04\\u0c5e\\u0c84\\u0ca6\\u0cd8\\u0d61\\u0d85\\u6aec\\u0100ou\\u0b5b\\u0b64ngruent;\\u6262pCap;\\u626doubleVerticalBar;\\u6226\\u0180lqx\\u0b83\\u0b8a\\u0b9bement;\\u6209ual\\u0100;T\\u0b92\\u0b93\\u6260ilde;\\uc000\\u2242\\u0338ists;\\u6204reater\\u0380;EFGLST\\u0bb6\\u0bb7\\u0bbd\\u0bc9\\u0bd3\\u0bd8\\u0be5\\u626fqual;\\u6271ullEqual;\\uc000\\u2267\\u0338reater;\\uc000\\u226b\\u0338ess;\\u6279lantEqual;\\uc000\\u2a7e\\u0338ilde;\\u6275ump\\u0144\\u0bf2\\u0bfdownHump;\\uc000\\u224e\\u0338qual;\\uc000\\u224f\\u0338e\\u0100fs\\u0c0a\\u0c27tTriangle\\u0180;BE\\u0c1a\\u0c1b\\u0c21\\u62eaar;\\uc000\\u29cf\\u0338qual;\\u62ecs\\u0300;EGLST\\u0c35\\u0c36\\u0c3c\\u0c44\\u0c4b\\u0c58\\u626equal;\\u6270reater;\\u6278ess;\\uc000\\u226a\\u0338lantEqual;\\uc000\\u2a7d\\u0338ilde;\\u6274ested\\u0100GL\\u0c68\\u0c79reaterGreater;\\uc000\\u2aa2\\u0338essLess;\\uc000\\u2aa1\\u0338recedes\\u0180;ES\\u0c92\\u0c93\\u0c9b\\u6280qual;\\uc000\\u2aaf\\u0338lantEqual;\\u62e0\\u0100ei\\u0cab\\u0cb9verseElement;\\u620cghtTriangle\\u0180;BE\\u0ccb\\u0ccc\\u0cd2\\u62ebar;\\uc000\\u29d0\\u0338qual;\\u62ed\\u0100qu\\u0cdd\\u0d0cuareSu\\u0100bp\\u0ce8\\u0cf9set\\u0100;E\\u0cf0\\u0cf3\\uc000\\u228f\\u0338qual;\\u62e2erset\\u0100;E\\u0d03\\u0d06\\uc000\\u2290\\u0338qual;\\u62e3\\u0180bcp\\u0d13\\u0d24\\u0d4eset\\u0100;E\\u0d1b\\u0d1e\\uc000\\u2282\\u20d2qual;\\u6288ceeds\\u0200;EST\\u0d32\\u0d33\\u0d3b\\u0d46\\u6281qual;\\uc000\\u2ab0\\u0338lantEqual;\\u62e1ilde;\\uc000\\u227f\\u0338erset\\u0100;E\\u0d58\\u0d5b\\uc000\\u2283\\u20d2qual;\\u6289ilde\\u0200;EFT\\u0d6e\\u0d6f\\u0d75\\u0d7f\\u6241qual;\\u6244ullEqual;\\u6247ilde;\\u6249erticalBar;\\u6224cr;\\uc000\\ud835\\udca9ilde\\u803b\\xd1\\u40d1;\\u439d\\u0700Eacdfgmoprstuv\\u0dbd\\u0dc2\\u0dc9\\u0dd5\\u0ddb\\u0de0\\u0de7\\u0dfc\\u0e02\\u0e20\\u0e22\\u0e32\\u0e3f\\u0e44lig;\\u4152cute\\u803b\\xd3\\u40d3\\u0100iy\\u0dce\\u0dd3rc\\u803b\\xd4\\u40d4;\\u441eblac;\\u4150r;\\uc000\\ud835\\udd12rave\\u803b\\xd2\\u40d2\\u0180aei\\u0dee\\u0df2\\u0df6cr;\\u414cga;\\u43a9cron;\\u439fpf;\\uc000\\ud835\\udd46enCurly\\u0100DQ\\u0e0e\\u0e1aoubleQuote;\\u601cuote;\\u6018;\\u6a54\\u0100cl\\u0e27\\u0e2cr;\\uc000\\ud835\\udcaaash\\u803b\\xd8\\u40d8i\\u016c\\u0e37\\u0e3cde\\u803b\\xd5\\u40d5es;\\u6a37ml\\u803b\\xd6\\u40d6er\\u0100BP\\u0e4b\\u0e60\\u0100ar\\u0e50\\u0e53r;\\u603eac\\u0100ek\\u0e5a\\u0e5c;\\u63deet;\\u63b4arenthesis;\\u63dc\\u0480acfhilors\\u0e7f\\u0e87\\u0e8a\\u0e8f\\u0e92\\u0e94\\u0e9d\\u0eb0\\u0efcrtialD;\\u6202y;\\u441fr;\\uc000\\ud835\\udd13i;\\u43a6;\\u43a0usMinus;\\u40b1\\u0100ip\\u0ea2\\u0eadncareplan\\xe5\\u069df;\\u6119\\u0200;eio\\u0eb9\\u0eba\\u0ee0\\u0ee4\\u6abbcedes\\u0200;EST\\u0ec8\\u0ec9\\u0ecf\\u0eda\\u627aqual;\\u6aaflantEqual;\\u627cilde;\\u627eme;\\u6033\\u0100dp\\u0ee9\\u0eeeuct;\\u620fortion\\u0100;a\\u0225\\u0ef9l;\\u621d\\u0100ci\\u0f01\\u0f06r;\\uc000\\ud835\\udcab;\\u43a8\\u0200Ufos\\u0f11\\u0f16\\u0f1b\\u0f1fOT\\u803b\\\"\\u4022r;\\uc000\\ud835\\udd14pf;\\u611acr;\\uc000\\ud835\\udcac\\u0600BEacefhiorsu\\u0f3e\\u0f43\\u0f47\\u0f60\\u0f73\\u0fa7\\u0faa\\u0fad\\u1096\\u10a9\\u10b4\\u10bearr;\\u6910G\\u803b\\xae\\u40ae\\u0180cnr\\u0f4e\\u0f53\\u0f56ute;\\u4154g;\\u67ebr\\u0100;t\\u0f5c\\u0f5d\\u61a0l;\\u6916\\u0180aey\\u0f67\\u0f6c\\u0f71ron;\\u4158dil;\\u4156;\\u4420\\u0100;v\\u0f78\\u0f79\\u611cerse\\u0100EU\\u0f82\\u0f99\\u0100lq\\u0f87\\u0f8eement;\\u620builibrium;\\u61cbpEquilibrium;\\u696fr\\xbb\\u0f79o;\\u43a1ght\\u0400ACDFTUVa\\u0fc1\\u0feb\\u0ff3\\u1022\\u1028\\u105b\\u1087\\u03d8\\u0100nr\\u0fc6\\u0fd2gleBracket;\\u67e9row\\u0180;BL\\u0fdc\\u0fdd\\u0fe1\\u6192ar;\\u61e5eftArrow;\\u61c4eiling;\\u6309o\\u01f5\\u0ff9\\0\\u1005bleBracket;\\u67e7n\\u01d4\\u100a\\0\\u1014eeVector;\\u695dector\\u0100;B\\u101d\\u101e\\u61c2ar;\\u6955loor;\\u630b\\u0100er\\u102d\\u1043e\\u0180;AV\\u1035\\u1036\\u103c\\u62a2rrow;\\u61a6ector;\\u695biangle\\u0180;BE\\u1050\\u1051\\u1055\\u62b3ar;\\u69d0qual;\\u62b5p\\u0180DTV\\u1063\\u106e\\u1078ownVector;\\u694feeVector;\\u695cector\\u0100;B\\u1082\\u1083\\u61bear;\\u6954ector\\u0100;B\\u1091\\u1092\\u61c0ar;\\u6953\\u0100pu\\u109b\\u109ef;\\u611dndImplies;\\u6970ightarrow;\\u61db\\u0100ch\\u10b9\\u10bcr;\\u611b;\\u61b1leDelayed;\\u69f4\\u0680HOacfhimoqstu\\u10e4\\u10f1\\u10f7\\u10fd\\u1119\\u111e\\u1151\\u1156\\u1161\\u1167\\u11b5\\u11bb\\u11bf\\u0100Cc\\u10e9\\u10eeHcy;\\u4429y;\\u4428FTcy;\\u442ccute;\\u415a\\u0280;aeiy\\u1108\\u1109\\u110e\\u1113\\u1117\\u6abcron;\\u4160dil;\\u415erc;\\u415c;\\u4421r;\\uc000\\ud835\\udd16ort\\u0200DLRU\\u112a\\u1134\\u113e\\u1149ownArrow\\xbb\\u041eeftArrow\\xbb\\u089aightArrow\\xbb\\u0fddpArrow;\\u6191gma;\\u43a3allCircle;\\u6218pf;\\uc000\\ud835\\udd4a\\u0272\\u116d\\0\\0\\u1170t;\\u621aare\\u0200;ISU\\u117b\\u117c\\u1189\\u11af\\u65a1ntersection;\\u6293u\\u0100bp\\u118f\\u119eset\\u0100;E\\u1197\\u1198\\u628fqual;\\u6291erset\\u0100;E\\u11a8\\u11a9\\u6290qual;\\u6292nion;\\u6294cr;\\uc000\\ud835\\udcaear;\\u62c6\\u0200bcmp\\u11c8\\u11db\\u1209\\u120b\\u0100;s\\u11cd\\u11ce\\u62d0et\\u0100;E\\u11cd\\u11d5qual;\\u6286\\u0100ch\\u11e0\\u1205eeds\\u0200;EST\\u11ed\\u11ee\\u11f4\\u11ff\\u627bqual;\\u6ab0lantEqual;\\u627dilde;\\u627fTh\\xe1\\u0f8c;\\u6211\\u0180;es\\u1212\\u1213\\u1223\\u62d1rset\\u0100;E\\u121c\\u121d\\u6283qual;\\u6287et\\xbb\\u1213\\u0580HRSacfhiors\\u123e\\u1244\\u1249\\u1255\\u125e\\u1271\\u1276\\u129f\\u12c2\\u12c8\\u12d1ORN\\u803b\\xde\\u40deADE;\\u6122\\u0100Hc\\u124e\\u1252cy;\\u440by;\\u4426\\u0100bu\\u125a\\u125c;\\u4009;\\u43a4\\u0180aey\\u1265\\u126a\\u126fron;\\u4164dil;\\u4162;\\u4422r;\\uc000\\ud835\\udd17\\u0100ei\\u127b\\u1289\\u01f2\\u1280\\0\\u1287efore;\\u6234a;\\u4398\\u0100cn\\u128e\\u1298kSpace;\\uc000\\u205f\\u200aSpace;\\u6009lde\\u0200;EFT\\u12ab\\u12ac\\u12b2\\u12bc\\u623cqual;\\u6243ullEqual;\\u6245ilde;\\u6248pf;\\uc000\\ud835\\udd4bipleDot;\\u60db\\u0100ct\\u12d6\\u12dbr;\\uc000\\ud835\\udcafrok;\\u4166\\u0ae1\\u12f7\\u130e\\u131a\\u1326\\0\\u132c\\u1331\\0\\0\\0\\0\\0\\u1338\\u133d\\u1377\\u1385\\0\\u13ff\\u1404\\u140a\\u1410\\u0100cr\\u12fb\\u1301ute\\u803b\\xda\\u40dar\\u0100;o\\u1307\\u1308\\u619fcir;\\u6949r\\u01e3\\u1313\\0\\u1316y;\\u440eve;\\u416c\\u0100iy\\u131e\\u1323rc\\u803b\\xdb\\u40db;\\u4423blac;\\u4170r;\\uc000\\ud835\\udd18rave\\u803b\\xd9\\u40d9acr;\\u416a\\u0100di\\u1341\\u1369er\\u0100BP\\u1348\\u135d\\u0100ar\\u134d\\u1350r;\\u405fac\\u0100ek\\u1357\\u1359;\\u63dfet;\\u63b5arenthesis;\\u63ddon\\u0100;P\\u1370\\u1371\\u62c3lus;\\u628e\\u0100gp\\u137b\\u137fon;\\u4172f;\\uc000\\ud835\\udd4c\\u0400ADETadps\\u1395\\u13ae\\u13b8\\u13c4\\u03e8\\u13d2\\u13d7\\u13f3rrow\\u0180;BD\\u1150\\u13a0\\u13a4ar;\\u6912ownArrow;\\u61c5ownArrow;\\u6195quilibrium;\\u696eee\\u0100;A\\u13cb\\u13cc\\u62a5rrow;\\u61a5own\\xe1\\u03f3er\\u0100LR\\u13de\\u13e8eftArrow;\\u6196ightArrow;\\u6197i\\u0100;l\\u13f9\\u13fa\\u43d2on;\\u43a5ing;\\u416ecr;\\uc000\\ud835\\udcb0ilde;\\u4168ml\\u803b\\xdc\\u40dc\\u0480Dbcdefosv\\u1427\\u142c\\u1430\\u1433\\u143e\\u1485\\u148a\\u1490\\u1496ash;\\u62abar;\\u6aeby;\\u4412ash\\u0100;l\\u143b\\u143c\\u62a9;\\u6ae6\\u0100er\\u1443\\u1445;\\u62c1\\u0180bty\\u144c\\u1450\\u147aar;\\u6016\\u0100;i\\u144f\\u1455cal\\u0200BLST\\u1461\\u1465\\u146a\\u1474ar;\\u6223ine;\\u407ceparator;\\u6758ilde;\\u6240ThinSpace;\\u600ar;\\uc000\\ud835\\udd19pf;\\uc000\\ud835\\udd4dcr;\\uc000\\ud835\\udcb1dash;\\u62aa\\u0280cefos\\u14a7\\u14ac\\u14b1\\u14b6\\u14bcirc;\\u4174dge;\\u62c0r;\\uc000\\ud835\\udd1apf;\\uc000\\ud835\\udd4ecr;\\uc000\\ud835\\udcb2\\u0200fios\\u14cb\\u14d0\\u14d2\\u14d8r;\\uc000\\ud835\\udd1b;\\u439epf;\\uc000\\ud835\\udd4fcr;\\uc000\\ud835\\udcb3\\u0480AIUacfosu\\u14f1\\u14f5\\u14f9\\u14fd\\u1504\\u150f\\u1514\\u151a\\u1520cy;\\u442fcy;\\u4407cy;\\u442ecute\\u803b\\xdd\\u40dd\\u0100iy\\u1509\\u150drc;\\u4176;\\u442br;\\uc000\\ud835\\udd1cpf;\\uc000\\ud835\\udd50cr;\\uc000\\ud835\\udcb4ml;\\u4178\\u0400Hacdefos\\u1535\\u1539\\u153f\\u154b\\u154f\\u155d\\u1560\\u1564cy;\\u4416cute;\\u4179\\u0100ay\\u1544\\u1549ron;\\u417d;\\u4417ot;\\u417b\\u01f2\\u1554\\0\\u155boWidt\\xe8\\u0ad9a;\\u4396r;\\u6128pf;\\u6124cr;\\uc000\\ud835\\udcb5\\u0be1\\u1583\\u158a\\u1590\\0\\u15b0\\u15b6\\u15bf\\0\\0\\0\\0\\u15c6\\u15db\\u15eb\\u165f\\u166d\\0\\u1695\\u169b\\u16b2\\u16b9\\0\\u16becute\\u803b\\xe1\\u40e1reve;\\u4103\\u0300;Ediuy\\u159c\\u159d\\u15a1\\u15a3\\u15a8\\u15ad\\u623e;\\uc000\\u223e\\u0333;\\u623frc\\u803b\\xe2\\u40e2te\\u80bb\\xb4\\u0306;\\u4430lig\\u803b\\xe6\\u40e6\\u0100;r\\xb2\\u15ba;\\uc000\\ud835\\udd1erave\\u803b\\xe0\\u40e0\\u0100ep\\u15ca\\u15d6\\u0100fp\\u15cf\\u15d4sym;\\u6135\\xe8\\u15d3ha;\\u43b1\\u0100ap\\u15dfc\\u0100cl\\u15e4\\u15e7r;\\u4101g;\\u6a3f\\u0264\\u15f0\\0\\0\\u160a\\u0280;adsv\\u15fa\\u15fb\\u15ff\\u1601\\u1607\\u6227nd;\\u6a55;\\u6a5clope;\\u6a58;\\u6a5a\\u0380;elmrsz\\u1618\\u1619\\u161b\\u161e\\u163f\\u164f\\u1659\\u6220;\\u69a4e\\xbb\\u1619sd\\u0100;a\\u1625\\u1626\\u6221\\u0461\\u1630\\u1632\\u1634\\u1636\\u1638\\u163a\\u163c\\u163e;\\u69a8;\\u69a9;\\u69aa;\\u69ab;\\u69ac;\\u69ad;\\u69ae;\\u69aft\\u0100;v\\u1645\\u1646\\u621fb\\u0100;d\\u164c\\u164d\\u62be;\\u699d\\u0100pt\\u1654\\u1657h;\\u6222\\xbb\\xb9arr;\\u637c\\u0100gp\\u1663\\u1667on;\\u4105f;\\uc000\\ud835\\udd52\\u0380;Eaeiop\\u12c1\\u167b\\u167d\\u1682\\u1684\\u1687\\u168a;\\u6a70cir;\\u6a6f;\\u624ad;\\u624bs;\\u4027rox\\u0100;e\\u12c1\\u1692\\xf1\\u1683ing\\u803b\\xe5\\u40e5\\u0180cty\\u16a1\\u16a6\\u16a8r;\\uc000\\ud835\\udcb6;\\u402amp\\u0100;e\\u12c1\\u16af\\xf1\\u0288ilde\\u803b\\xe3\\u40e3ml\\u803b\\xe4\\u40e4\\u0100ci\\u16c2\\u16c8onin\\xf4\\u0272nt;\\u6a11\\u0800Nabcdefiklnoprsu\\u16ed\\u16f1\\u1730\\u173c\\u1743\\u1748\\u1778\\u177d\\u17e0\\u17e6\\u1839\\u1850\\u170d\\u193d\\u1948\\u1970ot;\\u6aed\\u0100cr\\u16f6\\u171ek\\u0200ceps\\u1700\\u1705\\u170d\\u1713ong;\\u624cpsilon;\\u43f6rime;\\u6035im\\u0100;e\\u171a\\u171b\\u623dq;\\u62cd\\u0176\\u1722\\u1726ee;\\u62bded\\u0100;g\\u172c\\u172d\\u6305e\\xbb\\u172drk\\u0100;t\\u135c\\u1737brk;\\u63b6\\u0100oy\\u1701\\u1741;\\u4431quo;\\u601e\\u0280cmprt\\u1753\\u175b\\u1761\\u1764\\u1768aus\\u0100;e\\u010a\\u0109ptyv;\\u69b0s\\xe9\\u170cno\\xf5\\u0113\\u0180ahw\\u176f\\u1771\\u1773;\\u43b2;\\u6136een;\\u626cr;\\uc000\\ud835\\udd1fg\\u0380costuvw\\u178d\\u179d\\u17b3\\u17c1\\u17d5\\u17db\\u17de\\u0180aiu\\u1794\\u1796\\u179a\\xf0\\u0760rc;\\u65efp\\xbb\\u1371\\u0180dpt\\u17a4\\u17a8\\u17adot;\\u6a00lus;\\u6a01imes;\\u6a02\\u0271\\u17b9\\0\\0\\u17becup;\\u6a06ar;\\u6605riangle\\u0100du\\u17cd\\u17d2own;\\u65bdp;\\u65b3plus;\\u6a04e\\xe5\\u1444\\xe5\\u14adarow;\\u690d\\u0180ako\\u17ed\\u1826\\u1835\\u0100cn\\u17f2\\u1823k\\u0180lst\\u17fa\\u05ab\\u1802ozenge;\\u69ebriangle\\u0200;dlr\\u1812\\u1813\\u1818\\u181d\\u65b4own;\\u65beeft;\\u65c2ight;\\u65b8k;\\u6423\\u01b1\\u182b\\0\\u1833\\u01b2\\u182f\\0\\u1831;\\u6592;\\u65914;\\u6593ck;\\u6588\\u0100eo\\u183e\\u184d\\u0100;q\\u1843\\u1846\\uc000=\\u20e5uiv;\\uc000\\u2261\\u20e5t;\\u6310\\u0200ptwx\\u1859\\u185e\\u1867\\u186cf;\\uc000\\ud835\\udd53\\u0100;t\\u13cb\\u1863om\\xbb\\u13cctie;\\u62c8\\u0600DHUVbdhmptuv\\u1885\\u1896\\u18aa\\u18bb\\u18d7\\u18db\\u18ec\\u18ff\\u1905\\u190a\\u1910\\u1921\\u0200LRlr\\u188e\\u1890\\u1892\\u1894;\\u6557;\\u6554;\\u6556;\\u6553\\u0280;DUdu\\u18a1\\u18a2\\u18a4\\u18a6\\u18a8\\u6550;\\u6566;\\u6569;\\u6564;\\u6567\\u0200LRlr\\u18b3\\u18b5\\u18b7\\u18b9;\\u655d;\\u655a;\\u655c;\\u6559\\u0380;HLRhlr\\u18ca\\u18cb\\u18cd\\u18cf\\u18d1\\u18d3\\u18d5\\u6551;\\u656c;\\u6563;\\u6560;\\u656b;\\u6562;\\u655fox;\\u69c9\\u0200LRlr\\u18e4\\u18e6\\u18e8\\u18ea;\\u6555;\\u6552;\\u6510;\\u650c\\u0280;DUdu\\u06bd\\u18f7\\u18f9\\u18fb\\u18fd;\\u6565;\\u6568;\\u652c;\\u6534inus;\\u629flus;\\u629eimes;\\u62a0\\u0200LRlr\\u1919\\u191b\\u191d\\u191f;\\u655b;\\u6558;\\u6518;\\u6514\\u0380;HLRhlr\\u1930\\u1931\\u1933\\u1935\\u1937\\u1939\\u193b\\u6502;\\u656a;\\u6561;\\u655e;\\u653c;\\u6524;\\u651c\\u0100ev\\u0123\\u1942bar\\u803b\\xa6\\u40a6\\u0200ceio\\u1951\\u1956\\u195a\\u1960r;\\uc000\\ud835\\udcb7mi;\\u604fm\\u0100;e\\u171a\\u171cl\\u0180;bh\\u1968\\u1969\\u196b\\u405c;\\u69c5sub;\\u67c8\\u016c\\u1974\\u197el\\u0100;e\\u1979\\u197a\\u6022t\\xbb\\u197ap\\u0180;Ee\\u012f\\u1985\\u1987;\\u6aae\\u0100;q\\u06dc\\u06db\\u0ce1\\u19a7\\0\\u19e8\\u1a11\\u1a15\\u1a32\\0\\u1a37\\u1a50\\0\\0\\u1ab4\\0\\0\\u1ac1\\0\\0\\u1b21\\u1b2e\\u1b4d\\u1b52\\0\\u1bfd\\0\\u1c0c\\u0180cpr\\u19ad\\u19b2\\u19ddute;\\u4107\\u0300;abcds\\u19bf\\u19c0\\u19c4\\u19ca\\u19d5\\u19d9\\u6229nd;\\u6a44rcup;\\u6a49\\u0100au\\u19cf\\u19d2p;\\u6a4bp;\\u6a47ot;\\u6a40;\\uc000\\u2229\\ufe00\\u0100eo\\u19e2\\u19e5t;\\u6041\\xee\\u0693\\u0200aeiu\\u19f0\\u19fb\\u1a01\\u1a05\\u01f0\\u19f5\\0\\u19f8s;\\u6a4don;\\u410ddil\\u803b\\xe7\\u40e7rc;\\u4109ps\\u0100;s\\u1a0c\\u1a0d\\u6a4cm;\\u6a50ot;\\u410b\\u0180dmn\\u1a1b\\u1a20\\u1a26il\\u80bb\\xb8\\u01adptyv;\\u69b2t\\u8100\\xa2;e\\u1a2d\\u1a2e\\u40a2r\\xe4\\u01b2r;\\uc000\\ud835\\udd20\\u0180cei\\u1a3d\\u1a40\\u1a4dy;\\u4447ck\\u0100;m\\u1a47\\u1a48\\u6713ark\\xbb\\u1a48;\\u43c7r\\u0380;Ecefms\\u1a5f\\u1a60\\u1a62\\u1a6b\\u1aa4\\u1aaa\\u1aae\\u65cb;\\u69c3\\u0180;el\\u1a69\\u1a6a\\u1a6d\\u42c6q;\\u6257e\\u0261\\u1a74\\0\\0\\u1a88rrow\\u0100lr\\u1a7c\\u1a81eft;\\u61baight;\\u61bb\\u0280RSacd\\u1a92\\u1a94\\u1a96\\u1a9a\\u1a9f\\xbb\\u0f47;\\u64c8st;\\u629birc;\\u629aash;\\u629dnint;\\u6a10id;\\u6aefcir;\\u69c2ubs\\u0100;u\\u1abb\\u1abc\\u6663it\\xbb\\u1abc\\u02ec\\u1ac7\\u1ad4\\u1afa\\0\\u1b0aon\\u0100;e\\u1acd\\u1ace\\u403a\\u0100;q\\xc7\\xc6\\u026d\\u1ad9\\0\\0\\u1ae2a\\u0100;t\\u1ade\\u1adf\\u402c;\\u4040\\u0180;fl\\u1ae8\\u1ae9\\u1aeb\\u6201\\xee\\u1160e\\u0100mx\\u1af1\\u1af6ent\\xbb\\u1ae9e\\xf3\\u024d\\u01e7\\u1afe\\0\\u1b07\\u0100;d\\u12bb\\u1b02ot;\\u6a6dn\\xf4\\u0246\\u0180fry\\u1b10\\u1b14\\u1b17;\\uc000\\ud835\\udd54o\\xe4\\u0254\\u8100\\xa9;s\\u0155\\u1b1dr;\\u6117\\u0100ao\\u1b25\\u1b29rr;\\u61b5ss;\\u6717\\u0100cu\\u1b32\\u1b37r;\\uc000\\ud835\\udcb8\\u0100bp\\u1b3c\\u1b44\\u0100;e\\u1b41\\u1b42\\u6acf;\\u6ad1\\u0100;e\\u1b49\\u1b4a\\u6ad0;\\u6ad2dot;\\u62ef\\u0380delprvw\\u1b60\\u1b6c\\u1b77\\u1b82\\u1bac\\u1bd4\\u1bf9arr\\u0100lr\\u1b68\\u1b6a;\\u6938;\\u6935\\u0270\\u1b72\\0\\0\\u1b75r;\\u62dec;\\u62dfarr\\u0100;p\\u1b7f\\u1b80\\u61b6;\\u693d\\u0300;bcdos\\u1b8f\\u1b90\\u1b96\\u1ba1\\u1ba5\\u1ba8\\u622arcap;\\u6a48\\u0100au\\u1b9b\\u1b9ep;\\u6a46p;\\u6a4aot;\\u628dr;\\u6a45;\\uc000\\u222a\\ufe00\\u0200alrv\\u1bb5\\u1bbf\\u1bde\\u1be3rr\\u0100;m\\u1bbc\\u1bbd\\u61b7;\\u693cy\\u0180evw\\u1bc7\\u1bd4\\u1bd8q\\u0270\\u1bce\\0\\0\\u1bd2re\\xe3\\u1b73u\\xe3\\u1b75ee;\\u62ceedge;\\u62cfen\\u803b\\xa4\\u40a4earrow\\u0100lr\\u1bee\\u1bf3eft\\xbb\\u1b80ight\\xbb\\u1bbde\\xe4\\u1bdd\\u0100ci\\u1c01\\u1c07onin\\xf4\\u01f7nt;\\u6231lcty;\\u632d\\u0980AHabcdefhijlorstuwz\\u1c38\\u1c3b\\u1c3f\\u1c5d\\u1c69\\u1c75\\u1c8a\\u1c9e\\u1cac\\u1cb7\\u1cfb\\u1cff\\u1d0d\\u1d7b\\u1d91\\u1dab\\u1dbb\\u1dc6\\u1dcdr\\xf2\\u0381ar;\\u6965\\u0200glrs\\u1c48\\u1c4d\\u1c52\\u1c54ger;\\u6020eth;\\u6138\\xf2\\u1133h\\u0100;v\\u1c5a\\u1c5b\\u6010\\xbb\\u090a\\u016b\\u1c61\\u1c67arow;\\u690fa\\xe3\\u0315\\u0100ay\\u1c6e\\u1c73ron;\\u410f;\\u4434\\u0180;ao\\u0332\\u1c7c\\u1c84\\u0100gr\\u02bf\\u1c81r;\\u61catseq;\\u6a77\\u0180glm\\u1c91\\u1c94\\u1c98\\u803b\\xb0\\u40b0ta;\\u43b4ptyv;\\u69b1\\u0100ir\\u1ca3\\u1ca8sht;\\u697f;\\uc000\\ud835\\udd21ar\\u0100lr\\u1cb3\\u1cb5\\xbb\\u08dc\\xbb\\u101e\\u0280aegsv\\u1cc2\\u0378\\u1cd6\\u1cdc\\u1ce0m\\u0180;os\\u0326\\u1cca\\u1cd4nd\\u0100;s\\u0326\\u1cd1uit;\\u6666amma;\\u43ddin;\\u62f2\\u0180;io\\u1ce7\\u1ce8\\u1cf8\\u40f7de\\u8100\\xf7;o\\u1ce7\\u1cf0ntimes;\\u62c7n\\xf8\\u1cf7cy;\\u4452c\\u026f\\u1d06\\0\\0\\u1d0arn;\\u631eop;\\u630d\\u0280lptuw\\u1d18\\u1d1d\\u1d22\\u1d49\\u1d55lar;\\u4024f;\\uc000\\ud835\\udd55\\u0280;emps\\u030b\\u1d2d\\u1d37\\u1d3d\\u1d42q\\u0100;d\\u0352\\u1d33ot;\\u6251inus;\\u6238lus;\\u6214quare;\\u62a1blebarwedg\\xe5\\xfan\\u0180adh\\u112e\\u1d5d\\u1d67ownarrow\\xf3\\u1c83arpoon\\u0100lr\\u1d72\\u1d76ef\\xf4\\u1cb4igh\\xf4\\u1cb6\\u0162\\u1d7f\\u1d85karo\\xf7\\u0f42\\u026f\\u1d8a\\0\\0\\u1d8ern;\\u631fop;\\u630c\\u0180cot\\u1d98\\u1da3\\u1da6\\u0100ry\\u1d9d\\u1da1;\\uc000\\ud835\\udcb9;\\u4455l;\\u69f6rok;\\u4111\\u0100dr\\u1db0\\u1db4ot;\\u62f1i\\u0100;f\\u1dba\\u1816\\u65bf\\u0100ah\\u1dc0\\u1dc3r\\xf2\\u0429a\\xf2\\u0fa6angle;\\u69a6\\u0100ci\\u1dd2\\u1dd5y;\\u445fgrarr;\\u67ff\\u0900Dacdefglmnopqrstux\\u1e01\\u1e09\\u1e19\\u1e38\\u0578\\u1e3c\\u1e49\\u1e61\\u1e7e\\u1ea5\\u1eaf\\u1ebd\\u1ee1\\u1f2a\\u1f37\\u1f44\\u1f4e\\u1f5a\\u0100Do\\u1e06\\u1d34o\\xf4\\u1c89\\u0100cs\\u1e0e\\u1e14ute\\u803b\\xe9\\u40e9ter;\\u6a6e\\u0200aioy\\u1e22\\u1e27\\u1e31\\u1e36ron;\\u411br\\u0100;c\\u1e2d\\u1e2e\\u6256\\u803b\\xea\\u40ealon;\\u6255;\\u444dot;\\u4117\\u0100Dr\\u1e41\\u1e45ot;\\u6252;\\uc000\\ud835\\udd22\\u0180;rs\\u1e50\\u1e51\\u1e57\\u6a9aave\\u803b\\xe8\\u40e8\\u0100;d\\u1e5c\\u1e5d\\u6a96ot;\\u6a98\\u0200;ils\\u1e6a\\u1e6b\\u1e72\\u1e74\\u6a99nters;\\u63e7;\\u6113\\u0100;d\\u1e79\\u1e7a\\u6a95ot;\\u6a97\\u0180aps\\u1e85\\u1e89\\u1e97cr;\\u4113ty\\u0180;sv\\u1e92\\u1e93\\u1e95\\u6205et\\xbb\\u1e93p\\u01001;\\u1e9d\\u1ea4\\u0133\\u1ea1\\u1ea3;\\u6004;\\u6005\\u6003\\u0100gs\\u1eaa\\u1eac;\\u414bp;\\u6002\\u0100gp\\u1eb4\\u1eb8on;\\u4119f;\\uc000\\ud835\\udd56\\u0180als\\u1ec4\\u1ece\\u1ed2r\\u0100;s\\u1eca\\u1ecb\\u62d5l;\\u69e3us;\\u6a71i\\u0180;lv\\u1eda\\u1edb\\u1edf\\u43b5on\\xbb\\u1edb;\\u43f5\\u0200csuv\\u1eea\\u1ef3\\u1f0b\\u1f23\\u0100io\\u1eef\\u1e31rc\\xbb\\u1e2e\\u0269\\u1ef9\\0\\0\\u1efb\\xed\\u0548ant\\u0100gl\\u1f02\\u1f06tr\\xbb\\u1e5dess\\xbb\\u1e7a\\u0180aei\\u1f12\\u1f16\\u1f1als;\\u403dst;\\u625fv\\u0100;D\\u0235\\u1f20D;\\u6a78parsl;\\u69e5\\u0100Da\\u1f2f\\u1f33ot;\\u6253rr;\\u6971\\u0180cdi\\u1f3e\\u1f41\\u1ef8r;\\u612fo\\xf4\\u0352\\u0100ah\\u1f49\\u1f4b;\\u43b7\\u803b\\xf0\\u40f0\\u0100mr\\u1f53\\u1f57l\\u803b\\xeb\\u40ebo;\\u60ac\\u0180cip\\u1f61\\u1f64\\u1f67l;\\u4021s\\xf4\\u056e\\u0100eo\\u1f6c\\u1f74ctatio\\xee\\u0559nential\\xe5\\u0579\\u09e1\\u1f92\\0\\u1f9e\\0\\u1fa1\\u1fa7\\0\\0\\u1fc6\\u1fcc\\0\\u1fd3\\0\\u1fe6\\u1fea\\u2000\\0\\u2008\\u205allingdotse\\xf1\\u1e44y;\\u4444male;\\u6640\\u0180ilr\\u1fad\\u1fb3\\u1fc1lig;\\u8000\\ufb03\\u0269\\u1fb9\\0\\0\\u1fbdg;\\u8000\\ufb00ig;\\u8000\\ufb04;\\uc000\\ud835\\udd23lig;\\u8000\\ufb01lig;\\uc000fj\\u0180alt\\u1fd9\\u1fdc\\u1fe1t;\\u666dig;\\u8000\\ufb02ns;\\u65b1of;\\u4192\\u01f0\\u1fee\\0\\u1ff3f;\\uc000\\ud835\\udd57\\u0100ak\\u05bf\\u1ff7\\u0100;v\\u1ffc\\u1ffd\\u62d4;\\u6ad9artint;\\u6a0d\\u0100ao\\u200c\\u2055\\u0100cs\\u2011\\u2052\\u03b1\\u201a\\u2030\\u2038\\u2045\\u2048\\0\\u2050\\u03b2\\u2022\\u2025\\u2027\\u202a\\u202c\\0\\u202e\\u803b\\xbd\\u40bd;\\u6153\\u803b\\xbc\\u40bc;\\u6155;\\u6159;\\u615b\\u01b3\\u2034\\0\\u2036;\\u6154;\\u6156\\u02b4\\u203e\\u2041\\0\\0\\u2043\\u803b\\xbe\\u40be;\\u6157;\\u615c5;\\u6158\\u01b6\\u204c\\0\\u204e;\\u615a;\\u615d8;\\u615el;\\u6044wn;\\u6322cr;\\uc000\\ud835\\udcbb\\u0880Eabcdefgijlnorstv\\u2082\\u2089\\u209f\\u20a5\\u20b0\\u20b4\\u20f0\\u20f5\\u20fa\\u20ff\\u2103\\u2112\\u2138\\u0317\\u213e\\u2152\\u219e\\u0100;l\\u064d\\u2087;\\u6a8c\\u0180cmp\\u2090\\u2095\\u209dute;\\u41f5ma\\u0100;d\\u209c\\u1cda\\u43b3;\\u6a86reve;\\u411f\\u0100iy\\u20aa\\u20aerc;\\u411d;\\u4433ot;\\u4121\\u0200;lqs\\u063e\\u0642\\u20bd\\u20c9\\u0180;qs\\u063e\\u064c\\u20c4lan\\xf4\\u0665\\u0200;cdl\\u0665\\u20d2\\u20d5\\u20e5c;\\u6aa9ot\\u0100;o\\u20dc\\u20dd\\u6a80\\u0100;l\\u20e2\\u20e3\\u6a82;\\u6a84\\u0100;e\\u20ea\\u20ed\\uc000\\u22db\\ufe00s;\\u6a94r;\\uc000\\ud835\\udd24\\u0100;g\\u0673\\u061bmel;\\u6137cy;\\u4453\\u0200;Eaj\\u065a\\u210c\\u210e\\u2110;\\u6a92;\\u6aa5;\\u6aa4\\u0200Eaes\\u211b\\u211d\\u2129\\u2134;\\u6269p\\u0100;p\\u2123\\u2124\\u6a8arox\\xbb\\u2124\\u0100;q\\u212e\\u212f\\u6a88\\u0100;q\\u212e\\u211bim;\\u62e7pf;\\uc000\\ud835\\udd58\\u0100ci\\u2143\\u2146r;\\u610am\\u0180;el\\u066b\\u214e\\u2150;\\u6a8e;\\u6a90\\u8300>;cdlqr\\u05ee\\u2160\\u216a\\u216e\\u2173\\u2179\\u0100ci\\u2165\\u2167;\\u6aa7r;\\u6a7aot;\\u62d7Par;\\u6995uest;\\u6a7c\\u0280adels\\u2184\\u216a\\u2190\\u0656\\u219b\\u01f0\\u2189\\0\\u218epro\\xf8\\u209er;\\u6978q\\u0100lq\\u063f\\u2196les\\xf3\\u2088i\\xed\\u066b\\u0100en\\u21a3\\u21adrtneqq;\\uc000\\u2269\\ufe00\\xc5\\u21aa\\u0500Aabcefkosy\\u21c4\\u21c7\\u21f1\\u21f5\\u21fa\\u2218\\u221d\\u222f\\u2268\\u227dr\\xf2\\u03a0\\u0200ilmr\\u21d0\\u21d4\\u21d7\\u21dbrs\\xf0\\u1484f\\xbb\\u2024il\\xf4\\u06a9\\u0100dr\\u21e0\\u21e4cy;\\u444a\\u0180;cw\\u08f4\\u21eb\\u21efir;\\u6948;\\u61adar;\\u610firc;\\u4125\\u0180alr\\u2201\\u220e\\u2213rts\\u0100;u\\u2209\\u220a\\u6665it\\xbb\\u220alip;\\u6026con;\\u62b9r;\\uc000\\ud835\\udd25s\\u0100ew\\u2223\\u2229arow;\\u6925arow;\\u6926\\u0280amopr\\u223a\\u223e\\u2243\\u225e\\u2263rr;\\u61fftht;\\u623bk\\u0100lr\\u2249\\u2253eftarrow;\\u61a9ightarrow;\\u61aaf;\\uc000\\ud835\\udd59bar;\\u6015\\u0180clt\\u226f\\u2274\\u2278r;\\uc000\\ud835\\udcbdas\\xe8\\u21f4rok;\\u4127\\u0100bp\\u2282\\u2287ull;\\u6043hen\\xbb\\u1c5b\\u0ae1\\u22a3\\0\\u22aa\\0\\u22b8\\u22c5\\u22ce\\0\\u22d5\\u22f3\\0\\0\\u22f8\\u2322\\u2367\\u2362\\u237f\\0\\u2386\\u23aa\\u23b4cute\\u803b\\xed\\u40ed\\u0180;iy\\u0771\\u22b0\\u22b5rc\\u803b\\xee\\u40ee;\\u4438\\u0100cx\\u22bc\\u22bfy;\\u4435cl\\u803b\\xa1\\u40a1\\u0100fr\\u039f\\u22c9;\\uc000\\ud835\\udd26rave\\u803b\\xec\\u40ec\\u0200;ino\\u073e\\u22dd\\u22e9\\u22ee\\u0100in\\u22e2\\u22e6nt;\\u6a0ct;\\u622dfin;\\u69dcta;\\u6129lig;\\u4133\\u0180aop\\u22fe\\u231a\\u231d\\u0180cgt\\u2305\\u2308\\u2317r;\\u412b\\u0180elp\\u071f\\u230f\\u2313in\\xe5\\u078ear\\xf4\\u0720h;\\u4131f;\\u62b7ed;\\u41b5\\u0280;cfot\\u04f4\\u232c\\u2331\\u233d\\u2341are;\\u6105in\\u0100;t\\u2338\\u2339\\u621eie;\\u69dddo\\xf4\\u2319\\u0280;celp\\u0757\\u234c\\u2350\\u235b\\u2361al;\\u62ba\\u0100gr\\u2355\\u2359er\\xf3\\u1563\\xe3\\u234darhk;\\u6a17rod;\\u6a3c\\u0200cgpt\\u236f\\u2372\\u2376\\u237by;\\u4451on;\\u412ff;\\uc000\\ud835\\udd5aa;\\u43b9uest\\u803b\\xbf\\u40bf\\u0100ci\\u238a\\u238fr;\\uc000\\ud835\\udcben\\u0280;Edsv\\u04f4\\u239b\\u239d\\u23a1\\u04f3;\\u62f9ot;\\u62f5\\u0100;v\\u23a6\\u23a7\\u62f4;\\u62f3\\u0100;i\\u0777\\u23aelde;\\u4129\\u01eb\\u23b8\\0\\u23bccy;\\u4456l\\u803b\\xef\\u40ef\\u0300cfmosu\\u23cc\\u23d7\\u23dc\\u23e1\\u23e7\\u23f5\\u0100iy\\u23d1\\u23d5rc;\\u4135;\\u4439r;\\uc000\\ud835\\udd27ath;\\u4237pf;\\uc000\\ud835\\udd5b\\u01e3\\u23ec\\0\\u23f1r;\\uc000\\ud835\\udcbfrcy;\\u4458kcy;\\u4454\\u0400acfghjos\\u240b\\u2416\\u2422\\u2427\\u242d\\u2431\\u2435\\u243bppa\\u0100;v\\u2413\\u2414\\u43ba;\\u43f0\\u0100ey\\u241b\\u2420dil;\\u4137;\\u443ar;\\uc000\\ud835\\udd28reen;\\u4138cy;\\u4445cy;\\u445cpf;\\uc000\\ud835\\udd5ccr;\\uc000\\ud835\\udcc0\\u0b80ABEHabcdefghjlmnoprstuv\\u2470\\u2481\\u2486\\u248d\\u2491\\u250e\\u253d\\u255a\\u2580\\u264e\\u265e\\u2665\\u2679\\u267d\\u269a\\u26b2\\u26d8\\u275d\\u2768\\u278b\\u27c0\\u2801\\u2812\\u0180art\\u2477\\u247a\\u247cr\\xf2\\u09c6\\xf2\\u0395ail;\\u691barr;\\u690e\\u0100;g\\u0994\\u248b;\\u6a8bar;\\u6962\\u0963\\u24a5\\0\\u24aa\\0\\u24b1\\0\\0\\0\\0\\0\\u24b5\\u24ba\\0\\u24c6\\u24c8\\u24cd\\0\\u24f9ute;\\u413amptyv;\\u69b4ra\\xee\\u084cbda;\\u43bbg\\u0180;dl\\u088e\\u24c1\\u24c3;\\u6991\\xe5\\u088e;\\u6a85uo\\u803b\\xab\\u40abr\\u0400;bfhlpst\\u0899\\u24de\\u24e6\\u24e9\\u24eb\\u24ee\\u24f1\\u24f5\\u0100;f\\u089d\\u24e3s;\\u691fs;\\u691d\\xeb\\u2252p;\\u61abl;\\u6939im;\\u6973l;\\u61a2\\u0180;ae\\u24ff\\u2500\\u2504\\u6aabil;\\u6919\\u0100;s\\u2509\\u250a\\u6aad;\\uc000\\u2aad\\ufe00\\u0180abr\\u2515\\u2519\\u251drr;\\u690crk;\\u6772\\u0100ak\\u2522\\u252cc\\u0100ek\\u2528\\u252a;\\u407b;\\u405b\\u0100es\\u2531\\u2533;\\u698bl\\u0100du\\u2539\\u253b;\\u698f;\\u698d\\u0200aeuy\\u2546\\u254b\\u2556\\u2558ron;\\u413e\\u0100di\\u2550\\u2554il;\\u413c\\xec\\u08b0\\xe2\\u2529;\\u443b\\u0200cqrs\\u2563\\u2566\\u256d\\u257da;\\u6936uo\\u0100;r\\u0e19\\u1746\\u0100du\\u2572\\u2577har;\\u6967shar;\\u694bh;\\u61b2\\u0280;fgqs\\u258b\\u258c\\u0989\\u25f3\\u25ff\\u6264t\\u0280ahlrt\\u2598\\u25a4\\u25b7\\u25c2\\u25e8rrow\\u0100;t\\u0899\\u25a1a\\xe9\\u24f6arpoon\\u0100du\\u25af\\u25b4own\\xbb\\u045ap\\xbb\\u0966eftarrows;\\u61c7ight\\u0180ahs\\u25cd\\u25d6\\u25derrow\\u0100;s\\u08f4\\u08a7arpoon\\xf3\\u0f98quigarro\\xf7\\u21f0hreetimes;\\u62cb\\u0180;qs\\u258b\\u0993\\u25falan\\xf4\\u09ac\\u0280;cdgs\\u09ac\\u260a\\u260d\\u261d\\u2628c;\\u6aa8ot\\u0100;o\\u2614\\u2615\\u6a7f\\u0100;r\\u261a\\u261b\\u6a81;\\u6a83\\u0100;e\\u2622\\u2625\\uc000\\u22da\\ufe00s;\\u6a93\\u0280adegs\\u2633\\u2639\\u263d\\u2649\\u264bppro\\xf8\\u24c6ot;\\u62d6q\\u0100gq\\u2643\\u2645\\xf4\\u0989gt\\xf2\\u248c\\xf4\\u099bi\\xed\\u09b2\\u0180ilr\\u2655\\u08e1\\u265asht;\\u697c;\\uc000\\ud835\\udd29\\u0100;E\\u099c\\u2663;\\u6a91\\u0161\\u2669\\u2676r\\u0100du\\u25b2\\u266e\\u0100;l\\u0965\\u2673;\\u696alk;\\u6584cy;\\u4459\\u0280;acht\\u0a48\\u2688\\u268b\\u2691\\u2696r\\xf2\\u25c1orne\\xf2\\u1d08ard;\\u696bri;\\u65fa\\u0100io\\u269f\\u26a4dot;\\u4140ust\\u0100;a\\u26ac\\u26ad\\u63b0che\\xbb\\u26ad\\u0200Eaes\\u26bb\\u26bd\\u26c9\\u26d4;\\u6268p\\u0100;p\\u26c3\\u26c4\\u6a89rox\\xbb\\u26c4\\u0100;q\\u26ce\\u26cf\\u6a87\\u0100;q\\u26ce\\u26bbim;\\u62e6\\u0400abnoptwz\\u26e9\\u26f4\\u26f7\\u271a\\u272f\\u2741\\u2747\\u2750\\u0100nr\\u26ee\\u26f1g;\\u67ecr;\\u61fdr\\xeb\\u08c1g\\u0180lmr\\u26ff\\u270d\\u2714eft\\u0100ar\\u09e6\\u2707ight\\xe1\\u09f2apsto;\\u67fcight\\xe1\\u09fdparrow\\u0100lr\\u2725\\u2729ef\\xf4\\u24edight;\\u61ac\\u0180afl\\u2736\\u2739\\u273dr;\\u6985;\\uc000\\ud835\\udd5dus;\\u6a2dimes;\\u6a34\\u0161\\u274b\\u274fst;\\u6217\\xe1\\u134e\\u0180;ef\\u2757\\u2758\\u1800\\u65cange\\xbb\\u2758ar\\u0100;l\\u2764\\u2765\\u4028t;\\u6993\\u0280achmt\\u2773\\u2776\\u277c\\u2785\\u2787r\\xf2\\u08a8orne\\xf2\\u1d8car\\u0100;d\\u0f98\\u2783;\\u696d;\\u600eri;\\u62bf\\u0300achiqt\\u2798\\u279d\\u0a40\\u27a2\\u27ae\\u27bbquo;\\u6039r;\\uc000\\ud835\\udcc1m\\u0180;eg\\u09b2\\u27aa\\u27ac;\\u6a8d;\\u6a8f\\u0100bu\\u252a\\u27b3o\\u0100;r\\u0e1f\\u27b9;\\u601arok;\\u4142\\u8400<;cdhilqr\\u082b\\u27d2\\u2639\\u27dc\\u27e0\\u27e5\\u27ea\\u27f0\\u0100ci\\u27d7\\u27d9;\\u6aa6r;\\u6a79re\\xe5\\u25f2mes;\\u62c9arr;\\u6976uest;\\u6a7b\\u0100Pi\\u27f5\\u27f9ar;\\u6996\\u0180;ef\\u2800\\u092d\\u181b\\u65c3r\\u0100du\\u2807\\u280dshar;\\u694ahar;\\u6966\\u0100en\\u2817\\u2821rtneqq;\\uc000\\u2268\\ufe00\\xc5\\u281e\\u0700Dacdefhilnopsu\\u2840\\u2845\\u2882\\u288e\\u2893\\u28a0\\u28a5\\u28a8\\u28da\\u28e2\\u28e4\\u0a83\\u28f3\\u2902Dot;\\u623a\\u0200clpr\\u284e\\u2852\\u2863\\u287dr\\u803b\\xaf\\u40af\\u0100et\\u2857\\u2859;\\u6642\\u0100;e\\u285e\\u285f\\u6720se\\xbb\\u285f\\u0100;s\\u103b\\u2868to\\u0200;dlu\\u103b\\u2873\\u2877\\u287bow\\xee\\u048cef\\xf4\\u090f\\xf0\\u13d1ker;\\u65ae\\u0100oy\\u2887\\u288cmma;\\u6a29;\\u443cash;\\u6014asuredangle\\xbb\\u1626r;\\uc000\\ud835\\udd2ao;\\u6127\\u0180cdn\\u28af\\u28b4\\u28c9ro\\u803b\\xb5\\u40b5\\u0200;acd\\u1464\\u28bd\\u28c0\\u28c4s\\xf4\\u16a7ir;\\u6af0ot\\u80bb\\xb7\\u01b5us\\u0180;bd\\u28d2\\u1903\\u28d3\\u6212\\u0100;u\\u1d3c\\u28d8;\\u6a2a\\u0163\\u28de\\u28e1p;\\u6adb\\xf2\\u2212\\xf0\\u0a81\\u0100dp\\u28e9\\u28eeels;\\u62a7f;\\uc000\\ud835\\udd5e\\u0100ct\\u28f8\\u28fdr;\\uc000\\ud835\\udcc2pos\\xbb\\u159d\\u0180;lm\\u2909\\u290a\\u290d\\u43bctimap;\\u62b8\\u0c00GLRVabcdefghijlmoprstuvw\\u2942\\u2953\\u297e\\u2989\\u2998\\u29da\\u29e9\\u2a15\\u2a1a\\u2a58\\u2a5d\\u2a83\\u2a95\\u2aa4\\u2aa8\\u2b04\\u2b07\\u2b44\\u2b7f\\u2bae\\u2c34\\u2c67\\u2c7c\\u2ce9\\u0100gt\\u2947\\u294b;\\uc000\\u22d9\\u0338\\u0100;v\\u2950\\u0bcf\\uc000\\u226b\\u20d2\\u0180elt\\u295a\\u2972\\u2976ft\\u0100ar\\u2961\\u2967rrow;\\u61cdightarrow;\\u61ce;\\uc000\\u22d8\\u0338\\u0100;v\\u297b\\u0c47\\uc000\\u226a\\u20d2ightarrow;\\u61cf\\u0100Dd\\u298e\\u2993ash;\\u62afash;\\u62ae\\u0280bcnpt\\u29a3\\u29a7\\u29ac\\u29b1\\u29ccla\\xbb\\u02deute;\\u4144g;\\uc000\\u2220\\u20d2\\u0280;Eiop\\u0d84\\u29bc\\u29c0\\u29c5\\u29c8;\\uc000\\u2a70\\u0338d;\\uc000\\u224b\\u0338s;\\u4149ro\\xf8\\u0d84ur\\u0100;a\\u29d3\\u29d4\\u666el\\u0100;s\\u29d3\\u0b38\\u01f3\\u29df\\0\\u29e3p\\u80bb\\xa0\\u0b37mp\\u0100;e\\u0bf9\\u0c00\\u0280aeouy\\u29f4\\u29fe\\u2a03\\u2a10\\u2a13\\u01f0\\u29f9\\0\\u29fb;\\u6a43on;\\u4148dil;\\u4146ng\\u0100;d\\u0d7e\\u2a0aot;\\uc000\\u2a6d\\u0338p;\\u6a42;\\u443dash;\\u6013\\u0380;Aadqsx\\u0b92\\u2a29\\u2a2d\\u2a3b\\u2a41\\u2a45\\u2a50rr;\\u61d7r\\u0100hr\\u2a33\\u2a36k;\\u6924\\u0100;o\\u13f2\\u13f0ot;\\uc000\\u2250\\u0338ui\\xf6\\u0b63\\u0100ei\\u2a4a\\u2a4ear;\\u6928\\xed\\u0b98ist\\u0100;s\\u0ba0\\u0b9fr;\\uc000\\ud835\\udd2b\\u0200Eest\\u0bc5\\u2a66\\u2a79\\u2a7c\\u0180;qs\\u0bbc\\u2a6d\\u0be1\\u0180;qs\\u0bbc\\u0bc5\\u2a74lan\\xf4\\u0be2i\\xed\\u0bea\\u0100;r\\u0bb6\\u2a81\\xbb\\u0bb7\\u0180Aap\\u2a8a\\u2a8d\\u2a91r\\xf2\\u2971rr;\\u61aear;\\u6af2\\u0180;sv\\u0f8d\\u2a9c\\u0f8c\\u0100;d\\u2aa1\\u2aa2\\u62fc;\\u62facy;\\u445a\\u0380AEadest\\u2ab7\\u2aba\\u2abe\\u2ac2\\u2ac5\\u2af6\\u2af9r\\xf2\\u2966;\\uc000\\u2266\\u0338rr;\\u619ar;\\u6025\\u0200;fqs\\u0c3b\\u2ace\\u2ae3\\u2aeft\\u0100ar\\u2ad4\\u2ad9rro\\xf7\\u2ac1ightarro\\xf7\\u2a90\\u0180;qs\\u0c3b\\u2aba\\u2aealan\\xf4\\u0c55\\u0100;s\\u0c55\\u2af4\\xbb\\u0c36i\\xed\\u0c5d\\u0100;r\\u0c35\\u2afei\\u0100;e\\u0c1a\\u0c25i\\xe4\\u0d90\\u0100pt\\u2b0c\\u2b11f;\\uc000\\ud835\\udd5f\\u8180\\xac;in\\u2b19\\u2b1a\\u2b36\\u40acn\\u0200;Edv\\u0b89\\u2b24\\u2b28\\u2b2e;\\uc000\\u22f9\\u0338ot;\\uc000\\u22f5\\u0338\\u01e1\\u0b89\\u2b33\\u2b35;\\u62f7;\\u62f6i\\u0100;v\\u0cb8\\u2b3c\\u01e1\\u0cb8\\u2b41\\u2b43;\\u62fe;\\u62fd\\u0180aor\\u2b4b\\u2b63\\u2b69r\\u0200;ast\\u0b7b\\u2b55\\u2b5a\\u2b5flle\\xec\\u0b7bl;\\uc000\\u2afd\\u20e5;\\uc000\\u2202\\u0338lint;\\u6a14\\u0180;ce\\u0c92\\u2b70\\u2b73u\\xe5\\u0ca5\\u0100;c\\u0c98\\u2b78\\u0100;e\\u0c92\\u2b7d\\xf1\\u0c98\\u0200Aait\\u2b88\\u2b8b\\u2b9d\\u2ba7r\\xf2\\u2988rr\\u0180;cw\\u2b94\\u2b95\\u2b99\\u619b;\\uc000\\u2933\\u0338;\\uc000\\u219d\\u0338ghtarrow\\xbb\\u2b95ri\\u0100;e\\u0ccb\\u0cd6\\u0380chimpqu\\u2bbd\\u2bcd\\u2bd9\\u2b04\\u0b78\\u2be4\\u2bef\\u0200;cer\\u0d32\\u2bc6\\u0d37\\u2bc9u\\xe5\\u0d45;\\uc000\\ud835\\udcc3ort\\u026d\\u2b05\\0\\0\\u2bd6ar\\xe1\\u2b56m\\u0100;e\\u0d6e\\u2bdf\\u0100;q\\u0d74\\u0d73su\\u0100bp\\u2beb\\u2bed\\xe5\\u0cf8\\xe5\\u0d0b\\u0180bcp\\u2bf6\\u2c11\\u2c19\\u0200;Ees\\u2bff\\u2c00\\u0d22\\u2c04\\u6284;\\uc000\\u2ac5\\u0338et\\u0100;e\\u0d1b\\u2c0bq\\u0100;q\\u0d23\\u2c00c\\u0100;e\\u0d32\\u2c17\\xf1\\u0d38\\u0200;Ees\\u2c22\\u2c23\\u0d5f\\u2c27\\u6285;\\uc000\\u2ac6\\u0338et\\u0100;e\\u0d58\\u2c2eq\\u0100;q\\u0d60\\u2c23\\u0200gilr\\u2c3d\\u2c3f\\u2c45\\u2c47\\xec\\u0bd7lde\\u803b\\xf1\\u40f1\\xe7\\u0c43iangle\\u0100lr\\u2c52\\u2c5ceft\\u0100;e\\u0c1a\\u2c5a\\xf1\\u0c26ight\\u0100;e\\u0ccb\\u2c65\\xf1\\u0cd7\\u0100;m\\u2c6c\\u2c6d\\u43bd\\u0180;es\\u2c74\\u2c75\\u2c79\\u4023ro;\\u6116p;\\u6007\\u0480DHadgilrs\\u2c8f\\u2c94\\u2c99\\u2c9e\\u2ca3\\u2cb0\\u2cb6\\u2cd3\\u2ce3ash;\\u62adarr;\\u6904p;\\uc000\\u224d\\u20d2ash;\\u62ac\\u0100et\\u2ca8\\u2cac;\\uc000\\u2265\\u20d2;\\uc000>\\u20d2nfin;\\u69de\\u0180Aet\\u2cbd\\u2cc1\\u2cc5rr;\\u6902;\\uc000\\u2264\\u20d2\\u0100;r\\u2cca\\u2ccd\\uc000<\\u20d2ie;\\uc000\\u22b4\\u20d2\\u0100At\\u2cd8\\u2cdcrr;\\u6903rie;\\uc000\\u22b5\\u20d2im;\\uc000\\u223c\\u20d2\\u0180Aan\\u2cf0\\u2cf4\\u2d02rr;\\u61d6r\\u0100hr\\u2cfa\\u2cfdk;\\u6923\\u0100;o\\u13e7\\u13e5ear;\\u6927\\u1253\\u1a95\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\u2d2d\\0\\u2d38\\u2d48\\u2d60\\u2d65\\u2d72\\u2d84\\u1b07\\0\\0\\u2d8d\\u2dab\\0\\u2dc8\\u2dce\\0\\u2ddc\\u2e19\\u2e2b\\u2e3e\\u2e43\\u0100cs\\u2d31\\u1a97ute\\u803b\\xf3\\u40f3\\u0100iy\\u2d3c\\u2d45r\\u0100;c\\u1a9e\\u2d42\\u803b\\xf4\\u40f4;\\u443e\\u0280abios\\u1aa0\\u2d52\\u2d57\\u01c8\\u2d5alac;\\u4151v;\\u6a38old;\\u69bclig;\\u4153\\u0100cr\\u2d69\\u2d6dir;\\u69bf;\\uc000\\ud835\\udd2c\\u036f\\u2d79\\0\\0\\u2d7c\\0\\u2d82n;\\u42dbave\\u803b\\xf2\\u40f2;\\u69c1\\u0100bm\\u2d88\\u0df4ar;\\u69b5\\u0200acit\\u2d95\\u2d98\\u2da5\\u2da8r\\xf2\\u1a80\\u0100ir\\u2d9d\\u2da0r;\\u69beoss;\\u69bbn\\xe5\\u0e52;\\u69c0\\u0180aei\\u2db1\\u2db5\\u2db9cr;\\u414dga;\\u43c9\\u0180cdn\\u2dc0\\u2dc5\\u01cdron;\\u43bf;\\u69b6pf;\\uc000\\ud835\\udd60\\u0180ael\\u2dd4\\u2dd7\\u01d2r;\\u69b7rp;\\u69b9\\u0380;adiosv\\u2dea\\u2deb\\u2dee\\u2e08\\u2e0d\\u2e10\\u2e16\\u6228r\\xf2\\u1a86\\u0200;efm\\u2df7\\u2df8\\u2e02\\u2e05\\u6a5dr\\u0100;o\\u2dfe\\u2dff\\u6134f\\xbb\\u2dff\\u803b\\xaa\\u40aa\\u803b\\xba\\u40bagof;\\u62b6r;\\u6a56lope;\\u6a57;\\u6a5b\\u0180clo\\u2e1f\\u2e21\\u2e27\\xf2\\u2e01ash\\u803b\\xf8\\u40f8l;\\u6298i\\u016c\\u2e2f\\u2e34de\\u803b\\xf5\\u40f5es\\u0100;a\\u01db\\u2e3as;\\u6a36ml\\u803b\\xf6\\u40f6bar;\\u633d\\u0ae1\\u2e5e\\0\\u2e7d\\0\\u2e80\\u2e9d\\0\\u2ea2\\u2eb9\\0\\0\\u2ecb\\u0e9c\\0\\u2f13\\0\\0\\u2f2b\\u2fbc\\0\\u2fc8r\\u0200;ast\\u0403\\u2e67\\u2e72\\u0e85\\u8100\\xb6;l\\u2e6d\\u2e6e\\u40b6le\\xec\\u0403\\u0269\\u2e78\\0\\0\\u2e7bm;\\u6af3;\\u6afdy;\\u443fr\\u0280cimpt\\u2e8b\\u2e8f\\u2e93\\u1865\\u2e97nt;\\u4025od;\\u402eil;\\u6030enk;\\u6031r;\\uc000\\ud835\\udd2d\\u0180imo\\u2ea8\\u2eb0\\u2eb4\\u0100;v\\u2ead\\u2eae\\u43c6;\\u43d5ma\\xf4\\u0a76ne;\\u660e\\u0180;tv\\u2ebf\\u2ec0\\u2ec8\\u43c0chfork\\xbb\\u1ffd;\\u43d6\\u0100au\\u2ecf\\u2edfn\\u0100ck\\u2ed5\\u2eddk\\u0100;h\\u21f4\\u2edb;\\u610e\\xf6\\u21f4s\\u0480;abcdemst\\u2ef3\\u2ef4\\u1908\\u2ef9\\u2efd\\u2f04\\u2f06\\u2f0a\\u2f0e\\u402bcir;\\u6a23ir;\\u6a22\\u0100ou\\u1d40\\u2f02;\\u6a25;\\u6a72n\\u80bb\\xb1\\u0e9dim;\\u6a26wo;\\u6a27\\u0180ipu\\u2f19\\u2f20\\u2f25ntint;\\u6a15f;\\uc000\\ud835\\udd61nd\\u803b\\xa3\\u40a3\\u0500;Eaceinosu\\u0ec8\\u2f3f\\u2f41\\u2f44\\u2f47\\u2f81\\u2f89\\u2f92\\u2f7e\\u2fb6;\\u6ab3p;\\u6ab7u\\xe5\\u0ed9\\u0100;c\\u0ece\\u2f4c\\u0300;acens\\u0ec8\\u2f59\\u2f5f\\u2f66\\u2f68\\u2f7eppro\\xf8\\u2f43urlye\\xf1\\u0ed9\\xf1\\u0ece\\u0180aes\\u2f6f\\u2f76\\u2f7approx;\\u6ab9qq;\\u6ab5im;\\u62e8i\\xed\\u0edfme\\u0100;s\\u2f88\\u0eae\\u6032\\u0180Eas\\u2f78\\u2f90\\u2f7a\\xf0\\u2f75\\u0180dfp\\u0eec\\u2f99\\u2faf\\u0180als\\u2fa0\\u2fa5\\u2faalar;\\u632eine;\\u6312urf;\\u6313\\u0100;t\\u0efb\\u2fb4\\xef\\u0efbrel;\\u62b0\\u0100ci\\u2fc0\\u2fc5r;\\uc000\\ud835\\udcc5;\\u43c8ncsp;\\u6008\\u0300fiopsu\\u2fda\\u22e2\\u2fdf\\u2fe5\\u2feb\\u2ff1r;\\uc000\\ud835\\udd2epf;\\uc000\\ud835\\udd62rime;\\u6057cr;\\uc000\\ud835\\udcc6\\u0180aeo\\u2ff8\\u3009\\u3013t\\u0100ei\\u2ffe\\u3005rnion\\xf3\\u06b0nt;\\u6a16st\\u0100;e\\u3010\\u3011\\u403f\\xf1\\u1f19\\xf4\\u0f14\\u0a80ABHabcdefhilmnoprstux\\u3040\\u3051\\u3055\\u3059\\u30e0\\u310e\\u312b\\u3147\\u3162\\u3172\\u318e\\u3206\\u3215\\u3224\\u3229\\u3258\\u326e\\u3272\\u3290\\u32b0\\u32b7\\u0180art\\u3047\\u304a\\u304cr\\xf2\\u10b3\\xf2\\u03ddail;\\u691car\\xf2\\u1c65ar;\\u6964\\u0380cdenqrt\\u3068\\u3075\\u3078\\u307f\\u308f\\u3094\\u30cc\\u0100eu\\u306d\\u3071;\\uc000\\u223d\\u0331te;\\u4155i\\xe3\\u116emptyv;\\u69b3g\\u0200;del\\u0fd1\\u3089\\u308b\\u308d;\\u6992;\\u69a5\\xe5\\u0fd1uo\\u803b\\xbb\\u40bbr\\u0580;abcfhlpstw\\u0fdc\\u30ac\\u30af\\u30b7\\u30b9\\u30bc\\u30be\\u30c0\\u30c3\\u30c7\\u30cap;\\u6975\\u0100;f\\u0fe0\\u30b4s;\\u6920;\\u6933s;\\u691e\\xeb\\u225d\\xf0\\u272el;\\u6945im;\\u6974l;\\u61a3;\\u619d\\u0100ai\\u30d1\\u30d5il;\\u691ao\\u0100;n\\u30db\\u30dc\\u6236al\\xf3\\u0f1e\\u0180abr\\u30e7\\u30ea\\u30eer\\xf2\\u17e5rk;\\u6773\\u0100ak\\u30f3\\u30fdc\\u0100ek\\u30f9\\u30fb;\\u407d;\\u405d\\u0100es\\u3102\\u3104;\\u698cl\\u0100du\\u310a\\u310c;\\u698e;\\u6990\\u0200aeuy\\u3117\\u311c\\u3127\\u3129ron;\\u4159\\u0100di\\u3121\\u3125il;\\u4157\\xec\\u0ff2\\xe2\\u30fa;\\u4440\\u0200clqs\\u3134\\u3137\\u313d\\u3144a;\\u6937dhar;\\u6969uo\\u0100;r\\u020e\\u020dh;\\u61b3\\u0180acg\\u314e\\u315f\\u0f44l\\u0200;ips\\u0f78\\u3158\\u315b\\u109cn\\xe5\\u10bbar\\xf4\\u0fa9t;\\u65ad\\u0180ilr\\u3169\\u1023\\u316esht;\\u697d;\\uc000\\ud835\\udd2f\\u0100ao\\u3177\\u3186r\\u0100du\\u317d\\u317f\\xbb\\u047b\\u0100;l\\u1091\\u3184;\\u696c\\u0100;v\\u318b\\u318c\\u43c1;\\u43f1\\u0180gns\\u3195\\u31f9\\u31fcht\\u0300ahlrst\\u31a4\\u31b0\\u31c2\\u31d8\\u31e4\\u31eerrow\\u0100;t\\u0fdc\\u31ada\\xe9\\u30c8arpoon\\u0100du\\u31bb\\u31bfow\\xee\\u317ep\\xbb\\u1092eft\\u0100ah\\u31ca\\u31d0rrow\\xf3\\u0feaarpoon\\xf3\\u0551ightarrows;\\u61c9quigarro\\xf7\\u30cbhreetimes;\\u62ccg;\\u42daingdotse\\xf1\\u1f32\\u0180ahm\\u320d\\u3210\\u3213r\\xf2\\u0feaa\\xf2\\u0551;\\u600foust\\u0100;a\\u321e\\u321f\\u63b1che\\xbb\\u321fmid;\\u6aee\\u0200abpt\\u3232\\u323d\\u3240\\u3252\\u0100nr\\u3237\\u323ag;\\u67edr;\\u61fer\\xeb\\u1003\\u0180afl\\u3247\\u324a\\u324er;\\u6986;\\uc000\\ud835\\udd63us;\\u6a2eimes;\\u6a35\\u0100ap\\u325d\\u3267r\\u0100;g\\u3263\\u3264\\u4029t;\\u6994olint;\\u6a12ar\\xf2\\u31e3\\u0200achq\\u327b\\u3280\\u10bc\\u3285quo;\\u603ar;\\uc000\\ud835\\udcc7\\u0100bu\\u30fb\\u328ao\\u0100;r\\u0214\\u0213\\u0180hir\\u3297\\u329b\\u32a0re\\xe5\\u31f8mes;\\u62cai\\u0200;efl\\u32aa\\u1059\\u1821\\u32ab\\u65b9tri;\\u69celuhar;\\u6968;\\u611e\\u0d61\\u32d5\\u32db\\u32df\\u332c\\u3338\\u3371\\0\\u337a\\u33a4\\0\\0\\u33ec\\u33f0\\0\\u3428\\u3448\\u345a\\u34ad\\u34b1\\u34ca\\u34f1\\0\\u3616\\0\\0\\u3633cute;\\u415bqu\\xef\\u27ba\\u0500;Eaceinpsy\\u11ed\\u32f3\\u32f5\\u32ff\\u3302\\u330b\\u330f\\u331f\\u3326\\u3329;\\u6ab4\\u01f0\\u32fa\\0\\u32fc;\\u6ab8on;\\u4161u\\xe5\\u11fe\\u0100;d\\u11f3\\u3307il;\\u415frc;\\u415d\\u0180Eas\\u3316\\u3318\\u331b;\\u6ab6p;\\u6abaim;\\u62e9olint;\\u6a13i\\xed\\u1204;\\u4441ot\\u0180;be\\u3334\\u1d47\\u3335\\u62c5;\\u6a66\\u0380Aacmstx\\u3346\\u334a\\u3357\\u335b\\u335e\\u3363\\u336drr;\\u61d8r\\u0100hr\\u3350\\u3352\\xeb\\u2228\\u0100;o\\u0a36\\u0a34t\\u803b\\xa7\\u40a7i;\\u403bwar;\\u6929m\\u0100in\\u3369\\xf0nu\\xf3\\xf1t;\\u6736r\\u0100;o\\u3376\\u2055\\uc000\\ud835\\udd30\\u0200acoy\\u3382\\u3386\\u3391\\u33a0rp;\\u666f\\u0100hy\\u338b\\u338fcy;\\u4449;\\u4448rt\\u026d\\u3399\\0\\0\\u339ci\\xe4\\u1464ara\\xec\\u2e6f\\u803b\\xad\\u40ad\\u0100gm\\u33a8\\u33b4ma\\u0180;fv\\u33b1\\u33b2\\u33b2\\u43c3;\\u43c2\\u0400;deglnpr\\u12ab\\u33c5\\u33c9\\u33ce\\u33d6\\u33de\\u33e1\\u33e6ot;\\u6a6a\\u0100;q\\u12b1\\u12b0\\u0100;E\\u33d3\\u33d4\\u6a9e;\\u6aa0\\u0100;E\\u33db\\u33dc\\u6a9d;\\u6a9fe;\\u6246lus;\\u6a24arr;\\u6972ar\\xf2\\u113d\\u0200aeit\\u33f8\\u3408\\u340f\\u3417\\u0100ls\\u33fd\\u3404lsetm\\xe9\\u336ahp;\\u6a33parsl;\\u69e4\\u0100dl\\u1463\\u3414e;\\u6323\\u0100;e\\u341c\\u341d\\u6aaa\\u0100;s\\u3422\\u3423\\u6aac;\\uc000\\u2aac\\ufe00\\u0180flp\\u342e\\u3433\\u3442tcy;\\u444c\\u0100;b\\u3438\\u3439\\u402f\\u0100;a\\u343e\\u343f\\u69c4r;\\u633ff;\\uc000\\ud835\\udd64a\\u0100dr\\u344d\\u0402es\\u0100;u\\u3454\\u3455\\u6660it\\xbb\\u3455\\u0180csu\\u3460\\u3479\\u349f\\u0100au\\u3465\\u346fp\\u0100;s\\u1188\\u346b;\\uc000\\u2293\\ufe00p\\u0100;s\\u11b4\\u3475;\\uc000\\u2294\\ufe00u\\u0100bp\\u347f\\u348f\\u0180;es\\u1197\\u119c\\u3486et\\u0100;e\\u1197\\u348d\\xf1\\u119d\\u0180;es\\u11a8\\u11ad\\u3496et\\u0100;e\\u11a8\\u349d\\xf1\\u11ae\\u0180;af\\u117b\\u34a6\\u05b0r\\u0165\\u34ab\\u05b1\\xbb\\u117car\\xf2\\u1148\\u0200cemt\\u34b9\\u34be\\u34c2\\u34c5r;\\uc000\\ud835\\udcc8tm\\xee\\xf1i\\xec\\u3415ar\\xe6\\u11be\\u0100ar\\u34ce\\u34d5r\\u0100;f\\u34d4\\u17bf\\u6606\\u0100an\\u34da\\u34edight\\u0100ep\\u34e3\\u34eapsilo\\xee\\u1ee0h\\xe9\\u2eafs\\xbb\\u2852\\u0280bcmnp\\u34fb\\u355e\\u1209\\u358b\\u358e\\u0480;Edemnprs\\u350e\\u350f\\u3511\\u3515\\u351e\\u3523\\u352c\\u3531\\u3536\\u6282;\\u6ac5ot;\\u6abd\\u0100;d\\u11da\\u351aot;\\u6ac3ult;\\u6ac1\\u0100Ee\\u3528\\u352a;\\u6acb;\\u628alus;\\u6abfarr;\\u6979\\u0180eiu\\u353d\\u3552\\u3555t\\u0180;en\\u350e\\u3545\\u354bq\\u0100;q\\u11da\\u350feq\\u0100;q\\u352b\\u3528m;\\u6ac7\\u0100bp\\u355a\\u355c;\\u6ad5;\\u6ad3c\\u0300;acens\\u11ed\\u356c\\u3572\\u3579\\u357b\\u3326ppro\\xf8\\u32faurlye\\xf1\\u11fe\\xf1\\u11f3\\u0180aes\\u3582\\u3588\\u331bppro\\xf8\\u331aq\\xf1\\u3317g;\\u666a\\u0680123;Edehlmnps\\u35a9\\u35ac\\u35af\\u121c\\u35b2\\u35b4\\u35c0\\u35c9\\u35d5\\u35da\\u35df\\u35e8\\u35ed\\u803b\\xb9\\u40b9\\u803b\\xb2\\u40b2\\u803b\\xb3\\u40b3;\\u6ac6\\u0100os\\u35b9\\u35bct;\\u6abeub;\\u6ad8\\u0100;d\\u1222\\u35c5ot;\\u6ac4s\\u0100ou\\u35cf\\u35d2l;\\u67c9b;\\u6ad7arr;\\u697bult;\\u6ac2\\u0100Ee\\u35e4\\u35e6;\\u6acc;\\u628blus;\\u6ac0\\u0180eiu\\u35f4\\u3609\\u360ct\\u0180;en\\u121c\\u35fc\\u3602q\\u0100;q\\u1222\\u35b2eq\\u0100;q\\u35e7\\u35e4m;\\u6ac8\\u0100bp\\u3611\\u3613;\\u6ad4;\\u6ad6\\u0180Aan\\u361c\\u3620\\u362drr;\\u61d9r\\u0100hr\\u3626\\u3628\\xeb\\u222e\\u0100;o\\u0a2b\\u0a29war;\\u692alig\\u803b\\xdf\\u40df\\u0be1\\u3651\\u365d\\u3660\\u12ce\\u3673\\u3679\\0\\u367e\\u36c2\\0\\0\\0\\0\\0\\u36db\\u3703\\0\\u3709\\u376c\\0\\0\\0\\u3787\\u0272\\u3656\\0\\0\\u365bget;\\u6316;\\u43c4r\\xeb\\u0e5f\\u0180aey\\u3666\\u366b\\u3670ron;\\u4165dil;\\u4163;\\u4442lrec;\\u6315r;\\uc000\\ud835\\udd31\\u0200eiko\\u3686\\u369d\\u36b5\\u36bc\\u01f2\\u368b\\0\\u3691e\\u01004f\\u1284\\u1281a\\u0180;sv\\u3698\\u3699\\u369b\\u43b8ym;\\u43d1\\u0100cn\\u36a2\\u36b2k\\u0100as\\u36a8\\u36aeppro\\xf8\\u12c1im\\xbb\\u12acs\\xf0\\u129e\\u0100as\\u36ba\\u36ae\\xf0\\u12c1rn\\u803b\\xfe\\u40fe\\u01ec\\u031f\\u36c6\\u22e7es\\u8180\\xd7;bd\\u36cf\\u36d0\\u36d8\\u40d7\\u0100;a\\u190f\\u36d5r;\\u6a31;\\u6a30\\u0180eps\\u36e1\\u36e3\\u3700\\xe1\\u2a4d\\u0200;bcf\\u0486\\u36ec\\u36f0\\u36f4ot;\\u6336ir;\\u6af1\\u0100;o\\u36f9\\u36fc\\uc000\\ud835\\udd65rk;\\u6ada\\xe1\\u3362rime;\\u6034\\u0180aip\\u370f\\u3712\\u3764d\\xe5\\u1248\\u0380adempst\\u3721\\u374d\\u3740\\u3751\\u3757\\u375c\\u375fngle\\u0280;dlqr\\u3730\\u3731\\u3736\\u3740\\u3742\\u65b5own\\xbb\\u1dbbeft\\u0100;e\\u2800\\u373e\\xf1\\u092e;\\u625cight\\u0100;e\\u32aa\\u374b\\xf1\\u105aot;\\u65ecinus;\\u6a3alus;\\u6a39b;\\u69cdime;\\u6a3bezium;\\u63e2\\u0180cht\\u3772\\u377d\\u3781\\u0100ry\\u3777\\u377b;\\uc000\\ud835\\udcc9;\\u4446cy;\\u445brok;\\u4167\\u0100io\\u378b\\u378ex\\xf4\\u1777head\\u0100lr\\u3797\\u37a0eftarro\\xf7\\u084fightarrow\\xbb\\u0f5d\\u0900AHabcdfghlmoprstuw\\u37d0\\u37d3\\u37d7\\u37e4\\u37f0\\u37fc\\u380e\\u381c\\u3823\\u3834\\u3851\\u385d\\u386b\\u38a9\\u38cc\\u38d2\\u38ea\\u38f6r\\xf2\\u03edar;\\u6963\\u0100cr\\u37dc\\u37e2ute\\u803b\\xfa\\u40fa\\xf2\\u1150r\\u01e3\\u37ea\\0\\u37edy;\\u445eve;\\u416d\\u0100iy\\u37f5\\u37farc\\u803b\\xfb\\u40fb;\\u4443\\u0180abh\\u3803\\u3806\\u380br\\xf2\\u13adlac;\\u4171a\\xf2\\u13c3\\u0100ir\\u3813\\u3818sht;\\u697e;\\uc000\\ud835\\udd32rave\\u803b\\xf9\\u40f9\\u0161\\u3827\\u3831r\\u0100lr\\u382c\\u382e\\xbb\\u0957\\xbb\\u1083lk;\\u6580\\u0100ct\\u3839\\u384d\\u026f\\u383f\\0\\0\\u384arn\\u0100;e\\u3845\\u3846\\u631cr\\xbb\\u3846op;\\u630fri;\\u65f8\\u0100al\\u3856\\u385acr;\\u416b\\u80bb\\xa8\\u0349\\u0100gp\\u3862\\u3866on;\\u4173f;\\uc000\\ud835\\udd66\\u0300adhlsu\\u114b\\u3878\\u387d\\u1372\\u3891\\u38a0own\\xe1\\u13b3arpoon\\u0100lr\\u3888\\u388cef\\xf4\\u382digh\\xf4\\u382fi\\u0180;hl\\u3899\\u389a\\u389c\\u43c5\\xbb\\u13faon\\xbb\\u389aparrows;\\u61c8\\u0180cit\\u38b0\\u38c4\\u38c8\\u026f\\u38b6\\0\\0\\u38c1rn\\u0100;e\\u38bc\\u38bd\\u631dr\\xbb\\u38bdop;\\u630eng;\\u416fri;\\u65f9cr;\\uc000\\ud835\\udcca\\u0180dir\\u38d9\\u38dd\\u38e2ot;\\u62f0lde;\\u4169i\\u0100;f\\u3730\\u38e8\\xbb\\u1813\\u0100am\\u38ef\\u38f2r\\xf2\\u38a8l\\u803b\\xfc\\u40fcangle;\\u69a7\\u0780ABDacdeflnoprsz\\u391c\\u391f\\u3929\\u392d\\u39b5\\u39b8\\u39bd\\u39df\\u39e4\\u39e8\\u39f3\\u39f9\\u39fd\\u3a01\\u3a20r\\xf2\\u03f7ar\\u0100;v\\u3926\\u3927\\u6ae8;\\u6ae9as\\xe8\\u03e1\\u0100nr\\u3932\\u3937grt;\\u699c\\u0380eknprst\\u34e3\\u3946\\u394b\\u3952\\u395d\\u3964\\u3996app\\xe1\\u2415othin\\xe7\\u1e96\\u0180hir\\u34eb\\u2ec8\\u3959op\\xf4\\u2fb5\\u0100;h\\u13b7\\u3962\\xef\\u318d\\u0100iu\\u3969\\u396dgm\\xe1\\u33b3\\u0100bp\\u3972\\u3984setneq\\u0100;q\\u397d\\u3980\\uc000\\u228a\\ufe00;\\uc000\\u2acb\\ufe00setneq\\u0100;q\\u398f\\u3992\\uc000\\u228b\\ufe00;\\uc000\\u2acc\\ufe00\\u0100hr\\u399b\\u399fet\\xe1\\u369ciangle\\u0100lr\\u39aa\\u39afeft\\xbb\\u0925ight\\xbb\\u1051y;\\u4432ash\\xbb\\u1036\\u0180elr\\u39c4\\u39d2\\u39d7\\u0180;be\\u2dea\\u39cb\\u39cfar;\\u62bbq;\\u625alip;\\u62ee\\u0100bt\\u39dc\\u1468a\\xf2\\u1469r;\\uc000\\ud835\\udd33tr\\xe9\\u39aesu\\u0100bp\\u39ef\\u39f1\\xbb\\u0d1c\\xbb\\u0d59pf;\\uc000\\ud835\\udd67ro\\xf0\\u0efbtr\\xe9\\u39b4\\u0100cu\\u3a06\\u3a0br;\\uc000\\ud835\\udccb\\u0100bp\\u3a10\\u3a18n\\u0100Ee\\u3980\\u3a16\\xbb\\u397en\\u0100Ee\\u3992\\u3a1e\\xbb\\u3990igzag;\\u699a\\u0380cefoprs\\u3a36\\u3a3b\\u3a56\\u3a5b\\u3a54\\u3a61\\u3a6airc;\\u4175\\u0100di\\u3a40\\u3a51\\u0100bg\\u3a45\\u3a49ar;\\u6a5fe\\u0100;q\\u15fa\\u3a4f;\\u6259erp;\\u6118r;\\uc000\\ud835\\udd34pf;\\uc000\\ud835\\udd68\\u0100;e\\u1479\\u3a66at\\xe8\\u1479cr;\\uc000\\ud835\\udccc\\u0ae3\\u178e\\u3a87\\0\\u3a8b\\0\\u3a90\\u3a9b\\0\\0\\u3a9d\\u3aa8\\u3aab\\u3aaf\\0\\0\\u3ac3\\u3ace\\0\\u3ad8\\u17dc\\u17dftr\\xe9\\u17d1r;\\uc000\\ud835\\udd35\\u0100Aa\\u3a94\\u3a97r\\xf2\\u03c3r\\xf2\\u09f6;\\u43be\\u0100Aa\\u3aa1\\u3aa4r\\xf2\\u03b8r\\xf2\\u09eba\\xf0\\u2713is;\\u62fb\\u0180dpt\\u17a4\\u3ab5\\u3abe\\u0100fl\\u3aba\\u17a9;\\uc000\\ud835\\udd69im\\xe5\\u17b2\\u0100Aa\\u3ac7\\u3acar\\xf2\\u03cer\\xf2\\u0a01\\u0100cq\\u3ad2\\u17b8r;\\uc000\\ud835\\udccd\\u0100pt\\u17d6\\u3adcr\\xe9\\u17d4\\u0400acefiosu\\u3af0\\u3afd\\u3b08\\u3b0c\\u3b11\\u3b15\\u3b1b\\u3b21c\\u0100uy\\u3af6\\u3afbte\\u803b\\xfd\\u40fd;\\u444f\\u0100iy\\u3b02\\u3b06rc;\\u4177;\\u444bn\\u803b\\xa5\\u40a5r;\\uc000\\ud835\\udd36cy;\\u4457pf;\\uc000\\ud835\\udd6acr;\\uc000\\ud835\\udcce\\u0100cm\\u3b26\\u3b29y;\\u444el\\u803b\\xff\\u40ff\\u0500acdefhiosw\\u3b42\\u3b48\\u3b54\\u3b58\\u3b64\\u3b69\\u3b6d\\u3b74\\u3b7a\\u3b80cute;\\u417a\\u0100ay\\u3b4d\\u3b52ron;\\u417e;\\u4437ot;\\u417c\\u0100et\\u3b5d\\u3b61tr\\xe6\\u155fa;\\u43b6r;\\uc000\\ud835\\udd37cy;\\u4436grarr;\\u61ddpf;\\uc000\\ud835\\udd6bcr;\\uc000\\ud835\\udccf\\u0100jn\\u3b85\\u3b87;\\u600dj;\\u600c\"\n    .split(\"\")\n    .map((c) => c.charCodeAt(0)));\n//# sourceMappingURL=decode-data-html.js.map","// Generated using scripts/write-decode-map.ts\nexport default new Uint16Array(\n// prettier-ignore\n\"\\u0200aglq\\t\\x15\\x18\\x1b\\u026d\\x0f\\0\\0\\x12p;\\u4026os;\\u4027t;\\u403et;\\u403cuot;\\u4022\"\n    .split(\"\")\n    .map((c) => c.charCodeAt(0)));\n//# sourceMappingURL=decode-data-xml.js.map","// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\nvar _a;\nconst decodeMap = new Map([\n    [0, 65533],\n    // C1 Unicode control character reference replacements\n    [128, 8364],\n    [130, 8218],\n    [131, 402],\n    [132, 8222],\n    [133, 8230],\n    [134, 8224],\n    [135, 8225],\n    [136, 710],\n    [137, 8240],\n    [138, 352],\n    [139, 8249],\n    [140, 338],\n    [142, 381],\n    [145, 8216],\n    [146, 8217],\n    [147, 8220],\n    [148, 8221],\n    [149, 8226],\n    [150, 8211],\n    [151, 8212],\n    [152, 732],\n    [153, 8482],\n    [154, 353],\n    [155, 8250],\n    [156, 339],\n    [158, 382],\n    [159, 376],\n]);\n/**\n * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.\n */\nexport const fromCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins\n(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {\n    let output = \"\";\n    if (codePoint > 0xffff) {\n        codePoint -= 0x10000;\n        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);\n        codePoint = 0xdc00 | (codePoint & 0x3ff);\n    }\n    output += String.fromCharCode(codePoint);\n    return output;\n};\n/**\n * Replace the given code point with a replacement character if it is a\n * surrogate or is outside the valid range. Otherwise return the code\n * point unchanged.\n */\nexport function replaceCodePoint(codePoint) {\n    var _a;\n    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {\n        return 0xfffd;\n    }\n    return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;\n}\n/**\n * Replace the code point if relevant, then convert it to a string.\n *\n * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.\n * @param codePoint The code point to decode.\n * @returns The decoded code point.\n */\nexport default function decodeCodePoint(codePoint) {\n    return fromCodePoint(replaceCodePoint(codePoint));\n}\n//# sourceMappingURL=decode_codepoint.js.map","import htmlDecodeTree from \"./generated/decode-data-html.js\";\nimport xmlDecodeTree from \"./generated/decode-data-xml.js\";\nimport decodeCodePoint, { replaceCodePoint, fromCodePoint, } from \"./decode_codepoint.js\";\n// Re-export for use by eg. htmlparser2\nexport { htmlDecodeTree, xmlDecodeTree, decodeCodePoint };\nexport { replaceCodePoint, fromCodePoint } from \"./decode_codepoint.js\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n    CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n    CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n    CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n    CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n    CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n    CharCodes[CharCodes[\"LOWER_F\"] = 102] = \"LOWER_F\";\n    CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n    CharCodes[CharCodes[\"LOWER_Z\"] = 122] = \"LOWER_Z\";\n    CharCodes[CharCodes[\"UPPER_A\"] = 65] = \"UPPER_A\";\n    CharCodes[CharCodes[\"UPPER_F\"] = 70] = \"UPPER_F\";\n    CharCodes[CharCodes[\"UPPER_Z\"] = 90] = \"UPPER_Z\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nconst TO_LOWER_BIT = 0b100000;\nexport var BinTrieFlags;\n(function (BinTrieFlags) {\n    BinTrieFlags[BinTrieFlags[\"VALUE_LENGTH\"] = 49152] = \"VALUE_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 16256] = \"BRANCH_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n})(BinTrieFlags || (BinTrieFlags = {}));\nfunction isNumber(code) {\n    return code >= CharCodes.ZERO && code <= CharCodes.NINE;\n}\nfunction isHexadecimalCharacter(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F));\n}\nfunction isAsciiAlphaNumeric(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z) ||\n        isNumber(code));\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n    return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n    EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n    EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n    EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\nexport var DecodingMode;\n(function (DecodingMode) {\n    /** Entities in text nodes that can end with any character. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Only allow entities terminated with a semicolon. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n    /** Entities in attributes have limitations on ending characters. */\n    DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode || (DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nexport class EntityDecoder {\n    constructor(\n    /** The tree used to decode entities. */\n    decodeTree, \n    /**\n     * The function that is called when a codepoint is decoded.\n     *\n     * For multi-byte named entities, this will be called multiple times,\n     * with the second codepoint, and the same `consumed` value.\n     *\n     * @param codepoint The decoded codepoint.\n     * @param consumed The number of bytes consumed by the decoder.\n     */\n    emitCodePoint, \n    /** An object that is used to produce errors. */\n    errors) {\n        this.decodeTree = decodeTree;\n        this.emitCodePoint = emitCodePoint;\n        this.errors = errors;\n        /** The current state of the decoder. */\n        this.state = EntityDecoderState.EntityStart;\n        /** Characters that were consumed while parsing an entity. */\n        this.consumed = 1;\n        /**\n         * The result of the entity.\n         *\n         * Either the result index of a numeric entity, or the codepoint of a\n         * numeric entity.\n         */\n        this.result = 0;\n        /** The current index in the decode tree. */\n        this.treeIndex = 0;\n        /** The number of characters that were consumed in excess. */\n        this.excess = 1;\n        /** The mode in which the decoder is operating. */\n        this.decodeMode = DecodingMode.Strict;\n    }\n    /** Resets the instance to make it reusable. */\n    startEntity(decodeMode) {\n        this.decodeMode = decodeMode;\n        this.state = EntityDecoderState.EntityStart;\n        this.result = 0;\n        this.treeIndex = 0;\n        this.excess = 1;\n        this.consumed = 1;\n    }\n    /**\n     * Write an entity to the decoder. This can be called multiple times with partial entities.\n     * If the entity is incomplete, the decoder will return -1.\n     *\n     * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the\n     * entity is incomplete, and resume when the next string is written.\n     *\n     * @param string The string containing the entity (or a continuation of the entity).\n     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    write(str, offset) {\n        switch (this.state) {\n            case EntityDecoderState.EntityStart: {\n                if (str.charCodeAt(offset) === CharCodes.NUM) {\n                    this.state = EntityDecoderState.NumericStart;\n                    this.consumed += 1;\n                    return this.stateNumericStart(str, offset + 1);\n                }\n                this.state = EntityDecoderState.NamedEntity;\n                return this.stateNamedEntity(str, offset);\n            }\n            case EntityDecoderState.NumericStart: {\n                return this.stateNumericStart(str, offset);\n            }\n            case EntityDecoderState.NumericDecimal: {\n                return this.stateNumericDecimal(str, offset);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.stateNumericHex(str, offset);\n            }\n            case EntityDecoderState.NamedEntity: {\n                return this.stateNamedEntity(str, offset);\n            }\n        }\n    }\n    /**\n     * Switches between the numeric decimal and hexadecimal states.\n     *\n     * Equivalent to the `Numeric character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericStart(str, offset) {\n        if (offset >= str.length) {\n            return -1;\n        }\n        if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n            this.state = EntityDecoderState.NumericHex;\n            this.consumed += 1;\n            return this.stateNumericHex(str, offset + 1);\n        }\n        this.state = EntityDecoderState.NumericDecimal;\n        return this.stateNumericDecimal(str, offset);\n    }\n    addToNumericResult(str, start, end, base) {\n        if (start !== end) {\n            const digitCount = end - start;\n            this.result =\n                this.result * Math.pow(base, digitCount) +\n                    parseInt(str.substr(start, digitCount), base);\n            this.consumed += digitCount;\n        }\n    }\n    /**\n     * Parses a hexadecimal numeric entity.\n     *\n     * Equivalent to the `Hexademical character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericHex(str, offset) {\n        const startIdx = offset;\n        while (offset < str.length) {\n            const char = str.charCodeAt(offset);\n            if (isNumber(char) || isHexadecimalCharacter(char)) {\n                offset += 1;\n            }\n            else {\n                this.addToNumericResult(str, startIdx, offset, 16);\n                return this.emitNumericEntity(char, 3);\n            }\n        }\n        this.addToNumericResult(str, startIdx, offset, 16);\n        return -1;\n    }\n    /**\n     * Parses a decimal numeric entity.\n     *\n     * Equivalent to the `Decimal character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericDecimal(str, offset) {\n        const startIdx = offset;\n        while (offset < str.length) {\n            const char = str.charCodeAt(offset);\n            if (isNumber(char)) {\n                offset += 1;\n            }\n            else {\n                this.addToNumericResult(str, startIdx, offset, 10);\n                return this.emitNumericEntity(char, 2);\n            }\n        }\n        this.addToNumericResult(str, startIdx, offset, 10);\n        return -1;\n    }\n    /**\n     * Validate and emit a numeric entity.\n     *\n     * Implements the logic from the `Hexademical character reference start\n     * state` and `Numeric character reference end state` in the HTML spec.\n     *\n     * @param lastCp The last code point of the entity. Used to see if the\n     *               entity was terminated with a semicolon.\n     * @param expectedLength The minimum number of characters that should be\n     *                       consumed. Used to validate that at least one digit\n     *                       was consumed.\n     * @returns The number of characters that were consumed.\n     */\n    emitNumericEntity(lastCp, expectedLength) {\n        var _a;\n        // Ensure we consumed at least one digit.\n        if (this.consumed <= expectedLength) {\n            (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n            return 0;\n        }\n        // Figure out if this is a legit end of the entity\n        if (lastCp === CharCodes.SEMI) {\n            this.consumed += 1;\n        }\n        else if (this.decodeMode === DecodingMode.Strict) {\n            return 0;\n        }\n        this.emitCodePoint(replaceCodePoint(this.result), this.consumed);\n        if (this.errors) {\n            if (lastCp !== CharCodes.SEMI) {\n                this.errors.missingSemicolonAfterCharacterReference();\n            }\n            this.errors.validateNumericCharacterReference(this.result);\n        }\n        return this.consumed;\n    }\n    /**\n     * Parses a named entity.\n     *\n     * Equivalent to the `Named character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNamedEntity(str, offset) {\n        const { decodeTree } = this;\n        let current = decodeTree[this.treeIndex];\n        // The mask is the number of bytes of the value, including the current byte.\n        let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n        for (; offset < str.length; offset++, this.excess++) {\n            const char = str.charCodeAt(offset);\n            this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);\n            if (this.treeIndex < 0) {\n                return this.result === 0 ||\n                    // If we are parsing an attribute\n                    (this.decodeMode === DecodingMode.Attribute &&\n                        // We shouldn't have consumed any characters after the entity,\n                        (valueLength === 0 ||\n                            // And there should be no invalid characters.\n                            isEntityInAttributeInvalidEnd(char)))\n                    ? 0\n                    : this.emitNotTerminatedNamedEntity();\n            }\n            current = decodeTree[this.treeIndex];\n            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n            // If the branch is a value, store it and continue\n            if (valueLength !== 0) {\n                // If the entity is terminated by a semicolon, we are done.\n                if (char === CharCodes.SEMI) {\n                    return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);\n                }\n                // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.\n                if (this.decodeMode !== DecodingMode.Strict) {\n                    this.result = this.treeIndex;\n                    this.consumed += this.excess;\n                    this.excess = 0;\n                }\n            }\n        }\n        return -1;\n    }\n    /**\n     * Emit a named entity that was not terminated with a semicolon.\n     *\n     * @returns The number of characters consumed.\n     */\n    emitNotTerminatedNamedEntity() {\n        var _a;\n        const { result, decodeTree } = this;\n        const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;\n        this.emitNamedEntityData(result, valueLength, this.consumed);\n        (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();\n        return this.consumed;\n    }\n    /**\n     * Emit a named entity.\n     *\n     * @param result The index of the entity in the decode tree.\n     * @param valueLength The number of bytes in the entity.\n     * @param consumed The number of characters consumed.\n     *\n     * @returns The number of characters consumed.\n     */\n    emitNamedEntityData(result, valueLength, consumed) {\n        const { decodeTree } = this;\n        this.emitCodePoint(valueLength === 1\n            ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH\n            : decodeTree[result + 1], consumed);\n        if (valueLength === 3) {\n            // For multi-byte values, we need to emit the second byte.\n            this.emitCodePoint(decodeTree[result + 2], consumed);\n        }\n        return consumed;\n    }\n    /**\n     * Signal to the parser that the end of the input was reached.\n     *\n     * Remaining data will be emitted and relevant errors will be produced.\n     *\n     * @returns The number of characters consumed.\n     */\n    end() {\n        var _a;\n        switch (this.state) {\n            case EntityDecoderState.NamedEntity: {\n                // Emit a named entity if we have one.\n                return this.result !== 0 &&\n                    (this.decodeMode !== DecodingMode.Attribute ||\n                        this.result === this.treeIndex)\n                    ? this.emitNotTerminatedNamedEntity()\n                    : 0;\n            }\n            // Otherwise, emit a numeric entity if we have one.\n            case EntityDecoderState.NumericDecimal: {\n                return this.emitNumericEntity(0, 2);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.emitNumericEntity(0, 3);\n            }\n            case EntityDecoderState.NumericStart: {\n                (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n                return 0;\n            }\n            case EntityDecoderState.EntityStart: {\n                // Return 0 if we have no entity.\n                return 0;\n            }\n        }\n    }\n}\n/**\n * Creates a function that decodes entities in a string.\n *\n * @param decodeTree The decode tree.\n * @returns A function that decodes entities in a string.\n */\nfunction getDecoder(decodeTree) {\n    let ret = \"\";\n    const decoder = new EntityDecoder(decodeTree, (str) => (ret += fromCodePoint(str)));\n    return function decodeWithTrie(str, decodeMode) {\n        let lastIndex = 0;\n        let offset = 0;\n        while ((offset = str.indexOf(\"&\", offset)) >= 0) {\n            ret += str.slice(lastIndex, offset);\n            decoder.startEntity(decodeMode);\n            const len = decoder.write(str, \n            // Skip the \"&\"\n            offset + 1);\n            if (len < 0) {\n                lastIndex = offset + decoder.end();\n                break;\n            }\n            lastIndex = offset + len;\n            // If `len` is 0, skip the current `&` and continue.\n            offset = len === 0 ? lastIndex + 1 : lastIndex;\n        }\n        const result = ret + str.slice(lastIndex);\n        // Make sure we don't keep a reference to the final string.\n        ret = \"\";\n        return result;\n    };\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n *\n * @param decodeTree The trie.\n * @param current The current node.\n * @param nodeIdx The index right after the current node and its value.\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nexport function determineBranch(decodeTree, current, nodeIdx, char) {\n    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    // Case 1: Single branch encoded in jump offset\n    if (branchCount === 0) {\n        return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;\n    }\n    // Case 2: Multiple branches encoded in jump table\n    if (jumpOffset) {\n        const value = char - jumpOffset;\n        return value < 0 || value >= branchCount\n            ? -1\n            : decodeTree[nodeIdx + value] - 1;\n    }\n    // Case 3: Multiple branches encoded in dictionary\n    // Binary search for the character.\n    let lo = nodeIdx;\n    let hi = lo + branchCount - 1;\n    while (lo <= hi) {\n        const mid = (lo + hi) >>> 1;\n        const midVal = decodeTree[mid];\n        if (midVal < char) {\n            lo = mid + 1;\n        }\n        else if (midVal > char) {\n            hi = mid - 1;\n        }\n        else {\n            return decodeTree[mid + branchCount];\n        }\n    }\n    return -1;\n}\nconst htmlDecoder = getDecoder(htmlDecodeTree);\nconst xmlDecoder = getDecoder(xmlDecodeTree);\n/**\n * Decodes an HTML string.\n *\n * @param str The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nexport function decodeHTML(str, mode = DecodingMode.Legacy) {\n    return htmlDecoder(str, mode);\n}\n/**\n * Decodes an HTML string in an attribute.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLAttribute(str) {\n    return htmlDecoder(str, DecodingMode.Attribute);\n}\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLStrict(str) {\n    return htmlDecoder(str, DecodingMode.Strict);\n}\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeXML(str) {\n    return xmlDecoder(str, DecodingMode.Strict);\n}\n//# sourceMappingURL=decode.js.map","/** All valid namespaces in HTML. */\nexport var NS;\n(function (NS) {\n    NS[\"HTML\"] = \"http://www.w3.org/1999/xhtml\";\n    NS[\"MATHML\"] = \"http://www.w3.org/1998/Math/MathML\";\n    NS[\"SVG\"] = \"http://www.w3.org/2000/svg\";\n    NS[\"XLINK\"] = \"http://www.w3.org/1999/xlink\";\n    NS[\"XML\"] = \"http://www.w3.org/XML/1998/namespace\";\n    NS[\"XMLNS\"] = \"http://www.w3.org/2000/xmlns/\";\n})(NS = NS || (NS = {}));\nexport var ATTRS;\n(function (ATTRS) {\n    ATTRS[\"TYPE\"] = \"type\";\n    ATTRS[\"ACTION\"] = \"action\";\n    ATTRS[\"ENCODING\"] = \"encoding\";\n    ATTRS[\"PROMPT\"] = \"prompt\";\n    ATTRS[\"NAME\"] = \"name\";\n    ATTRS[\"COLOR\"] = \"color\";\n    ATTRS[\"FACE\"] = \"face\";\n    ATTRS[\"SIZE\"] = \"size\";\n})(ATTRS = ATTRS || (ATTRS = {}));\n/**\n * The mode of the document.\n *\n * @see {@link https://dom.spec.whatwg.org/#concept-document-limited-quirks}\n */\nexport var DOCUMENT_MODE;\n(function (DOCUMENT_MODE) {\n    DOCUMENT_MODE[\"NO_QUIRKS\"] = \"no-quirks\";\n    DOCUMENT_MODE[\"QUIRKS\"] = \"quirks\";\n    DOCUMENT_MODE[\"LIMITED_QUIRKS\"] = \"limited-quirks\";\n})(DOCUMENT_MODE = DOCUMENT_MODE || (DOCUMENT_MODE = {}));\nexport var TAG_NAMES;\n(function (TAG_NAMES) {\n    TAG_NAMES[\"A\"] = \"a\";\n    TAG_NAMES[\"ADDRESS\"] = \"address\";\n    TAG_NAMES[\"ANNOTATION_XML\"] = \"annotation-xml\";\n    TAG_NAMES[\"APPLET\"] = \"applet\";\n    TAG_NAMES[\"AREA\"] = \"area\";\n    TAG_NAMES[\"ARTICLE\"] = \"article\";\n    TAG_NAMES[\"ASIDE\"] = \"aside\";\n    TAG_NAMES[\"B\"] = \"b\";\n    TAG_NAMES[\"BASE\"] = \"base\";\n    TAG_NAMES[\"BASEFONT\"] = \"basefont\";\n    TAG_NAMES[\"BGSOUND\"] = \"bgsound\";\n    TAG_NAMES[\"BIG\"] = \"big\";\n    TAG_NAMES[\"BLOCKQUOTE\"] = \"blockquote\";\n    TAG_NAMES[\"BODY\"] = \"body\";\n    TAG_NAMES[\"BR\"] = \"br\";\n    TAG_NAMES[\"BUTTON\"] = \"button\";\n    TAG_NAMES[\"CAPTION\"] = \"caption\";\n    TAG_NAMES[\"CENTER\"] = \"center\";\n    TAG_NAMES[\"CODE\"] = \"code\";\n    TAG_NAMES[\"COL\"] = \"col\";\n    TAG_NAMES[\"COLGROUP\"] = \"colgroup\";\n    TAG_NAMES[\"DD\"] = \"dd\";\n    TAG_NAMES[\"DESC\"] = \"desc\";\n    TAG_NAMES[\"DETAILS\"] = \"details\";\n    TAG_NAMES[\"DIALOG\"] = \"dialog\";\n    TAG_NAMES[\"DIR\"] = \"dir\";\n    TAG_NAMES[\"DIV\"] = \"div\";\n    TAG_NAMES[\"DL\"] = \"dl\";\n    TAG_NAMES[\"DT\"] = \"dt\";\n    TAG_NAMES[\"EM\"] = \"em\";\n    TAG_NAMES[\"EMBED\"] = \"embed\";\n    TAG_NAMES[\"FIELDSET\"] = \"fieldset\";\n    TAG_NAMES[\"FIGCAPTION\"] = \"figcaption\";\n    TAG_NAMES[\"FIGURE\"] = \"figure\";\n    TAG_NAMES[\"FONT\"] = \"font\";\n    TAG_NAMES[\"FOOTER\"] = \"footer\";\n    TAG_NAMES[\"FOREIGN_OBJECT\"] = \"foreignObject\";\n    TAG_NAMES[\"FORM\"] = \"form\";\n    TAG_NAMES[\"FRAME\"] = \"frame\";\n    TAG_NAMES[\"FRAMESET\"] = \"frameset\";\n    TAG_NAMES[\"H1\"] = \"h1\";\n    TAG_NAMES[\"H2\"] = \"h2\";\n    TAG_NAMES[\"H3\"] = \"h3\";\n    TAG_NAMES[\"H4\"] = \"h4\";\n    TAG_NAMES[\"H5\"] = \"h5\";\n    TAG_NAMES[\"H6\"] = \"h6\";\n    TAG_NAMES[\"HEAD\"] = \"head\";\n    TAG_NAMES[\"HEADER\"] = \"header\";\n    TAG_NAMES[\"HGROUP\"] = \"hgroup\";\n    TAG_NAMES[\"HR\"] = \"hr\";\n    TAG_NAMES[\"HTML\"] = \"html\";\n    TAG_NAMES[\"I\"] = \"i\";\n    TAG_NAMES[\"IMG\"] = \"img\";\n    TAG_NAMES[\"IMAGE\"] = \"image\";\n    TAG_NAMES[\"INPUT\"] = \"input\";\n    TAG_NAMES[\"IFRAME\"] = \"iframe\";\n    TAG_NAMES[\"KEYGEN\"] = \"keygen\";\n    TAG_NAMES[\"LABEL\"] = \"label\";\n    TAG_NAMES[\"LI\"] = \"li\";\n    TAG_NAMES[\"LINK\"] = \"link\";\n    TAG_NAMES[\"LISTING\"] = \"listing\";\n    TAG_NAMES[\"MAIN\"] = \"main\";\n    TAG_NAMES[\"MALIGNMARK\"] = \"malignmark\";\n    TAG_NAMES[\"MARQUEE\"] = \"marquee\";\n    TAG_NAMES[\"MATH\"] = \"math\";\n    TAG_NAMES[\"MENU\"] = \"menu\";\n    TAG_NAMES[\"META\"] = \"meta\";\n    TAG_NAMES[\"MGLYPH\"] = \"mglyph\";\n    TAG_NAMES[\"MI\"] = \"mi\";\n    TAG_NAMES[\"MO\"] = \"mo\";\n    TAG_NAMES[\"MN\"] = \"mn\";\n    TAG_NAMES[\"MS\"] = \"ms\";\n    TAG_NAMES[\"MTEXT\"] = \"mtext\";\n    TAG_NAMES[\"NAV\"] = \"nav\";\n    TAG_NAMES[\"NOBR\"] = \"nobr\";\n    TAG_NAMES[\"NOFRAMES\"] = \"noframes\";\n    TAG_NAMES[\"NOEMBED\"] = \"noembed\";\n    TAG_NAMES[\"NOSCRIPT\"] = \"noscript\";\n    TAG_NAMES[\"OBJECT\"] = \"object\";\n    TAG_NAMES[\"OL\"] = \"ol\";\n    TAG_NAMES[\"OPTGROUP\"] = \"optgroup\";\n    TAG_NAMES[\"OPTION\"] = \"option\";\n    TAG_NAMES[\"P\"] = \"p\";\n    TAG_NAMES[\"PARAM\"] = \"param\";\n    TAG_NAMES[\"PLAINTEXT\"] = \"plaintext\";\n    TAG_NAMES[\"PRE\"] = \"pre\";\n    TAG_NAMES[\"RB\"] = \"rb\";\n    TAG_NAMES[\"RP\"] = \"rp\";\n    TAG_NAMES[\"RT\"] = \"rt\";\n    TAG_NAMES[\"RTC\"] = \"rtc\";\n    TAG_NAMES[\"RUBY\"] = \"ruby\";\n    TAG_NAMES[\"S\"] = \"s\";\n    TAG_NAMES[\"SCRIPT\"] = \"script\";\n    TAG_NAMES[\"SECTION\"] = \"section\";\n    TAG_NAMES[\"SELECT\"] = \"select\";\n    TAG_NAMES[\"SOURCE\"] = \"source\";\n    TAG_NAMES[\"SMALL\"] = \"small\";\n    TAG_NAMES[\"SPAN\"] = \"span\";\n    TAG_NAMES[\"STRIKE\"] = \"strike\";\n    TAG_NAMES[\"STRONG\"] = \"strong\";\n    TAG_NAMES[\"STYLE\"] = \"style\";\n    TAG_NAMES[\"SUB\"] = \"sub\";\n    TAG_NAMES[\"SUMMARY\"] = \"summary\";\n    TAG_NAMES[\"SUP\"] = \"sup\";\n    TAG_NAMES[\"TABLE\"] = \"table\";\n    TAG_NAMES[\"TBODY\"] = \"tbody\";\n    TAG_NAMES[\"TEMPLATE\"] = \"template\";\n    TAG_NAMES[\"TEXTAREA\"] = \"textarea\";\n    TAG_NAMES[\"TFOOT\"] = \"tfoot\";\n    TAG_NAMES[\"TD\"] = \"td\";\n    TAG_NAMES[\"TH\"] = \"th\";\n    TAG_NAMES[\"THEAD\"] = \"thead\";\n    TAG_NAMES[\"TITLE\"] = \"title\";\n    TAG_NAMES[\"TR\"] = \"tr\";\n    TAG_NAMES[\"TRACK\"] = \"track\";\n    TAG_NAMES[\"TT\"] = \"tt\";\n    TAG_NAMES[\"U\"] = \"u\";\n    TAG_NAMES[\"UL\"] = \"ul\";\n    TAG_NAMES[\"SVG\"] = \"svg\";\n    TAG_NAMES[\"VAR\"] = \"var\";\n    TAG_NAMES[\"WBR\"] = \"wbr\";\n    TAG_NAMES[\"XMP\"] = \"xmp\";\n})(TAG_NAMES = TAG_NAMES || (TAG_NAMES = {}));\n/**\n * Tag IDs are numeric IDs for known tag names.\n *\n * We use tag IDs to improve the performance of tag name comparisons.\n */\nexport var TAG_ID;\n(function (TAG_ID) {\n    TAG_ID[TAG_ID[\"UNKNOWN\"] = 0] = \"UNKNOWN\";\n    TAG_ID[TAG_ID[\"A\"] = 1] = \"A\";\n    TAG_ID[TAG_ID[\"ADDRESS\"] = 2] = \"ADDRESS\";\n    TAG_ID[TAG_ID[\"ANNOTATION_XML\"] = 3] = \"ANNOTATION_XML\";\n    TAG_ID[TAG_ID[\"APPLET\"] = 4] = \"APPLET\";\n    TAG_ID[TAG_ID[\"AREA\"] = 5] = \"AREA\";\n    TAG_ID[TAG_ID[\"ARTICLE\"] = 6] = \"ARTICLE\";\n    TAG_ID[TAG_ID[\"ASIDE\"] = 7] = \"ASIDE\";\n    TAG_ID[TAG_ID[\"B\"] = 8] = \"B\";\n    TAG_ID[TAG_ID[\"BASE\"] = 9] = \"BASE\";\n    TAG_ID[TAG_ID[\"BASEFONT\"] = 10] = \"BASEFONT\";\n    TAG_ID[TAG_ID[\"BGSOUND\"] = 11] = \"BGSOUND\";\n    TAG_ID[TAG_ID[\"BIG\"] = 12] = \"BIG\";\n    TAG_ID[TAG_ID[\"BLOCKQUOTE\"] = 13] = \"BLOCKQUOTE\";\n    TAG_ID[TAG_ID[\"BODY\"] = 14] = \"BODY\";\n    TAG_ID[TAG_ID[\"BR\"] = 15] = \"BR\";\n    TAG_ID[TAG_ID[\"BUTTON\"] = 16] = \"BUTTON\";\n    TAG_ID[TAG_ID[\"CAPTION\"] = 17] = \"CAPTION\";\n    TAG_ID[TAG_ID[\"CENTER\"] = 18] = \"CENTER\";\n    TAG_ID[TAG_ID[\"CODE\"] = 19] = \"CODE\";\n    TAG_ID[TAG_ID[\"COL\"] = 20] = \"COL\";\n    TAG_ID[TAG_ID[\"COLGROUP\"] = 21] = \"COLGROUP\";\n    TAG_ID[TAG_ID[\"DD\"] = 22] = \"DD\";\n    TAG_ID[TAG_ID[\"DESC\"] = 23] = \"DESC\";\n    TAG_ID[TAG_ID[\"DETAILS\"] = 24] = \"DETAILS\";\n    TAG_ID[TAG_ID[\"DIALOG\"] = 25] = \"DIALOG\";\n    TAG_ID[TAG_ID[\"DIR\"] = 26] = \"DIR\";\n    TAG_ID[TAG_ID[\"DIV\"] = 27] = \"DIV\";\n    TAG_ID[TAG_ID[\"DL\"] = 28] = \"DL\";\n    TAG_ID[TAG_ID[\"DT\"] = 29] = \"DT\";\n    TAG_ID[TAG_ID[\"EM\"] = 30] = \"EM\";\n    TAG_ID[TAG_ID[\"EMBED\"] = 31] = \"EMBED\";\n    TAG_ID[TAG_ID[\"FIELDSET\"] = 32] = \"FIELDSET\";\n    TAG_ID[TAG_ID[\"FIGCAPTION\"] = 33] = \"FIGCAPTION\";\n    TAG_ID[TAG_ID[\"FIGURE\"] = 34] = \"FIGURE\";\n    TAG_ID[TAG_ID[\"FONT\"] = 35] = \"FONT\";\n    TAG_ID[TAG_ID[\"FOOTER\"] = 36] = \"FOOTER\";\n    TAG_ID[TAG_ID[\"FOREIGN_OBJECT\"] = 37] = \"FOREIGN_OBJECT\";\n    TAG_ID[TAG_ID[\"FORM\"] = 38] = \"FORM\";\n    TAG_ID[TAG_ID[\"FRAME\"] = 39] = \"FRAME\";\n    TAG_ID[TAG_ID[\"FRAMESET\"] = 40] = \"FRAMESET\";\n    TAG_ID[TAG_ID[\"H1\"] = 41] = \"H1\";\n    TAG_ID[TAG_ID[\"H2\"] = 42] = \"H2\";\n    TAG_ID[TAG_ID[\"H3\"] = 43] = \"H3\";\n    TAG_ID[TAG_ID[\"H4\"] = 44] = \"H4\";\n    TAG_ID[TAG_ID[\"H5\"] = 45] = \"H5\";\n    TAG_ID[TAG_ID[\"H6\"] = 46] = \"H6\";\n    TAG_ID[TAG_ID[\"HEAD\"] = 47] = \"HEAD\";\n    TAG_ID[TAG_ID[\"HEADER\"] = 48] = \"HEADER\";\n    TAG_ID[TAG_ID[\"HGROUP\"] = 49] = \"HGROUP\";\n    TAG_ID[TAG_ID[\"HR\"] = 50] = \"HR\";\n    TAG_ID[TAG_ID[\"HTML\"] = 51] = \"HTML\";\n    TAG_ID[TAG_ID[\"I\"] = 52] = \"I\";\n    TAG_ID[TAG_ID[\"IMG\"] = 53] = \"IMG\";\n    TAG_ID[TAG_ID[\"IMAGE\"] = 54] = \"IMAGE\";\n    TAG_ID[TAG_ID[\"INPUT\"] = 55] = \"INPUT\";\n    TAG_ID[TAG_ID[\"IFRAME\"] = 56] = \"IFRAME\";\n    TAG_ID[TAG_ID[\"KEYGEN\"] = 57] = \"KEYGEN\";\n    TAG_ID[TAG_ID[\"LABEL\"] = 58] = \"LABEL\";\n    TAG_ID[TAG_ID[\"LI\"] = 59] = \"LI\";\n    TAG_ID[TAG_ID[\"LINK\"] = 60] = \"LINK\";\n    TAG_ID[TAG_ID[\"LISTING\"] = 61] = \"LISTING\";\n    TAG_ID[TAG_ID[\"MAIN\"] = 62] = \"MAIN\";\n    TAG_ID[TAG_ID[\"MALIGNMARK\"] = 63] = \"MALIGNMARK\";\n    TAG_ID[TAG_ID[\"MARQUEE\"] = 64] = \"MARQUEE\";\n    TAG_ID[TAG_ID[\"MATH\"] = 65] = \"MATH\";\n    TAG_ID[TAG_ID[\"MENU\"] = 66] = \"MENU\";\n    TAG_ID[TAG_ID[\"META\"] = 67] = \"META\";\n    TAG_ID[TAG_ID[\"MGLYPH\"] = 68] = \"MGLYPH\";\n    TAG_ID[TAG_ID[\"MI\"] = 69] = \"MI\";\n    TAG_ID[TAG_ID[\"MO\"] = 70] = \"MO\";\n    TAG_ID[TAG_ID[\"MN\"] = 71] = \"MN\";\n    TAG_ID[TAG_ID[\"MS\"] = 72] = \"MS\";\n    TAG_ID[TAG_ID[\"MTEXT\"] = 73] = \"MTEXT\";\n    TAG_ID[TAG_ID[\"NAV\"] = 74] = \"NAV\";\n    TAG_ID[TAG_ID[\"NOBR\"] = 75] = \"NOBR\";\n    TAG_ID[TAG_ID[\"NOFRAMES\"] = 76] = \"NOFRAMES\";\n    TAG_ID[TAG_ID[\"NOEMBED\"] = 77] = \"NOEMBED\";\n    TAG_ID[TAG_ID[\"NOSCRIPT\"] = 78] = \"NOSCRIPT\";\n    TAG_ID[TAG_ID[\"OBJECT\"] = 79] = \"OBJECT\";\n    TAG_ID[TAG_ID[\"OL\"] = 80] = \"OL\";\n    TAG_ID[TAG_ID[\"OPTGROUP\"] = 81] = \"OPTGROUP\";\n    TAG_ID[TAG_ID[\"OPTION\"] = 82] = \"OPTION\";\n    TAG_ID[TAG_ID[\"P\"] = 83] = \"P\";\n    TAG_ID[TAG_ID[\"PARAM\"] = 84] = \"PARAM\";\n    TAG_ID[TAG_ID[\"PLAINTEXT\"] = 85] = \"PLAINTEXT\";\n    TAG_ID[TAG_ID[\"PRE\"] = 86] = \"PRE\";\n    TAG_ID[TAG_ID[\"RB\"] = 87] = \"RB\";\n    TAG_ID[TAG_ID[\"RP\"] = 88] = \"RP\";\n    TAG_ID[TAG_ID[\"RT\"] = 89] = \"RT\";\n    TAG_ID[TAG_ID[\"RTC\"] = 90] = \"RTC\";\n    TAG_ID[TAG_ID[\"RUBY\"] = 91] = \"RUBY\";\n    TAG_ID[TAG_ID[\"S\"] = 92] = \"S\";\n    TAG_ID[TAG_ID[\"SCRIPT\"] = 93] = \"SCRIPT\";\n    TAG_ID[TAG_ID[\"SECTION\"] = 94] = \"SECTION\";\n    TAG_ID[TAG_ID[\"SELECT\"] = 95] = \"SELECT\";\n    TAG_ID[TAG_ID[\"SOURCE\"] = 96] = \"SOURCE\";\n    TAG_ID[TAG_ID[\"SMALL\"] = 97] = \"SMALL\";\n    TAG_ID[TAG_ID[\"SPAN\"] = 98] = \"SPAN\";\n    TAG_ID[TAG_ID[\"STRIKE\"] = 99] = \"STRIKE\";\n    TAG_ID[TAG_ID[\"STRONG\"] = 100] = \"STRONG\";\n    TAG_ID[TAG_ID[\"STYLE\"] = 101] = \"STYLE\";\n    TAG_ID[TAG_ID[\"SUB\"] = 102] = \"SUB\";\n    TAG_ID[TAG_ID[\"SUMMARY\"] = 103] = \"SUMMARY\";\n    TAG_ID[TAG_ID[\"SUP\"] = 104] = \"SUP\";\n    TAG_ID[TAG_ID[\"TABLE\"] = 105] = \"TABLE\";\n    TAG_ID[TAG_ID[\"TBODY\"] = 106] = \"TBODY\";\n    TAG_ID[TAG_ID[\"TEMPLATE\"] = 107] = \"TEMPLATE\";\n    TAG_ID[TAG_ID[\"TEXTAREA\"] = 108] = \"TEXTAREA\";\n    TAG_ID[TAG_ID[\"TFOOT\"] = 109] = \"TFOOT\";\n    TAG_ID[TAG_ID[\"TD\"] = 110] = \"TD\";\n    TAG_ID[TAG_ID[\"TH\"] = 111] = \"TH\";\n    TAG_ID[TAG_ID[\"THEAD\"] = 112] = \"THEAD\";\n    TAG_ID[TAG_ID[\"TITLE\"] = 113] = \"TITLE\";\n    TAG_ID[TAG_ID[\"TR\"] = 114] = \"TR\";\n    TAG_ID[TAG_ID[\"TRACK\"] = 115] = \"TRACK\";\n    TAG_ID[TAG_ID[\"TT\"] = 116] = \"TT\";\n    TAG_ID[TAG_ID[\"U\"] = 117] = \"U\";\n    TAG_ID[TAG_ID[\"UL\"] = 118] = \"UL\";\n    TAG_ID[TAG_ID[\"SVG\"] = 119] = \"SVG\";\n    TAG_ID[TAG_ID[\"VAR\"] = 120] = \"VAR\";\n    TAG_ID[TAG_ID[\"WBR\"] = 121] = \"WBR\";\n    TAG_ID[TAG_ID[\"XMP\"] = 122] = \"XMP\";\n})(TAG_ID = TAG_ID || (TAG_ID = {}));\nconst TAG_NAME_TO_ID = new Map([\n    [TAG_NAMES.A, TAG_ID.A],\n    [TAG_NAMES.ADDRESS, TAG_ID.ADDRESS],\n    [TAG_NAMES.ANNOTATION_XML, TAG_ID.ANNOTATION_XML],\n    [TAG_NAMES.APPLET, TAG_ID.APPLET],\n    [TAG_NAMES.AREA, TAG_ID.AREA],\n    [TAG_NAMES.ARTICLE, TAG_ID.ARTICLE],\n    [TAG_NAMES.ASIDE, TAG_ID.ASIDE],\n    [TAG_NAMES.B, TAG_ID.B],\n    [TAG_NAMES.BASE, TAG_ID.BASE],\n    [TAG_NAMES.BASEFONT, TAG_ID.BASEFONT],\n    [TAG_NAMES.BGSOUND, TAG_ID.BGSOUND],\n    [TAG_NAMES.BIG, TAG_ID.BIG],\n    [TAG_NAMES.BLOCKQUOTE, TAG_ID.BLOCKQUOTE],\n    [TAG_NAMES.BODY, TAG_ID.BODY],\n    [TAG_NAMES.BR, TAG_ID.BR],\n    [TAG_NAMES.BUTTON, TAG_ID.BUTTON],\n    [TAG_NAMES.CAPTION, TAG_ID.CAPTION],\n    [TAG_NAMES.CENTER, TAG_ID.CENTER],\n    [TAG_NAMES.CODE, TAG_ID.CODE],\n    [TAG_NAMES.COL, TAG_ID.COL],\n    [TAG_NAMES.COLGROUP, TAG_ID.COLGROUP],\n    [TAG_NAMES.DD, TAG_ID.DD],\n    [TAG_NAMES.DESC, TAG_ID.DESC],\n    [TAG_NAMES.DETAILS, TAG_ID.DETAILS],\n    [TAG_NAMES.DIALOG, TAG_ID.DIALOG],\n    [TAG_NAMES.DIR, TAG_ID.DIR],\n    [TAG_NAMES.DIV, TAG_ID.DIV],\n    [TAG_NAMES.DL, TAG_ID.DL],\n    [TAG_NAMES.DT, TAG_ID.DT],\n    [TAG_NAMES.EM, TAG_ID.EM],\n    [TAG_NAMES.EMBED, TAG_ID.EMBED],\n    [TAG_NAMES.FIELDSET, TAG_ID.FIELDSET],\n    [TAG_NAMES.FIGCAPTION, TAG_ID.FIGCAPTION],\n    [TAG_NAMES.FIGURE, TAG_ID.FIGURE],\n    [TAG_NAMES.FONT, TAG_ID.FONT],\n    [TAG_NAMES.FOOTER, TAG_ID.FOOTER],\n    [TAG_NAMES.FOREIGN_OBJECT, TAG_ID.FOREIGN_OBJECT],\n    [TAG_NAMES.FORM, TAG_ID.FORM],\n    [TAG_NAMES.FRAME, TAG_ID.FRAME],\n    [TAG_NAMES.FRAMESET, TAG_ID.FRAMESET],\n    [TAG_NAMES.H1, TAG_ID.H1],\n    [TAG_NAMES.H2, TAG_ID.H2],\n    [TAG_NAMES.H3, TAG_ID.H3],\n    [TAG_NAMES.H4, TAG_ID.H4],\n    [TAG_NAMES.H5, TAG_ID.H5],\n    [TAG_NAMES.H6, TAG_ID.H6],\n    [TAG_NAMES.HEAD, TAG_ID.HEAD],\n    [TAG_NAMES.HEADER, TAG_ID.HEADER],\n    [TAG_NAMES.HGROUP, TAG_ID.HGROUP],\n    [TAG_NAMES.HR, TAG_ID.HR],\n    [TAG_NAMES.HTML, TAG_ID.HTML],\n    [TAG_NAMES.I, TAG_ID.I],\n    [TAG_NAMES.IMG, TAG_ID.IMG],\n    [TAG_NAMES.IMAGE, TAG_ID.IMAGE],\n    [TAG_NAMES.INPUT, TAG_ID.INPUT],\n    [TAG_NAMES.IFRAME, TAG_ID.IFRAME],\n    [TAG_NAMES.KEYGEN, TAG_ID.KEYGEN],\n    [TAG_NAMES.LABEL, TAG_ID.LABEL],\n    [TAG_NAMES.LI, TAG_ID.LI],\n    [TAG_NAMES.LINK, TAG_ID.LINK],\n    [TAG_NAMES.LISTING, TAG_ID.LISTING],\n    [TAG_NAMES.MAIN, TAG_ID.MAIN],\n    [TAG_NAMES.MALIGNMARK, TAG_ID.MALIGNMARK],\n    [TAG_NAMES.MARQUEE, TAG_ID.MARQUEE],\n    [TAG_NAMES.MATH, TAG_ID.MATH],\n    [TAG_NAMES.MENU, TAG_ID.MENU],\n    [TAG_NAMES.META, TAG_ID.META],\n    [TAG_NAMES.MGLYPH, TAG_ID.MGLYPH],\n    [TAG_NAMES.MI, TAG_ID.MI],\n    [TAG_NAMES.MO, TAG_ID.MO],\n    [TAG_NAMES.MN, TAG_ID.MN],\n    [TAG_NAMES.MS, TAG_ID.MS],\n    [TAG_NAMES.MTEXT, TAG_ID.MTEXT],\n    [TAG_NAMES.NAV, TAG_ID.NAV],\n    [TAG_NAMES.NOBR, TAG_ID.NOBR],\n    [TAG_NAMES.NOFRAMES, TAG_ID.NOFRAMES],\n    [TAG_NAMES.NOEMBED, TAG_ID.NOEMBED],\n    [TAG_NAMES.NOSCRIPT, TAG_ID.NOSCRIPT],\n    [TAG_NAMES.OBJECT, TAG_ID.OBJECT],\n    [TAG_NAMES.OL, TAG_ID.OL],\n    [TAG_NAMES.OPTGROUP, TAG_ID.OPTGROUP],\n    [TAG_NAMES.OPTION, TAG_ID.OPTION],\n    [TAG_NAMES.P, TAG_ID.P],\n    [TAG_NAMES.PARAM, TAG_ID.PARAM],\n    [TAG_NAMES.PLAINTEXT, TAG_ID.PLAINTEXT],\n    [TAG_NAMES.PRE, TAG_ID.PRE],\n    [TAG_NAMES.RB, TAG_ID.RB],\n    [TAG_NAMES.RP, TAG_ID.RP],\n    [TAG_NAMES.RT, TAG_ID.RT],\n    [TAG_NAMES.RTC, TAG_ID.RTC],\n    [TAG_NAMES.RUBY, TAG_ID.RUBY],\n    [TAG_NAMES.S, TAG_ID.S],\n    [TAG_NAMES.SCRIPT, TAG_ID.SCRIPT],\n    [TAG_NAMES.SECTION, TAG_ID.SECTION],\n    [TAG_NAMES.SELECT, TAG_ID.SELECT],\n    [TAG_NAMES.SOURCE, TAG_ID.SOURCE],\n    [TAG_NAMES.SMALL, TAG_ID.SMALL],\n    [TAG_NAMES.SPAN, TAG_ID.SPAN],\n    [TAG_NAMES.STRIKE, TAG_ID.STRIKE],\n    [TAG_NAMES.STRONG, TAG_ID.STRONG],\n    [TAG_NAMES.STYLE, TAG_ID.STYLE],\n    [TAG_NAMES.SUB, TAG_ID.SUB],\n    [TAG_NAMES.SUMMARY, TAG_ID.SUMMARY],\n    [TAG_NAMES.SUP, TAG_ID.SUP],\n    [TAG_NAMES.TABLE, TAG_ID.TABLE],\n    [TAG_NAMES.TBODY, TAG_ID.TBODY],\n    [TAG_NAMES.TEMPLATE, TAG_ID.TEMPLATE],\n    [TAG_NAMES.TEXTAREA, TAG_ID.TEXTAREA],\n    [TAG_NAMES.TFOOT, TAG_ID.TFOOT],\n    [TAG_NAMES.TD, TAG_ID.TD],\n    [TAG_NAMES.TH, TAG_ID.TH],\n    [TAG_NAMES.THEAD, TAG_ID.THEAD],\n    [TAG_NAMES.TITLE, TAG_ID.TITLE],\n    [TAG_NAMES.TR, TAG_ID.TR],\n    [TAG_NAMES.TRACK, TAG_ID.TRACK],\n    [TAG_NAMES.TT, TAG_ID.TT],\n    [TAG_NAMES.U, TAG_ID.U],\n    [TAG_NAMES.UL, TAG_ID.UL],\n    [TAG_NAMES.SVG, TAG_ID.SVG],\n    [TAG_NAMES.VAR, TAG_ID.VAR],\n    [TAG_NAMES.WBR, TAG_ID.WBR],\n    [TAG_NAMES.XMP, TAG_ID.XMP],\n]);\nexport function getTagID(tagName) {\n    var _a;\n    return (_a = TAG_NAME_TO_ID.get(tagName)) !== null && _a !== void 0 ? _a : TAG_ID.UNKNOWN;\n}\nconst $ = TAG_ID;\nexport const SPECIAL_ELEMENTS = {\n    [NS.HTML]: new Set([\n        $.ADDRESS,\n        $.APPLET,\n        $.AREA,\n        $.ARTICLE,\n        $.ASIDE,\n        $.BASE,\n        $.BASEFONT,\n        $.BGSOUND,\n        $.BLOCKQUOTE,\n        $.BODY,\n        $.BR,\n        $.BUTTON,\n        $.CAPTION,\n        $.CENTER,\n        $.COL,\n        $.COLGROUP,\n        $.DD,\n        $.DETAILS,\n        $.DIR,\n        $.DIV,\n        $.DL,\n        $.DT,\n        $.EMBED,\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        $.HGROUP,\n        $.HR,\n        $.HTML,\n        $.IFRAME,\n        $.IMG,\n        $.INPUT,\n        $.LI,\n        $.LINK,\n        $.LISTING,\n        $.MAIN,\n        $.MARQUEE,\n        $.MENU,\n        $.META,\n        $.NAV,\n        $.NOEMBED,\n        $.NOFRAMES,\n        $.NOSCRIPT,\n        $.OBJECT,\n        $.OL,\n        $.P,\n        $.PARAM,\n        $.PLAINTEXT,\n        $.PRE,\n        $.SCRIPT,\n        $.SECTION,\n        $.SELECT,\n        $.SOURCE,\n        $.STYLE,\n        $.SUMMARY,\n        $.TABLE,\n        $.TBODY,\n        $.TD,\n        $.TEMPLATE,\n        $.TEXTAREA,\n        $.TFOOT,\n        $.TH,\n        $.THEAD,\n        $.TITLE,\n        $.TR,\n        $.TRACK,\n        $.UL,\n        $.WBR,\n        $.XMP,\n    ]),\n    [NS.MATHML]: new Set([$.MI, $.MO, $.MN, $.MS, $.MTEXT, $.ANNOTATION_XML]),\n    [NS.SVG]: new Set([$.TITLE, $.FOREIGN_OBJECT, $.DESC]),\n    [NS.XLINK]: new Set(),\n    [NS.XML]: new Set(),\n    [NS.XMLNS]: new Set(),\n};\nexport function isNumberedHeader(tn) {\n    return tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6;\n}\nconst UNESCAPED_TEXT = new Set([\n    TAG_NAMES.STYLE,\n    TAG_NAMES.SCRIPT,\n    TAG_NAMES.XMP,\n    TAG_NAMES.IFRAME,\n    TAG_NAMES.NOEMBED,\n    TAG_NAMES.NOFRAMES,\n    TAG_NAMES.PLAINTEXT,\n]);\nexport function hasUnescapedText(tn, scriptingEnabled) {\n    return UNESCAPED_TEXT.has(tn) || (scriptingEnabled && tn === TAG_NAMES.NOSCRIPT);\n}\n//# sourceMappingURL=html.js.map","import { Preprocessor } from './preprocessor.js';\nimport { CODE_POINTS as $, SEQUENCES as $$, REPLACEMENT_CHARACTER, isSurrogate, isUndefinedCodePoint, isControlCodePoint, } from '../common/unicode.js';\nimport { TokenType, getTokenAttr, } from '../common/token.js';\nimport { htmlDecodeTree, BinTrieFlags, determineBranch } from 'entities/lib/decode.js';\nimport { ERR } from '../common/error-codes.js';\nimport { TAG_ID, getTagID } from '../common/html.js';\n//C1 Unicode control character reference replacements\nconst C1_CONTROLS_REFERENCE_REPLACEMENTS = new Map([\n    [0x80, 8364],\n    [0x82, 8218],\n    [0x83, 402],\n    [0x84, 8222],\n    [0x85, 8230],\n    [0x86, 8224],\n    [0x87, 8225],\n    [0x88, 710],\n    [0x89, 8240],\n    [0x8a, 352],\n    [0x8b, 8249],\n    [0x8c, 338],\n    [0x8e, 381],\n    [0x91, 8216],\n    [0x92, 8217],\n    [0x93, 8220],\n    [0x94, 8221],\n    [0x95, 8226],\n    [0x96, 8211],\n    [0x97, 8212],\n    [0x98, 732],\n    [0x99, 8482],\n    [0x9a, 353],\n    [0x9b, 8250],\n    [0x9c, 339],\n    [0x9e, 382],\n    [0x9f, 376],\n]);\n//States\nvar State;\n(function (State) {\n    State[State[\"DATA\"] = 0] = \"DATA\";\n    State[State[\"RCDATA\"] = 1] = \"RCDATA\";\n    State[State[\"RAWTEXT\"] = 2] = \"RAWTEXT\";\n    State[State[\"SCRIPT_DATA\"] = 3] = \"SCRIPT_DATA\";\n    State[State[\"PLAINTEXT\"] = 4] = \"PLAINTEXT\";\n    State[State[\"TAG_OPEN\"] = 5] = \"TAG_OPEN\";\n    State[State[\"END_TAG_OPEN\"] = 6] = \"END_TAG_OPEN\";\n    State[State[\"TAG_NAME\"] = 7] = \"TAG_NAME\";\n    State[State[\"RCDATA_LESS_THAN_SIGN\"] = 8] = \"RCDATA_LESS_THAN_SIGN\";\n    State[State[\"RCDATA_END_TAG_OPEN\"] = 9] = \"RCDATA_END_TAG_OPEN\";\n    State[State[\"RCDATA_END_TAG_NAME\"] = 10] = \"RCDATA_END_TAG_NAME\";\n    State[State[\"RAWTEXT_LESS_THAN_SIGN\"] = 11] = \"RAWTEXT_LESS_THAN_SIGN\";\n    State[State[\"RAWTEXT_END_TAG_OPEN\"] = 12] = \"RAWTEXT_END_TAG_OPEN\";\n    State[State[\"RAWTEXT_END_TAG_NAME\"] = 13] = \"RAWTEXT_END_TAG_NAME\";\n    State[State[\"SCRIPT_DATA_LESS_THAN_SIGN\"] = 14] = \"SCRIPT_DATA_LESS_THAN_SIGN\";\n    State[State[\"SCRIPT_DATA_END_TAG_OPEN\"] = 15] = \"SCRIPT_DATA_END_TAG_OPEN\";\n    State[State[\"SCRIPT_DATA_END_TAG_NAME\"] = 16] = \"SCRIPT_DATA_END_TAG_NAME\";\n    State[State[\"SCRIPT_DATA_ESCAPE_START\"] = 17] = \"SCRIPT_DATA_ESCAPE_START\";\n    State[State[\"SCRIPT_DATA_ESCAPE_START_DASH\"] = 18] = \"SCRIPT_DATA_ESCAPE_START_DASH\";\n    State[State[\"SCRIPT_DATA_ESCAPED\"] = 19] = \"SCRIPT_DATA_ESCAPED\";\n    State[State[\"SCRIPT_DATA_ESCAPED_DASH\"] = 20] = \"SCRIPT_DATA_ESCAPED_DASH\";\n    State[State[\"SCRIPT_DATA_ESCAPED_DASH_DASH\"] = 21] = \"SCRIPT_DATA_ESCAPED_DASH_DASH\";\n    State[State[\"SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN\"] = 22] = \"SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN\";\n    State[State[\"SCRIPT_DATA_ESCAPED_END_TAG_OPEN\"] = 23] = \"SCRIPT_DATA_ESCAPED_END_TAG_OPEN\";\n    State[State[\"SCRIPT_DATA_ESCAPED_END_TAG_NAME\"] = 24] = \"SCRIPT_DATA_ESCAPED_END_TAG_NAME\";\n    State[State[\"SCRIPT_DATA_DOUBLE_ESCAPE_START\"] = 25] = \"SCRIPT_DATA_DOUBLE_ESCAPE_START\";\n    State[State[\"SCRIPT_DATA_DOUBLE_ESCAPED\"] = 26] = \"SCRIPT_DATA_DOUBLE_ESCAPED\";\n    State[State[\"SCRIPT_DATA_DOUBLE_ESCAPED_DASH\"] = 27] = \"SCRIPT_DATA_DOUBLE_ESCAPED_DASH\";\n    State[State[\"SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH\"] = 28] = \"SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH\";\n    State[State[\"SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN\"] = 29] = \"SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN\";\n    State[State[\"SCRIPT_DATA_DOUBLE_ESCAPE_END\"] = 30] = \"SCRIPT_DATA_DOUBLE_ESCAPE_END\";\n    State[State[\"BEFORE_ATTRIBUTE_NAME\"] = 31] = \"BEFORE_ATTRIBUTE_NAME\";\n    State[State[\"ATTRIBUTE_NAME\"] = 32] = \"ATTRIBUTE_NAME\";\n    State[State[\"AFTER_ATTRIBUTE_NAME\"] = 33] = \"AFTER_ATTRIBUTE_NAME\";\n    State[State[\"BEFORE_ATTRIBUTE_VALUE\"] = 34] = \"BEFORE_ATTRIBUTE_VALUE\";\n    State[State[\"ATTRIBUTE_VALUE_DOUBLE_QUOTED\"] = 35] = \"ATTRIBUTE_VALUE_DOUBLE_QUOTED\";\n    State[State[\"ATTRIBUTE_VALUE_SINGLE_QUOTED\"] = 36] = \"ATTRIBUTE_VALUE_SINGLE_QUOTED\";\n    State[State[\"ATTRIBUTE_VALUE_UNQUOTED\"] = 37] = \"ATTRIBUTE_VALUE_UNQUOTED\";\n    State[State[\"AFTER_ATTRIBUTE_VALUE_QUOTED\"] = 38] = \"AFTER_ATTRIBUTE_VALUE_QUOTED\";\n    State[State[\"SELF_CLOSING_START_TAG\"] = 39] = \"SELF_CLOSING_START_TAG\";\n    State[State[\"BOGUS_COMMENT\"] = 40] = \"BOGUS_COMMENT\";\n    State[State[\"MARKUP_DECLARATION_OPEN\"] = 41] = \"MARKUP_DECLARATION_OPEN\";\n    State[State[\"COMMENT_START\"] = 42] = \"COMMENT_START\";\n    State[State[\"COMMENT_START_DASH\"] = 43] = \"COMMENT_START_DASH\";\n    State[State[\"COMMENT\"] = 44] = \"COMMENT\";\n    State[State[\"COMMENT_LESS_THAN_SIGN\"] = 45] = \"COMMENT_LESS_THAN_SIGN\";\n    State[State[\"COMMENT_LESS_THAN_SIGN_BANG\"] = 46] = \"COMMENT_LESS_THAN_SIGN_BANG\";\n    State[State[\"COMMENT_LESS_THAN_SIGN_BANG_DASH\"] = 47] = \"COMMENT_LESS_THAN_SIGN_BANG_DASH\";\n    State[State[\"COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH\"] = 48] = \"COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH\";\n    State[State[\"COMMENT_END_DASH\"] = 49] = \"COMMENT_END_DASH\";\n    State[State[\"COMMENT_END\"] = 50] = \"COMMENT_END\";\n    State[State[\"COMMENT_END_BANG\"] = 51] = \"COMMENT_END_BANG\";\n    State[State[\"DOCTYPE\"] = 52] = \"DOCTYPE\";\n    State[State[\"BEFORE_DOCTYPE_NAME\"] = 53] = \"BEFORE_DOCTYPE_NAME\";\n    State[State[\"DOCTYPE_NAME\"] = 54] = \"DOCTYPE_NAME\";\n    State[State[\"AFTER_DOCTYPE_NAME\"] = 55] = \"AFTER_DOCTYPE_NAME\";\n    State[State[\"AFTER_DOCTYPE_PUBLIC_KEYWORD\"] = 56] = \"AFTER_DOCTYPE_PUBLIC_KEYWORD\";\n    State[State[\"BEFORE_DOCTYPE_PUBLIC_IDENTIFIER\"] = 57] = \"BEFORE_DOCTYPE_PUBLIC_IDENTIFIER\";\n    State[State[\"DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED\"] = 58] = \"DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED\";\n    State[State[\"DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED\"] = 59] = \"DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED\";\n    State[State[\"AFTER_DOCTYPE_PUBLIC_IDENTIFIER\"] = 60] = \"AFTER_DOCTYPE_PUBLIC_IDENTIFIER\";\n    State[State[\"BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS\"] = 61] = \"BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS\";\n    State[State[\"AFTER_DOCTYPE_SYSTEM_KEYWORD\"] = 62] = \"AFTER_DOCTYPE_SYSTEM_KEYWORD\";\n    State[State[\"BEFORE_DOCTYPE_SYSTEM_IDENTIFIER\"] = 63] = \"BEFORE_DOCTYPE_SYSTEM_IDENTIFIER\";\n    State[State[\"DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED\"] = 64] = \"DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED\";\n    State[State[\"DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED\"] = 65] = \"DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED\";\n    State[State[\"AFTER_DOCTYPE_SYSTEM_IDENTIFIER\"] = 66] = \"AFTER_DOCTYPE_SYSTEM_IDENTIFIER\";\n    State[State[\"BOGUS_DOCTYPE\"] = 67] = \"BOGUS_DOCTYPE\";\n    State[State[\"CDATA_SECTION\"] = 68] = \"CDATA_SECTION\";\n    State[State[\"CDATA_SECTION_BRACKET\"] = 69] = \"CDATA_SECTION_BRACKET\";\n    State[State[\"CDATA_SECTION_END\"] = 70] = \"CDATA_SECTION_END\";\n    State[State[\"CHARACTER_REFERENCE\"] = 71] = \"CHARACTER_REFERENCE\";\n    State[State[\"NAMED_CHARACTER_REFERENCE\"] = 72] = \"NAMED_CHARACTER_REFERENCE\";\n    State[State[\"AMBIGUOUS_AMPERSAND\"] = 73] = \"AMBIGUOUS_AMPERSAND\";\n    State[State[\"NUMERIC_CHARACTER_REFERENCE\"] = 74] = \"NUMERIC_CHARACTER_REFERENCE\";\n    State[State[\"HEXADEMICAL_CHARACTER_REFERENCE_START\"] = 75] = \"HEXADEMICAL_CHARACTER_REFERENCE_START\";\n    State[State[\"HEXADEMICAL_CHARACTER_REFERENCE\"] = 76] = \"HEXADEMICAL_CHARACTER_REFERENCE\";\n    State[State[\"DECIMAL_CHARACTER_REFERENCE\"] = 77] = \"DECIMAL_CHARACTER_REFERENCE\";\n    State[State[\"NUMERIC_CHARACTER_REFERENCE_END\"] = 78] = \"NUMERIC_CHARACTER_REFERENCE_END\";\n})(State || (State = {}));\n//Tokenizer initial states for different modes\nexport const TokenizerMode = {\n    DATA: State.DATA,\n    RCDATA: State.RCDATA,\n    RAWTEXT: State.RAWTEXT,\n    SCRIPT_DATA: State.SCRIPT_DATA,\n    PLAINTEXT: State.PLAINTEXT,\n    CDATA_SECTION: State.CDATA_SECTION,\n};\n//Utils\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 isAsciiDigit(cp) {\n    return cp >= $.DIGIT_0 && cp <= $.DIGIT_9;\n}\nfunction isAsciiUpper(cp) {\n    return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_Z;\n}\nfunction isAsciiLower(cp) {\n    return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_Z;\n}\nfunction isAsciiLetter(cp) {\n    return isAsciiLower(cp) || isAsciiUpper(cp);\n}\nfunction isAsciiAlphaNumeric(cp) {\n    return isAsciiLetter(cp) || isAsciiDigit(cp);\n}\nfunction isAsciiUpperHexDigit(cp) {\n    return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_F;\n}\nfunction isAsciiLowerHexDigit(cp) {\n    return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_F;\n}\nfunction isAsciiHexDigit(cp) {\n    return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);\n}\nfunction toAsciiLower(cp) {\n    return cp + 32;\n}\nfunction isWhitespace(cp) {\n    return cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED;\n}\nfunction isEntityInAttributeInvalidEnd(nextCp) {\n    return nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);\n}\nfunction isScriptDataDoubleEscapeSequenceEnd(cp) {\n    return isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN;\n}\n//Tokenizer\nexport class Tokenizer {\n    constructor(options, handler) {\n        this.options = options;\n        this.handler = handler;\n        this.paused = false;\n        /** Ensures that the parsing loop isn't run multiple times at once. */\n        this.inLoop = false;\n        /**\n         * Indicates that the current adjusted node exists, is not an element in the HTML namespace,\n         * and that it is not an integration point for either MathML or HTML.\n         *\n         * @see {@link https://html.spec.whatwg.org/multipage/parsing.html#tree-construction}\n         */\n        this.inForeignNode = false;\n        this.lastStartTagName = '';\n        this.active = false;\n        this.state = State.DATA;\n        this.returnState = State.DATA;\n        this.charRefCode = -1;\n        this.consumedAfterSnapshot = -1;\n        this.currentCharacterToken = null;\n        this.currentToken = null;\n        this.currentAttr = { name: '', value: '' };\n        this.preprocessor = new Preprocessor(handler);\n        this.currentLocation = this.getCurrentLocation(-1);\n    }\n    //Errors\n    _err(code) {\n        var _a, _b;\n        (_b = (_a = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a, this.preprocessor.getError(code));\n    }\n    // NOTE: `offset` may never run across line boundaries.\n    getCurrentLocation(offset) {\n        if (!this.options.sourceCodeLocationInfo) {\n            return null;\n        }\n        return {\n            startLine: this.preprocessor.line,\n            startCol: this.preprocessor.col - offset,\n            startOffset: this.preprocessor.offset - offset,\n            endLine: -1,\n            endCol: -1,\n            endOffset: -1,\n        };\n    }\n    _runParsingLoop() {\n        if (this.inLoop)\n            return;\n        this.inLoop = true;\n        while (this.active && !this.paused) {\n            this.consumedAfterSnapshot = 0;\n            const cp = this._consume();\n            if (!this._ensureHibernation()) {\n                this._callState(cp);\n            }\n        }\n        this.inLoop = false;\n    }\n    //API\n    pause() {\n        this.paused = true;\n    }\n    resume(writeCallback) {\n        if (!this.paused) {\n            throw new Error('Parser was already resumed');\n        }\n        this.paused = false;\n        // Necessary for synchronous resume.\n        if (this.inLoop)\n            return;\n        this._runParsingLoop();\n        if (!this.paused) {\n            writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback();\n        }\n    }\n    write(chunk, isLastChunk, writeCallback) {\n        this.active = true;\n        this.preprocessor.write(chunk, isLastChunk);\n        this._runParsingLoop();\n        if (!this.paused) {\n            writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback();\n        }\n    }\n    insertHtmlAtCurrentPos(chunk) {\n        this.active = true;\n        this.preprocessor.insertHtmlAtCurrentPos(chunk);\n        this._runParsingLoop();\n    }\n    //Hibernation\n    _ensureHibernation() {\n        if (this.preprocessor.endOfChunkHit) {\n            this._unconsume(this.consumedAfterSnapshot);\n            this.active = false;\n            return true;\n        }\n        return false;\n    }\n    //Consumption\n    _consume() {\n        this.consumedAfterSnapshot++;\n        return this.preprocessor.advance();\n    }\n    _unconsume(count) {\n        this.consumedAfterSnapshot -= count;\n        this.preprocessor.retreat(count);\n    }\n    _reconsumeInState(state, cp) {\n        this.state = state;\n        this._callState(cp);\n    }\n    _advanceBy(count) {\n        this.consumedAfterSnapshot += count;\n        for (let i = 0; i < count; i++) {\n            this.preprocessor.advance();\n        }\n    }\n    _consumeSequenceIfMatch(pattern, caseSensitive) {\n        if (this.preprocessor.startsWith(pattern, caseSensitive)) {\n            // We will already have consumed one character before calling this method.\n            this._advanceBy(pattern.length - 1);\n            return true;\n        }\n        return false;\n    }\n    //Token creation\n    _createStartTagToken() {\n        this.currentToken = {\n            type: TokenType.START_TAG,\n            tagName: '',\n            tagID: TAG_ID.UNKNOWN,\n            selfClosing: false,\n            ackSelfClosing: false,\n            attrs: [],\n            location: this.getCurrentLocation(1),\n        };\n    }\n    _createEndTagToken() {\n        this.currentToken = {\n            type: TokenType.END_TAG,\n            tagName: '',\n            tagID: TAG_ID.UNKNOWN,\n            selfClosing: false,\n            ackSelfClosing: false,\n            attrs: [],\n            location: this.getCurrentLocation(2),\n        };\n    }\n    _createCommentToken(offset) {\n        this.currentToken = {\n            type: TokenType.COMMENT,\n            data: '',\n            location: this.getCurrentLocation(offset),\n        };\n    }\n    _createDoctypeToken(initialName) {\n        this.currentToken = {\n            type: TokenType.DOCTYPE,\n            name: initialName,\n            forceQuirks: false,\n            publicId: null,\n            systemId: null,\n            location: this.currentLocation,\n        };\n    }\n    _createCharacterToken(type, chars) {\n        this.currentCharacterToken = {\n            type,\n            chars,\n            location: this.currentLocation,\n        };\n    }\n    //Tag attributes\n    _createAttr(attrNameFirstCh) {\n        this.currentAttr = {\n            name: attrNameFirstCh,\n            value: '',\n        };\n        this.currentLocation = this.getCurrentLocation(0);\n    }\n    _leaveAttrName() {\n        var _a;\n        var _b;\n        const token = this.currentToken;\n        if (getTokenAttr(token, this.currentAttr.name) === null) {\n            token.attrs.push(this.currentAttr);\n            if (token.location && this.currentLocation) {\n                const attrLocations = ((_a = (_b = token.location).attrs) !== null && _a !== void 0 ? _a : (_b.attrs = Object.create(null)));\n                attrLocations[this.currentAttr.name] = this.currentLocation;\n                // Set end location\n                this._leaveAttrValue();\n            }\n        }\n        else {\n            this._err(ERR.duplicateAttribute);\n        }\n    }\n    _leaveAttrValue() {\n        if (this.currentLocation) {\n            this.currentLocation.endLine = this.preprocessor.line;\n            this.currentLocation.endCol = this.preprocessor.col;\n            this.currentLocation.endOffset = this.preprocessor.offset;\n        }\n    }\n    //Token emission\n    prepareToken(ct) {\n        this._emitCurrentCharacterToken(ct.location);\n        this.currentToken = null;\n        if (ct.location) {\n            ct.location.endLine = this.preprocessor.line;\n            ct.location.endCol = this.preprocessor.col + 1;\n            ct.location.endOffset = this.preprocessor.offset + 1;\n        }\n        this.currentLocation = this.getCurrentLocation(-1);\n    }\n    emitCurrentTagToken() {\n        const ct = this.currentToken;\n        this.prepareToken(ct);\n        ct.tagID = getTagID(ct.tagName);\n        if (ct.type === TokenType.START_TAG) {\n            this.lastStartTagName = ct.tagName;\n            this.handler.onStartTag(ct);\n        }\n        else {\n            if (ct.attrs.length > 0) {\n                this._err(ERR.endTagWithAttributes);\n            }\n            if (ct.selfClosing) {\n                this._err(ERR.endTagWithTrailingSolidus);\n            }\n            this.handler.onEndTag(ct);\n        }\n        this.preprocessor.dropParsedChunk();\n    }\n    emitCurrentComment(ct) {\n        this.prepareToken(ct);\n        this.handler.onComment(ct);\n        this.preprocessor.dropParsedChunk();\n    }\n    emitCurrentDoctype(ct) {\n        this.prepareToken(ct);\n        this.handler.onDoctype(ct);\n        this.preprocessor.dropParsedChunk();\n    }\n    _emitCurrentCharacterToken(nextLocation) {\n        if (this.currentCharacterToken) {\n            //NOTE: if we have a pending character token, make it's end location equal to the\n            //current token's start location.\n            if (nextLocation && this.currentCharacterToken.location) {\n                this.currentCharacterToken.location.endLine = nextLocation.startLine;\n                this.currentCharacterToken.location.endCol = nextLocation.startCol;\n                this.currentCharacterToken.location.endOffset = nextLocation.startOffset;\n            }\n            switch (this.currentCharacterToken.type) {\n                case TokenType.CHARACTER: {\n                    this.handler.onCharacter(this.currentCharacterToken);\n                    break;\n                }\n                case TokenType.NULL_CHARACTER: {\n                    this.handler.onNullCharacter(this.currentCharacterToken);\n                    break;\n                }\n                case TokenType.WHITESPACE_CHARACTER: {\n                    this.handler.onWhitespaceCharacter(this.currentCharacterToken);\n                    break;\n                }\n            }\n            this.currentCharacterToken = null;\n        }\n    }\n    _emitEOFToken() {\n        const location = this.getCurrentLocation(0);\n        if (location) {\n            location.endLine = location.startLine;\n            location.endCol = location.startCol;\n            location.endOffset = location.startOffset;\n        }\n        this._emitCurrentCharacterToken(location);\n        this.handler.onEof({ type: TokenType.EOF, location });\n        this.active = false;\n    }\n    //Characters emission\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, the parser can process it\n    //as a single solid character token.\n    //So, there are 3 types of character tokens in parse5:\n    //1)TokenType.NULL_CHARACTER - \\u0000-character sequences (e.g. '\\u0000\\u0000\\u0000')\n    //2)TokenType.WHITESPACE_CHARACTER - any whitespace/new-line character sequences (e.g. '\\n  \\r\\t   \\f')\n    //3)TokenType.CHARACTER - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')\n    _appendCharToCurrentCharacterToken(type, ch) {\n        if (this.currentCharacterToken) {\n            if (this.currentCharacterToken.type !== type) {\n                this.currentLocation = this.getCurrentLocation(0);\n                this._emitCurrentCharacterToken(this.currentLocation);\n                this.preprocessor.dropParsedChunk();\n            }\n            else {\n                this.currentCharacterToken.chars += ch;\n                return;\n            }\n        }\n        this._createCharacterToken(type, ch);\n    }\n    _emitCodePoint(cp) {\n        const type = isWhitespace(cp)\n            ? TokenType.WHITESPACE_CHARACTER\n            : cp === $.NULL\n                ? TokenType.NULL_CHARACTER\n                : TokenType.CHARACTER;\n        this._appendCharToCurrentCharacterToken(type, String.fromCodePoint(cp));\n    }\n    //NOTE: used when we emit characters explicitly.\n    //This is always for non-whitespace and non-null characters, which allows us to avoid additional checks.\n    _emitChars(ch) {\n        this._appendCharToCurrentCharacterToken(TokenType.CHARACTER, ch);\n    }\n    // Character reference helpers\n    _matchNamedCharacterReference(cp) {\n        let result = null;\n        let excess = 0;\n        let withoutSemicolon = false;\n        for (let i = 0, current = htmlDecodeTree[0]; i >= 0; cp = this._consume()) {\n            i = determineBranch(htmlDecodeTree, current, i + 1, cp);\n            if (i < 0)\n                break;\n            excess += 1;\n            current = htmlDecodeTree[i];\n            const masked = current & BinTrieFlags.VALUE_LENGTH;\n            // If the branch is a value, store it and continue\n            if (masked) {\n                // The mask is the number of bytes of the value, including the current byte.\n                const valueLength = (masked >> 14) - 1;\n                // Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n                // See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n                if (cp !== $.SEMICOLON &&\n                    this._isCharacterReferenceInAttribute() &&\n                    isEntityInAttributeInvalidEnd(this.preprocessor.peek(1))) {\n                    //NOTE: we don't flush all consumed code points here, and instead switch back to the original state after\n                    //emitting an ampersand. This is fine, as alphanumeric characters won't be parsed differently in attributes.\n                    result = [$.AMPERSAND];\n                    // Skip over the value.\n                    i += valueLength;\n                }\n                else {\n                    // If this is a surrogate pair, consume the next two bytes.\n                    result =\n                        valueLength === 0\n                            ? [htmlDecodeTree[i] & ~BinTrieFlags.VALUE_LENGTH]\n                            : valueLength === 1\n                                ? [htmlDecodeTree[++i]]\n                                : [htmlDecodeTree[++i], htmlDecodeTree[++i]];\n                    excess = 0;\n                    withoutSemicolon = cp !== $.SEMICOLON;\n                }\n                if (valueLength === 0) {\n                    // If the value is zero-length, we're done.\n                    this._consume();\n                    break;\n                }\n            }\n        }\n        this._unconsume(excess);\n        if (withoutSemicolon && !this.preprocessor.endOfChunkHit) {\n            this._err(ERR.missingSemicolonAfterCharacterReference);\n        }\n        // We want to emit the error above on the code point after the entity.\n        // We always consume one code point too many in the loop, and we wait to\n        // unconsume it until after the error is emitted.\n        this._unconsume(1);\n        return result;\n    }\n    _isCharacterReferenceInAttribute() {\n        return (this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED ||\n            this.returnState === State.ATTRIBUTE_VALUE_SINGLE_QUOTED ||\n            this.returnState === State.ATTRIBUTE_VALUE_UNQUOTED);\n    }\n    _flushCodePointConsumedAsCharacterReference(cp) {\n        if (this._isCharacterReferenceInAttribute()) {\n            this.currentAttr.value += String.fromCodePoint(cp);\n        }\n        else {\n            this._emitCodePoint(cp);\n        }\n    }\n    // Calling states this way turns out to be much faster than any other approach.\n    _callState(cp) {\n        switch (this.state) {\n            case State.DATA: {\n                this._stateData(cp);\n                break;\n            }\n            case State.RCDATA: {\n                this._stateRcdata(cp);\n                break;\n            }\n            case State.RAWTEXT: {\n                this._stateRawtext(cp);\n                break;\n            }\n            case State.SCRIPT_DATA: {\n                this._stateScriptData(cp);\n                break;\n            }\n            case State.PLAINTEXT: {\n                this._statePlaintext(cp);\n                break;\n            }\n            case State.TAG_OPEN: {\n                this._stateTagOpen(cp);\n                break;\n            }\n            case State.END_TAG_OPEN: {\n                this._stateEndTagOpen(cp);\n                break;\n            }\n            case State.TAG_NAME: {\n                this._stateTagName(cp);\n                break;\n            }\n            case State.RCDATA_LESS_THAN_SIGN: {\n                this._stateRcdataLessThanSign(cp);\n                break;\n            }\n            case State.RCDATA_END_TAG_OPEN: {\n                this._stateRcdataEndTagOpen(cp);\n                break;\n            }\n            case State.RCDATA_END_TAG_NAME: {\n                this._stateRcdataEndTagName(cp);\n                break;\n            }\n            case State.RAWTEXT_LESS_THAN_SIGN: {\n                this._stateRawtextLessThanSign(cp);\n                break;\n            }\n            case State.RAWTEXT_END_TAG_OPEN: {\n                this._stateRawtextEndTagOpen(cp);\n                break;\n            }\n            case State.RAWTEXT_END_TAG_NAME: {\n                this._stateRawtextEndTagName(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_LESS_THAN_SIGN: {\n                this._stateScriptDataLessThanSign(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_END_TAG_OPEN: {\n                this._stateScriptDataEndTagOpen(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_END_TAG_NAME: {\n                this._stateScriptDataEndTagName(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_ESCAPE_START: {\n                this._stateScriptDataEscapeStart(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_ESCAPE_START_DASH: {\n                this._stateScriptDataEscapeStartDash(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_ESCAPED: {\n                this._stateScriptDataEscaped(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_ESCAPED_DASH: {\n                this._stateScriptDataEscapedDash(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_ESCAPED_DASH_DASH: {\n                this._stateScriptDataEscapedDashDash(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {\n                this._stateScriptDataEscapedLessThanSign(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN: {\n                this._stateScriptDataEscapedEndTagOpen(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME: {\n                this._stateScriptDataEscapedEndTagName(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_DOUBLE_ESCAPE_START: {\n                this._stateScriptDataDoubleEscapeStart(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_DOUBLE_ESCAPED: {\n                this._stateScriptDataDoubleEscaped(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH: {\n                this._stateScriptDataDoubleEscapedDash(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: {\n                this._stateScriptDataDoubleEscapedDashDash(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: {\n                this._stateScriptDataDoubleEscapedLessThanSign(cp);\n                break;\n            }\n            case State.SCRIPT_DATA_DOUBLE_ESCAPE_END: {\n                this._stateScriptDataDoubleEscapeEnd(cp);\n                break;\n            }\n            case State.BEFORE_ATTRIBUTE_NAME: {\n                this._stateBeforeAttributeName(cp);\n                break;\n            }\n            case State.ATTRIBUTE_NAME: {\n                this._stateAttributeName(cp);\n                break;\n            }\n            case State.AFTER_ATTRIBUTE_NAME: {\n                this._stateAfterAttributeName(cp);\n                break;\n            }\n            case State.BEFORE_ATTRIBUTE_VALUE: {\n                this._stateBeforeAttributeValue(cp);\n                break;\n            }\n            case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED: {\n                this._stateAttributeValueDoubleQuoted(cp);\n                break;\n            }\n            case State.ATTRIBUTE_VALUE_SINGLE_QUOTED: {\n                this._stateAttributeValueSingleQuoted(cp);\n                break;\n            }\n            case State.ATTRIBUTE_VALUE_UNQUOTED: {\n                this._stateAttributeValueUnquoted(cp);\n                break;\n            }\n            case State.AFTER_ATTRIBUTE_VALUE_QUOTED: {\n                this._stateAfterAttributeValueQuoted(cp);\n                break;\n            }\n            case State.SELF_CLOSING_START_TAG: {\n                this._stateSelfClosingStartTag(cp);\n                break;\n            }\n            case State.BOGUS_COMMENT: {\n                this._stateBogusComment(cp);\n                break;\n            }\n            case State.MARKUP_DECLARATION_OPEN: {\n                this._stateMarkupDeclarationOpen(cp);\n                break;\n            }\n            case State.COMMENT_START: {\n                this._stateCommentStart(cp);\n                break;\n            }\n            case State.COMMENT_START_DASH: {\n                this._stateCommentStartDash(cp);\n                break;\n            }\n            case State.COMMENT: {\n                this._stateComment(cp);\n                break;\n            }\n            case State.COMMENT_LESS_THAN_SIGN: {\n                this._stateCommentLessThanSign(cp);\n                break;\n            }\n            case State.COMMENT_LESS_THAN_SIGN_BANG: {\n                this._stateCommentLessThanSignBang(cp);\n                break;\n            }\n            case State.COMMENT_LESS_THAN_SIGN_BANG_DASH: {\n                this._stateCommentLessThanSignBangDash(cp);\n                break;\n            }\n            case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH: {\n                this._stateCommentLessThanSignBangDashDash(cp);\n                break;\n            }\n            case State.COMMENT_END_DASH: {\n                this._stateCommentEndDash(cp);\n                break;\n            }\n            case State.COMMENT_END: {\n                this._stateCommentEnd(cp);\n                break;\n            }\n            case State.COMMENT_END_BANG: {\n                this._stateCommentEndBang(cp);\n                break;\n            }\n            case State.DOCTYPE: {\n                this._stateDoctype(cp);\n                break;\n            }\n            case State.BEFORE_DOCTYPE_NAME: {\n                this._stateBeforeDoctypeName(cp);\n                break;\n            }\n            case State.DOCTYPE_NAME: {\n                this._stateDoctypeName(cp);\n                break;\n            }\n            case State.AFTER_DOCTYPE_NAME: {\n                this._stateAfterDoctypeName(cp);\n                break;\n            }\n            case State.AFTER_DOCTYPE_PUBLIC_KEYWORD: {\n                this._stateAfterDoctypePublicKeyword(cp);\n                break;\n            }\n            case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {\n                this._stateBeforeDoctypePublicIdentifier(cp);\n                break;\n            }\n            case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: {\n                this._stateDoctypePublicIdentifierDoubleQuoted(cp);\n                break;\n            }\n            case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {\n                this._stateDoctypePublicIdentifierSingleQuoted(cp);\n                break;\n            }\n            case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER: {\n                this._stateAfterDoctypePublicIdentifier(cp);\n                break;\n            }\n            case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {\n                this._stateBetweenDoctypePublicAndSystemIdentifiers(cp);\n                break;\n            }\n            case State.AFTER_DOCTYPE_SYSTEM_KEYWORD: {\n                this._stateAfterDoctypeSystemKeyword(cp);\n                break;\n            }\n            case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: {\n                this._stateBeforeDoctypeSystemIdentifier(cp);\n                break;\n            }\n            case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: {\n                this._stateDoctypeSystemIdentifierDoubleQuoted(cp);\n                break;\n            }\n            case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {\n                this._stateDoctypeSystemIdentifierSingleQuoted(cp);\n                break;\n            }\n            case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {\n                this._stateAfterDoctypeSystemIdentifier(cp);\n                break;\n            }\n            case State.BOGUS_DOCTYPE: {\n                this._stateBogusDoctype(cp);\n                break;\n            }\n            case State.CDATA_SECTION: {\n                this._stateCdataSection(cp);\n                break;\n            }\n            case State.CDATA_SECTION_BRACKET: {\n                this._stateCdataSectionBracket(cp);\n                break;\n            }\n            case State.CDATA_SECTION_END: {\n                this._stateCdataSectionEnd(cp);\n                break;\n            }\n            case State.CHARACTER_REFERENCE: {\n                this._stateCharacterReference(cp);\n                break;\n            }\n            case State.NAMED_CHARACTER_REFERENCE: {\n                this._stateNamedCharacterReference(cp);\n                break;\n            }\n            case State.AMBIGUOUS_AMPERSAND: {\n                this._stateAmbiguousAmpersand(cp);\n                break;\n            }\n            case State.NUMERIC_CHARACTER_REFERENCE: {\n                this._stateNumericCharacterReference(cp);\n                break;\n            }\n            case State.HEXADEMICAL_CHARACTER_REFERENCE_START: {\n                this._stateHexademicalCharacterReferenceStart(cp);\n                break;\n            }\n            case State.HEXADEMICAL_CHARACTER_REFERENCE: {\n                this._stateHexademicalCharacterReference(cp);\n                break;\n            }\n            case State.DECIMAL_CHARACTER_REFERENCE: {\n                this._stateDecimalCharacterReference(cp);\n                break;\n            }\n            case State.NUMERIC_CHARACTER_REFERENCE_END: {\n                this._stateNumericCharacterReferenceEnd(cp);\n                break;\n            }\n            default: {\n                throw new Error('Unknown state');\n            }\n        }\n    }\n    // State machine\n    // Data state\n    //------------------------------------------------------------------\n    _stateData(cp) {\n        switch (cp) {\n            case $.LESS_THAN_SIGN: {\n                this.state = State.TAG_OPEN;\n                break;\n            }\n            case $.AMPERSAND: {\n                this.returnState = State.DATA;\n                this.state = State.CHARACTER_REFERENCE;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this._emitCodePoint(cp);\n                break;\n            }\n            case $.EOF: {\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    //  RCDATA state\n    //------------------------------------------------------------------\n    _stateRcdata(cp) {\n        switch (cp) {\n            case $.AMPERSAND: {\n                this.returnState = State.RCDATA;\n                this.state = State.CHARACTER_REFERENCE;\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                this.state = State.RCDATA_LESS_THAN_SIGN;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // RAWTEXT state\n    //------------------------------------------------------------------\n    _stateRawtext(cp) {\n        switch (cp) {\n            case $.LESS_THAN_SIGN: {\n                this.state = State.RAWTEXT_LESS_THAN_SIGN;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // Script data state\n    //------------------------------------------------------------------\n    _stateScriptData(cp) {\n        switch (cp) {\n            case $.LESS_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA_LESS_THAN_SIGN;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // PLAINTEXT state\n    //------------------------------------------------------------------\n    _statePlaintext(cp) {\n        switch (cp) {\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // Tag open state\n    //------------------------------------------------------------------\n    _stateTagOpen(cp) {\n        if (isAsciiLetter(cp)) {\n            this._createStartTagToken();\n            this.state = State.TAG_NAME;\n            this._stateTagName(cp);\n        }\n        else\n            switch (cp) {\n                case $.EXCLAMATION_MARK: {\n                    this.state = State.MARKUP_DECLARATION_OPEN;\n                    break;\n                }\n                case $.SOLIDUS: {\n                    this.state = State.END_TAG_OPEN;\n                    break;\n                }\n                case $.QUESTION_MARK: {\n                    this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);\n                    this._createCommentToken(1);\n                    this.state = State.BOGUS_COMMENT;\n                    this._stateBogusComment(cp);\n                    break;\n                }\n                case $.EOF: {\n                    this._err(ERR.eofBeforeTagName);\n                    this._emitChars('<');\n                    this._emitEOFToken();\n                    break;\n                }\n                default: {\n                    this._err(ERR.invalidFirstCharacterOfTagName);\n                    this._emitChars('<');\n                    this.state = State.DATA;\n                    this._stateData(cp);\n                }\n            }\n    }\n    // End tag open state\n    //------------------------------------------------------------------\n    _stateEndTagOpen(cp) {\n        if (isAsciiLetter(cp)) {\n            this._createEndTagToken();\n            this.state = State.TAG_NAME;\n            this._stateTagName(cp);\n        }\n        else\n            switch (cp) {\n                case $.GREATER_THAN_SIGN: {\n                    this._err(ERR.missingEndTagName);\n                    this.state = State.DATA;\n                    break;\n                }\n                case $.EOF: {\n                    this._err(ERR.eofBeforeTagName);\n                    this._emitChars('</');\n                    this._emitEOFToken();\n                    break;\n                }\n                default: {\n                    this._err(ERR.invalidFirstCharacterOfTagName);\n                    this._createCommentToken(2);\n                    this.state = State.BOGUS_COMMENT;\n                    this._stateBogusComment(cp);\n                }\n            }\n    }\n    // Tag name state\n    //------------------------------------------------------------------\n    _stateTagName(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this.state = State.BEFORE_ATTRIBUTE_NAME;\n                break;\n            }\n            case $.SOLIDUS: {\n                this.state = State.SELF_CLOSING_START_TAG;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.DATA;\n                this.emitCurrentTagToken();\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                token.tagName += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInTag);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.tagName += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);\n            }\n        }\n    }\n    // RCDATA less-than sign state\n    //------------------------------------------------------------------\n    _stateRcdataLessThanSign(cp) {\n        if (cp === $.SOLIDUS) {\n            this.state = State.RCDATA_END_TAG_OPEN;\n        }\n        else {\n            this._emitChars('<');\n            this.state = State.RCDATA;\n            this._stateRcdata(cp);\n        }\n    }\n    // RCDATA end tag open state\n    //------------------------------------------------------------------\n    _stateRcdataEndTagOpen(cp) {\n        if (isAsciiLetter(cp)) {\n            this.state = State.RCDATA_END_TAG_NAME;\n            this._stateRcdataEndTagName(cp);\n        }\n        else {\n            this._emitChars('</');\n            this.state = State.RCDATA;\n            this._stateRcdata(cp);\n        }\n    }\n    handleSpecialEndTag(_cp) {\n        if (!this.preprocessor.startsWith(this.lastStartTagName, false)) {\n            return !this._ensureHibernation();\n        }\n        this._createEndTagToken();\n        const token = this.currentToken;\n        token.tagName = this.lastStartTagName;\n        const cp = this.preprocessor.peek(this.lastStartTagName.length);\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this._advanceBy(this.lastStartTagName.length);\n                this.state = State.BEFORE_ATTRIBUTE_NAME;\n                return false;\n            }\n            case $.SOLIDUS: {\n                this._advanceBy(this.lastStartTagName.length);\n                this.state = State.SELF_CLOSING_START_TAG;\n                return false;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._advanceBy(this.lastStartTagName.length);\n                this.emitCurrentTagToken();\n                this.state = State.DATA;\n                return false;\n            }\n            default: {\n                return !this._ensureHibernation();\n            }\n        }\n    }\n    // RCDATA end tag name state\n    //------------------------------------------------------------------\n    _stateRcdataEndTagName(cp) {\n        if (this.handleSpecialEndTag(cp)) {\n            this._emitChars('</');\n            this.state = State.RCDATA;\n            this._stateRcdata(cp);\n        }\n    }\n    // RAWTEXT less-than sign state\n    //------------------------------------------------------------------\n    _stateRawtextLessThanSign(cp) {\n        if (cp === $.SOLIDUS) {\n            this.state = State.RAWTEXT_END_TAG_OPEN;\n        }\n        else {\n            this._emitChars('<');\n            this.state = State.RAWTEXT;\n            this._stateRawtext(cp);\n        }\n    }\n    // RAWTEXT end tag open state\n    //------------------------------------------------------------------\n    _stateRawtextEndTagOpen(cp) {\n        if (isAsciiLetter(cp)) {\n            this.state = State.RAWTEXT_END_TAG_NAME;\n            this._stateRawtextEndTagName(cp);\n        }\n        else {\n            this._emitChars('</');\n            this.state = State.RAWTEXT;\n            this._stateRawtext(cp);\n        }\n    }\n    // RAWTEXT end tag name state\n    //------------------------------------------------------------------\n    _stateRawtextEndTagName(cp) {\n        if (this.handleSpecialEndTag(cp)) {\n            this._emitChars('</');\n            this.state = State.RAWTEXT;\n            this._stateRawtext(cp);\n        }\n    }\n    // Script data less-than sign state\n    //------------------------------------------------------------------\n    _stateScriptDataLessThanSign(cp) {\n        switch (cp) {\n            case $.SOLIDUS: {\n                this.state = State.SCRIPT_DATA_END_TAG_OPEN;\n                break;\n            }\n            case $.EXCLAMATION_MARK: {\n                this.state = State.SCRIPT_DATA_ESCAPE_START;\n                this._emitChars('<!');\n                break;\n            }\n            default: {\n                this._emitChars('<');\n                this.state = State.SCRIPT_DATA;\n                this._stateScriptData(cp);\n            }\n        }\n    }\n    // Script data end tag open state\n    //------------------------------------------------------------------\n    _stateScriptDataEndTagOpen(cp) {\n        if (isAsciiLetter(cp)) {\n            this.state = State.SCRIPT_DATA_END_TAG_NAME;\n            this._stateScriptDataEndTagName(cp);\n        }\n        else {\n            this._emitChars('</');\n            this.state = State.SCRIPT_DATA;\n            this._stateScriptData(cp);\n        }\n    }\n    // Script data end tag name state\n    //------------------------------------------------------------------\n    _stateScriptDataEndTagName(cp) {\n        if (this.handleSpecialEndTag(cp)) {\n            this._emitChars('</');\n            this.state = State.SCRIPT_DATA;\n            this._stateScriptData(cp);\n        }\n    }\n    // Script data escape start state\n    //------------------------------------------------------------------\n    _stateScriptDataEscapeStart(cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = State.SCRIPT_DATA_ESCAPE_START_DASH;\n            this._emitChars('-');\n        }\n        else {\n            this.state = State.SCRIPT_DATA;\n            this._stateScriptData(cp);\n        }\n    }\n    // Script data escape start dash state\n    //------------------------------------------------------------------\n    _stateScriptDataEscapeStartDash(cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;\n            this._emitChars('-');\n        }\n        else {\n            this.state = State.SCRIPT_DATA;\n            this._stateScriptData(cp);\n        }\n    }\n    // Script data escaped state\n    //------------------------------------------------------------------\n    _stateScriptDataEscaped(cp) {\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this.state = State.SCRIPT_DATA_ESCAPED_DASH;\n                this._emitChars('-');\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInScriptHtmlCommentLikeText);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // Script data escaped dash state\n    //------------------------------------------------------------------\n    _stateScriptDataEscapedDash(cp) {\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;\n                this._emitChars('-');\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this.state = State.SCRIPT_DATA_ESCAPED;\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInScriptHtmlCommentLikeText);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this.state = State.SCRIPT_DATA_ESCAPED;\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // Script data escaped dash dash state\n    //------------------------------------------------------------------\n    _stateScriptDataEscapedDashDash(cp) {\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this._emitChars('-');\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA;\n                this._emitChars('>');\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this.state = State.SCRIPT_DATA_ESCAPED;\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInScriptHtmlCommentLikeText);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this.state = State.SCRIPT_DATA_ESCAPED;\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // Script data escaped less-than sign state\n    //------------------------------------------------------------------\n    _stateScriptDataEscapedLessThanSign(cp) {\n        if (cp === $.SOLIDUS) {\n            this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN;\n        }\n        else if (isAsciiLetter(cp)) {\n            this._emitChars('<');\n            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_START;\n            this._stateScriptDataDoubleEscapeStart(cp);\n        }\n        else {\n            this._emitChars('<');\n            this.state = State.SCRIPT_DATA_ESCAPED;\n            this._stateScriptDataEscaped(cp);\n        }\n    }\n    // Script data escaped end tag open state\n    //------------------------------------------------------------------\n    _stateScriptDataEscapedEndTagOpen(cp) {\n        if (isAsciiLetter(cp)) {\n            this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_NAME;\n            this._stateScriptDataEscapedEndTagName(cp);\n        }\n        else {\n            this._emitChars('</');\n            this.state = State.SCRIPT_DATA_ESCAPED;\n            this._stateScriptDataEscaped(cp);\n        }\n    }\n    // Script data escaped end tag name state\n    //------------------------------------------------------------------\n    _stateScriptDataEscapedEndTagName(cp) {\n        if (this.handleSpecialEndTag(cp)) {\n            this._emitChars('</');\n            this.state = State.SCRIPT_DATA_ESCAPED;\n            this._stateScriptDataEscaped(cp);\n        }\n    }\n    // Script data double escape start state\n    //------------------------------------------------------------------\n    _stateScriptDataDoubleEscapeStart(cp) {\n        if (this.preprocessor.startsWith($$.SCRIPT, false) &&\n            isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek($$.SCRIPT.length))) {\n            this._emitCodePoint(cp);\n            for (let i = 0; i < $$.SCRIPT.length; i++) {\n                this._emitCodePoint(this._consume());\n            }\n            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n        }\n        else if (!this._ensureHibernation()) {\n            this.state = State.SCRIPT_DATA_ESCAPED;\n            this._stateScriptDataEscaped(cp);\n        }\n    }\n    // Script data double escaped state\n    //------------------------------------------------------------------\n    _stateScriptDataDoubleEscaped(cp) {\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH;\n                this._emitChars('-');\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;\n                this._emitChars('<');\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInScriptHtmlCommentLikeText);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // Script data double escaped dash state\n    //------------------------------------------------------------------\n    _stateScriptDataDoubleEscapedDash(cp) {\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;\n                this._emitChars('-');\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;\n                this._emitChars('<');\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInScriptHtmlCommentLikeText);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // Script data double escaped dash dash state\n    //------------------------------------------------------------------\n    _stateScriptDataDoubleEscapedDashDash(cp) {\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this._emitChars('-');\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;\n                this._emitChars('<');\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.SCRIPT_DATA;\n                this._emitChars('>');\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n                this._emitChars(REPLACEMENT_CHARACTER);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInScriptHtmlCommentLikeText);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // Script data double escaped less-than sign state\n    //------------------------------------------------------------------\n    _stateScriptDataDoubleEscapedLessThanSign(cp) {\n        if (cp === $.SOLIDUS) {\n            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_END;\n            this._emitChars('/');\n        }\n        else {\n            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n            this._stateScriptDataDoubleEscaped(cp);\n        }\n    }\n    // Script data double escape end state\n    //------------------------------------------------------------------\n    _stateScriptDataDoubleEscapeEnd(cp) {\n        if (this.preprocessor.startsWith($$.SCRIPT, false) &&\n            isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek($$.SCRIPT.length))) {\n            this._emitCodePoint(cp);\n            for (let i = 0; i < $$.SCRIPT.length; i++) {\n                this._emitCodePoint(this._consume());\n            }\n            this.state = State.SCRIPT_DATA_ESCAPED;\n        }\n        else if (!this._ensureHibernation()) {\n            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n            this._stateScriptDataDoubleEscaped(cp);\n        }\n    }\n    // Before attribute name state\n    //------------------------------------------------------------------\n    _stateBeforeAttributeName(cp) {\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                // Ignore whitespace\n                break;\n            }\n            case $.SOLIDUS:\n            case $.GREATER_THAN_SIGN:\n            case $.EOF: {\n                this.state = State.AFTER_ATTRIBUTE_NAME;\n                this._stateAfterAttributeName(cp);\n                break;\n            }\n            case $.EQUALS_SIGN: {\n                this._err(ERR.unexpectedEqualsSignBeforeAttributeName);\n                this._createAttr('=');\n                this.state = State.ATTRIBUTE_NAME;\n                break;\n            }\n            default: {\n                this._createAttr('');\n                this.state = State.ATTRIBUTE_NAME;\n                this._stateAttributeName(cp);\n            }\n        }\n    }\n    // Attribute name state\n    //------------------------------------------------------------------\n    _stateAttributeName(cp) {\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED:\n            case $.SOLIDUS:\n            case $.GREATER_THAN_SIGN:\n            case $.EOF: {\n                this._leaveAttrName();\n                this.state = State.AFTER_ATTRIBUTE_NAME;\n                this._stateAfterAttributeName(cp);\n                break;\n            }\n            case $.EQUALS_SIGN: {\n                this._leaveAttrName();\n                this.state = State.BEFORE_ATTRIBUTE_VALUE;\n                break;\n            }\n            case $.QUOTATION_MARK:\n            case $.APOSTROPHE:\n            case $.LESS_THAN_SIGN: {\n                this._err(ERR.unexpectedCharacterInAttributeName);\n                this.currentAttr.name += String.fromCodePoint(cp);\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this.currentAttr.name += REPLACEMENT_CHARACTER;\n                break;\n            }\n            default: {\n                this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);\n            }\n        }\n    }\n    // After attribute name state\n    //------------------------------------------------------------------\n    _stateAfterAttributeName(cp) {\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                // Ignore whitespace\n                break;\n            }\n            case $.SOLIDUS: {\n                this.state = State.SELF_CLOSING_START_TAG;\n                break;\n            }\n            case $.EQUALS_SIGN: {\n                this.state = State.BEFORE_ATTRIBUTE_VALUE;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.DATA;\n                this.emitCurrentTagToken();\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInTag);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._createAttr('');\n                this.state = State.ATTRIBUTE_NAME;\n                this._stateAttributeName(cp);\n            }\n        }\n    }\n    // Before attribute value state\n    //------------------------------------------------------------------\n    _stateBeforeAttributeValue(cp) {\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                // Ignore whitespace\n                break;\n            }\n            case $.QUOTATION_MARK: {\n                this.state = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;\n                break;\n            }\n            case $.APOSTROPHE: {\n                this.state = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.missingAttributeValue);\n                this.state = State.DATA;\n                this.emitCurrentTagToken();\n                break;\n            }\n            default: {\n                this.state = State.ATTRIBUTE_VALUE_UNQUOTED;\n                this._stateAttributeValueUnquoted(cp);\n            }\n        }\n    }\n    // Attribute value (double-quoted) state\n    //------------------------------------------------------------------\n    _stateAttributeValueDoubleQuoted(cp) {\n        switch (cp) {\n            case $.QUOTATION_MARK: {\n                this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;\n                break;\n            }\n            case $.AMPERSAND: {\n                this.returnState = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;\n                this.state = State.CHARACTER_REFERENCE;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this.currentAttr.value += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInTag);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this.currentAttr.value += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // Attribute value (single-quoted) state\n    //------------------------------------------------------------------\n    _stateAttributeValueSingleQuoted(cp) {\n        switch (cp) {\n            case $.APOSTROPHE: {\n                this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;\n                break;\n            }\n            case $.AMPERSAND: {\n                this.returnState = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;\n                this.state = State.CHARACTER_REFERENCE;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this.currentAttr.value += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInTag);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this.currentAttr.value += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // Attribute value (unquoted) state\n    //------------------------------------------------------------------\n    _stateAttributeValueUnquoted(cp) {\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this._leaveAttrValue();\n                this.state = State.BEFORE_ATTRIBUTE_NAME;\n                break;\n            }\n            case $.AMPERSAND: {\n                this.returnState = State.ATTRIBUTE_VALUE_UNQUOTED;\n                this.state = State.CHARACTER_REFERENCE;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._leaveAttrValue();\n                this.state = State.DATA;\n                this.emitCurrentTagToken();\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                this.currentAttr.value += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.QUOTATION_MARK:\n            case $.APOSTROPHE:\n            case $.LESS_THAN_SIGN:\n            case $.EQUALS_SIGN:\n            case $.GRAVE_ACCENT: {\n                this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);\n                this.currentAttr.value += String.fromCodePoint(cp);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInTag);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this.currentAttr.value += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // After attribute value (quoted) state\n    //------------------------------------------------------------------\n    _stateAfterAttributeValueQuoted(cp) {\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this._leaveAttrValue();\n                this.state = State.BEFORE_ATTRIBUTE_NAME;\n                break;\n            }\n            case $.SOLIDUS: {\n                this._leaveAttrValue();\n                this.state = State.SELF_CLOSING_START_TAG;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._leaveAttrValue();\n                this.state = State.DATA;\n                this.emitCurrentTagToken();\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInTag);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.missingWhitespaceBetweenAttributes);\n                this.state = State.BEFORE_ATTRIBUTE_NAME;\n                this._stateBeforeAttributeName(cp);\n            }\n        }\n    }\n    // Self-closing start tag state\n    //------------------------------------------------------------------\n    _stateSelfClosingStartTag(cp) {\n        switch (cp) {\n            case $.GREATER_THAN_SIGN: {\n                const token = this.currentToken;\n                token.selfClosing = true;\n                this.state = State.DATA;\n                this.emitCurrentTagToken();\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInTag);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.unexpectedSolidusInTag);\n                this.state = State.BEFORE_ATTRIBUTE_NAME;\n                this._stateBeforeAttributeName(cp);\n            }\n        }\n    }\n    // Bogus comment state\n    //------------------------------------------------------------------\n    _stateBogusComment(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.DATA;\n                this.emitCurrentComment(token);\n                break;\n            }\n            case $.EOF: {\n                this.emitCurrentComment(token);\n                this._emitEOFToken();\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                token.data += REPLACEMENT_CHARACTER;\n                break;\n            }\n            default: {\n                token.data += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // Markup declaration open state\n    //------------------------------------------------------------------\n    _stateMarkupDeclarationOpen(cp) {\n        if (this._consumeSequenceIfMatch($$.DASH_DASH, true)) {\n            this._createCommentToken($$.DASH_DASH.length + 1);\n            this.state = State.COMMENT_START;\n        }\n        else if (this._consumeSequenceIfMatch($$.DOCTYPE, false)) {\n            // NOTE: Doctypes tokens are created without fixed offsets. We keep track of the moment a doctype *might* start here.\n            this.currentLocation = this.getCurrentLocation($$.DOCTYPE.length + 1);\n            this.state = State.DOCTYPE;\n        }\n        else if (this._consumeSequenceIfMatch($$.CDATA_START, true)) {\n            if (this.inForeignNode) {\n                this.state = State.CDATA_SECTION;\n            }\n            else {\n                this._err(ERR.cdataInHtmlContent);\n                this._createCommentToken($$.CDATA_START.length + 1);\n                this.currentToken.data = '[CDATA[';\n                this.state = State.BOGUS_COMMENT;\n            }\n        }\n        //NOTE: Sequence lookups 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(2);\n            this.state = State.BOGUS_COMMENT;\n            this._stateBogusComment(cp);\n        }\n    }\n    // Comment start state\n    //------------------------------------------------------------------\n    _stateCommentStart(cp) {\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this.state = State.COMMENT_START_DASH;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.abruptClosingOfEmptyComment);\n                this.state = State.DATA;\n                const token = this.currentToken;\n                this.emitCurrentComment(token);\n                break;\n            }\n            default: {\n                this.state = State.COMMENT;\n                this._stateComment(cp);\n            }\n        }\n    }\n    // Comment start dash state\n    //------------------------------------------------------------------\n    _stateCommentStartDash(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this.state = State.COMMENT_END;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.abruptClosingOfEmptyComment);\n                this.state = State.DATA;\n                this.emitCurrentComment(token);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInComment);\n                this.emitCurrentComment(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.data += '-';\n                this.state = State.COMMENT;\n                this._stateComment(cp);\n            }\n        }\n    }\n    // Comment state\n    //------------------------------------------------------------------\n    _stateComment(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this.state = State.COMMENT_END_DASH;\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                token.data += '<';\n                this.state = State.COMMENT_LESS_THAN_SIGN;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                token.data += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInComment);\n                this.emitCurrentComment(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.data += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // Comment less-than sign state\n    //------------------------------------------------------------------\n    _stateCommentLessThanSign(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.EXCLAMATION_MARK: {\n                token.data += '!';\n                this.state = State.COMMENT_LESS_THAN_SIGN_BANG;\n                break;\n            }\n            case $.LESS_THAN_SIGN: {\n                token.data += '<';\n                break;\n            }\n            default: {\n                this.state = State.COMMENT;\n                this._stateComment(cp);\n            }\n        }\n    }\n    // Comment less-than sign bang state\n    //------------------------------------------------------------------\n    _stateCommentLessThanSignBang(cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH;\n        }\n        else {\n            this.state = State.COMMENT;\n            this._stateComment(cp);\n        }\n    }\n    // Comment less-than sign bang dash state\n    //------------------------------------------------------------------\n    _stateCommentLessThanSignBangDash(cp) {\n        if (cp === $.HYPHEN_MINUS) {\n            this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH;\n        }\n        else {\n            this.state = State.COMMENT_END_DASH;\n            this._stateCommentEndDash(cp);\n        }\n    }\n    // Comment less-than sign bang dash dash state\n    //------------------------------------------------------------------\n    _stateCommentLessThanSignBangDashDash(cp) {\n        if (cp !== $.GREATER_THAN_SIGN && cp !== $.EOF) {\n            this._err(ERR.nestedComment);\n        }\n        this.state = State.COMMENT_END;\n        this._stateCommentEnd(cp);\n    }\n    // Comment end dash state\n    //------------------------------------------------------------------\n    _stateCommentEndDash(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                this.state = State.COMMENT_END;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInComment);\n                this.emitCurrentComment(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.data += '-';\n                this.state = State.COMMENT;\n                this._stateComment(cp);\n            }\n        }\n    }\n    // Comment end state\n    //------------------------------------------------------------------\n    _stateCommentEnd(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.DATA;\n                this.emitCurrentComment(token);\n                break;\n            }\n            case $.EXCLAMATION_MARK: {\n                this.state = State.COMMENT_END_BANG;\n                break;\n            }\n            case $.HYPHEN_MINUS: {\n                token.data += '-';\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInComment);\n                this.emitCurrentComment(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.data += '--';\n                this.state = State.COMMENT;\n                this._stateComment(cp);\n            }\n        }\n    }\n    // Comment end bang state\n    //------------------------------------------------------------------\n    _stateCommentEndBang(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.HYPHEN_MINUS: {\n                token.data += '--!';\n                this.state = State.COMMENT_END_DASH;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.incorrectlyClosedComment);\n                this.state = State.DATA;\n                this.emitCurrentComment(token);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInComment);\n                this.emitCurrentComment(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.data += '--!';\n                this.state = State.COMMENT;\n                this._stateComment(cp);\n            }\n        }\n    }\n    // DOCTYPE state\n    //------------------------------------------------------------------\n    _stateDoctype(cp) {\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this.state = State.BEFORE_DOCTYPE_NAME;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.BEFORE_DOCTYPE_NAME;\n                this._stateBeforeDoctypeName(cp);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                this._createDoctypeToken(null);\n                const token = this.currentToken;\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.missingWhitespaceBeforeDoctypeName);\n                this.state = State.BEFORE_DOCTYPE_NAME;\n                this._stateBeforeDoctypeName(cp);\n            }\n        }\n    }\n    // Before DOCTYPE name state\n    //------------------------------------------------------------------\n    _stateBeforeDoctypeName(cp) {\n        if (isAsciiUpper(cp)) {\n            this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp)));\n            this.state = State.DOCTYPE_NAME;\n        }\n        else\n            switch (cp) {\n                case $.SPACE:\n                case $.LINE_FEED:\n                case $.TABULATION:\n                case $.FORM_FEED: {\n                    // Ignore whitespace\n                    break;\n                }\n                case $.NULL: {\n                    this._err(ERR.unexpectedNullCharacter);\n                    this._createDoctypeToken(REPLACEMENT_CHARACTER);\n                    this.state = State.DOCTYPE_NAME;\n                    break;\n                }\n                case $.GREATER_THAN_SIGN: {\n                    this._err(ERR.missingDoctypeName);\n                    this._createDoctypeToken(null);\n                    const token = this.currentToken;\n                    token.forceQuirks = true;\n                    this.emitCurrentDoctype(token);\n                    this.state = State.DATA;\n                    break;\n                }\n                case $.EOF: {\n                    this._err(ERR.eofInDoctype);\n                    this._createDoctypeToken(null);\n                    const token = this.currentToken;\n                    token.forceQuirks = true;\n                    this.emitCurrentDoctype(token);\n                    this._emitEOFToken();\n                    break;\n                }\n                default: {\n                    this._createDoctypeToken(String.fromCodePoint(cp));\n                    this.state = State.DOCTYPE_NAME;\n                }\n            }\n    }\n    // DOCTYPE name state\n    //------------------------------------------------------------------\n    _stateDoctypeName(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this.state = State.AFTER_DOCTYPE_NAME;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.DATA;\n                this.emitCurrentDoctype(token);\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                token.name += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);\n            }\n        }\n    }\n    // After DOCTYPE name state\n    //------------------------------------------------------------------\n    _stateAfterDoctypeName(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                // Ignore whitespace\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.DATA;\n                this.emitCurrentDoctype(token);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                if (this._consumeSequenceIfMatch($$.PUBLIC, false)) {\n                    this.state = State.AFTER_DOCTYPE_PUBLIC_KEYWORD;\n                }\n                else if (this._consumeSequenceIfMatch($$.SYSTEM, false)) {\n                    this.state = State.AFTER_DOCTYPE_SYSTEM_KEYWORD;\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                    token.forceQuirks = true;\n                    this.state = State.BOGUS_DOCTYPE;\n                    this._stateBogusDoctype(cp);\n                }\n            }\n        }\n    }\n    // After DOCTYPE public keyword state\n    //------------------------------------------------------------------\n    _stateAfterDoctypePublicKeyword(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this.state = State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;\n                break;\n            }\n            case $.QUOTATION_MARK: {\n                this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);\n                token.publicId = '';\n                this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;\n                break;\n            }\n            case $.APOSTROPHE: {\n                this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);\n                token.publicId = '';\n                this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.missingDoctypePublicIdentifier);\n                token.forceQuirks = true;\n                this.state = State.DATA;\n                this.emitCurrentDoctype(token);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);\n                token.forceQuirks = true;\n                this.state = State.BOGUS_DOCTYPE;\n                this._stateBogusDoctype(cp);\n            }\n        }\n    }\n    // Before DOCTYPE public identifier state\n    //------------------------------------------------------------------\n    _stateBeforeDoctypePublicIdentifier(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                // Ignore whitespace\n                break;\n            }\n            case $.QUOTATION_MARK: {\n                token.publicId = '';\n                this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;\n                break;\n            }\n            case $.APOSTROPHE: {\n                token.publicId = '';\n                this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.missingDoctypePublicIdentifier);\n                token.forceQuirks = true;\n                this.state = State.DATA;\n                this.emitCurrentDoctype(token);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);\n                token.forceQuirks = true;\n                this.state = State.BOGUS_DOCTYPE;\n                this._stateBogusDoctype(cp);\n            }\n        }\n    }\n    // DOCTYPE public identifier (double-quoted) state\n    //------------------------------------------------------------------\n    _stateDoctypePublicIdentifierDoubleQuoted(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.QUOTATION_MARK: {\n                this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                token.publicId += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.abruptDoctypePublicIdentifier);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this.state = State.DATA;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.publicId += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // DOCTYPE public identifier (single-quoted) state\n    //------------------------------------------------------------------\n    _stateDoctypePublicIdentifierSingleQuoted(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.APOSTROPHE: {\n                this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                token.publicId += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.abruptDoctypePublicIdentifier);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this.state = State.DATA;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.publicId += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // After DOCTYPE public identifier state\n    //------------------------------------------------------------------\n    _stateAfterDoctypePublicIdentifier(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this.state = State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.DATA;\n                this.emitCurrentDoctype(token);\n                break;\n            }\n            case $.QUOTATION_MARK: {\n                this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);\n                token.systemId = '';\n                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;\n                break;\n            }\n            case $.APOSTROPHE: {\n                this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);\n                token.systemId = '';\n                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n                token.forceQuirks = true;\n                this.state = State.BOGUS_DOCTYPE;\n                this._stateBogusDoctype(cp);\n            }\n        }\n    }\n    // Between DOCTYPE public and system identifiers state\n    //------------------------------------------------------------------\n    _stateBetweenDoctypePublicAndSystemIdentifiers(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                // Ignore whitespace\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.emitCurrentDoctype(token);\n                this.state = State.DATA;\n                break;\n            }\n            case $.QUOTATION_MARK: {\n                token.systemId = '';\n                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;\n                break;\n            }\n            case $.APOSTROPHE: {\n                token.systemId = '';\n                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n                token.forceQuirks = true;\n                this.state = State.BOGUS_DOCTYPE;\n                this._stateBogusDoctype(cp);\n            }\n        }\n    }\n    // After DOCTYPE system keyword state\n    //------------------------------------------------------------------\n    _stateAfterDoctypeSystemKeyword(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                this.state = State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER;\n                break;\n            }\n            case $.QUOTATION_MARK: {\n                this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);\n                token.systemId = '';\n                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;\n                break;\n            }\n            case $.APOSTROPHE: {\n                this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);\n                token.systemId = '';\n                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.missingDoctypeSystemIdentifier);\n                token.forceQuirks = true;\n                this.state = State.DATA;\n                this.emitCurrentDoctype(token);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n                token.forceQuirks = true;\n                this.state = State.BOGUS_DOCTYPE;\n                this._stateBogusDoctype(cp);\n            }\n        }\n    }\n    // Before DOCTYPE system identifier state\n    //------------------------------------------------------------------\n    _stateBeforeDoctypeSystemIdentifier(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                // Ignore whitespace\n                break;\n            }\n            case $.QUOTATION_MARK: {\n                token.systemId = '';\n                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;\n                break;\n            }\n            case $.APOSTROPHE: {\n                token.systemId = '';\n                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.missingDoctypeSystemIdentifier);\n                token.forceQuirks = true;\n                this.state = State.DATA;\n                this.emitCurrentDoctype(token);\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n                token.forceQuirks = true;\n                this.state = State.BOGUS_DOCTYPE;\n                this._stateBogusDoctype(cp);\n            }\n        }\n    }\n    // DOCTYPE system identifier (double-quoted) state\n    //------------------------------------------------------------------\n    _stateDoctypeSystemIdentifierDoubleQuoted(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.QUOTATION_MARK: {\n                this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                token.systemId += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.abruptDoctypeSystemIdentifier);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this.state = State.DATA;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.systemId += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // DOCTYPE system identifier (single-quoted) state\n    //------------------------------------------------------------------\n    _stateDoctypeSystemIdentifierSingleQuoted(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.APOSTROPHE: {\n                this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                token.systemId += REPLACEMENT_CHARACTER;\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this._err(ERR.abruptDoctypeSystemIdentifier);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this.state = State.DATA;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                token.systemId += String.fromCodePoint(cp);\n            }\n        }\n    }\n    // After DOCTYPE system identifier state\n    //------------------------------------------------------------------\n    _stateAfterDoctypeSystemIdentifier(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.SPACE:\n            case $.LINE_FEED:\n            case $.TABULATION:\n            case $.FORM_FEED: {\n                // Ignore whitespace\n                break;\n            }\n            case $.GREATER_THAN_SIGN: {\n                this.emitCurrentDoctype(token);\n                this.state = State.DATA;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInDoctype);\n                token.forceQuirks = true;\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);\n                this.state = State.BOGUS_DOCTYPE;\n                this._stateBogusDoctype(cp);\n            }\n        }\n    }\n    // Bogus DOCTYPE state\n    //------------------------------------------------------------------\n    _stateBogusDoctype(cp) {\n        const token = this.currentToken;\n        switch (cp) {\n            case $.GREATER_THAN_SIGN: {\n                this.emitCurrentDoctype(token);\n                this.state = State.DATA;\n                break;\n            }\n            case $.NULL: {\n                this._err(ERR.unexpectedNullCharacter);\n                break;\n            }\n            case $.EOF: {\n                this.emitCurrentDoctype(token);\n                this._emitEOFToken();\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    // CDATA section state\n    //------------------------------------------------------------------\n    _stateCdataSection(cp) {\n        switch (cp) {\n            case $.RIGHT_SQUARE_BRACKET: {\n                this.state = State.CDATA_SECTION_BRACKET;\n                break;\n            }\n            case $.EOF: {\n                this._err(ERR.eofInCdata);\n                this._emitEOFToken();\n                break;\n            }\n            default: {\n                this._emitCodePoint(cp);\n            }\n        }\n    }\n    // CDATA section bracket state\n    //------------------------------------------------------------------\n    _stateCdataSectionBracket(cp) {\n        if (cp === $.RIGHT_SQUARE_BRACKET) {\n            this.state = State.CDATA_SECTION_END;\n        }\n        else {\n            this._emitChars(']');\n            this.state = State.CDATA_SECTION;\n            this._stateCdataSection(cp);\n        }\n    }\n    // CDATA section end state\n    //------------------------------------------------------------------\n    _stateCdataSectionEnd(cp) {\n        switch (cp) {\n            case $.GREATER_THAN_SIGN: {\n                this.state = State.DATA;\n                break;\n            }\n            case $.RIGHT_SQUARE_BRACKET: {\n                this._emitChars(']');\n                break;\n            }\n            default: {\n                this._emitChars(']]');\n                this.state = State.CDATA_SECTION;\n                this._stateCdataSection(cp);\n            }\n        }\n    }\n    // Character reference state\n    //------------------------------------------------------------------\n    _stateCharacterReference(cp) {\n        if (cp === $.NUMBER_SIGN) {\n            this.state = State.NUMERIC_CHARACTER_REFERENCE;\n        }\n        else if (isAsciiAlphaNumeric(cp)) {\n            this.state = State.NAMED_CHARACTER_REFERENCE;\n            this._stateNamedCharacterReference(cp);\n        }\n        else {\n            this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);\n            this._reconsumeInState(this.returnState, cp);\n        }\n    }\n    // Named character reference state\n    //------------------------------------------------------------------\n    _stateNamedCharacterReference(cp) {\n        const matchResult = this._matchNamedCharacterReference(cp);\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            // Stay in the state, try again.\n        }\n        else if (matchResult) {\n            for (let i = 0; i < matchResult.length; i++) {\n                this._flushCodePointConsumedAsCharacterReference(matchResult[i]);\n            }\n            this.state = this.returnState;\n        }\n        else {\n            this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);\n            this.state = State.AMBIGUOUS_AMPERSAND;\n        }\n    }\n    // Ambiguos ampersand state\n    //------------------------------------------------------------------\n    _stateAmbiguousAmpersand(cp) {\n        if (isAsciiAlphaNumeric(cp)) {\n            this._flushCodePointConsumedAsCharacterReference(cp);\n        }\n        else {\n            if (cp === $.SEMICOLON) {\n                this._err(ERR.unknownNamedCharacterReference);\n            }\n            this._reconsumeInState(this.returnState, cp);\n        }\n    }\n    // Numeric character reference state\n    //------------------------------------------------------------------\n    _stateNumericCharacterReference(cp) {\n        this.charRefCode = 0;\n        if (cp === $.LATIN_SMALL_X || cp === $.LATIN_CAPITAL_X) {\n            this.state = State.HEXADEMICAL_CHARACTER_REFERENCE_START;\n        }\n        // Inlined decimal character reference start state\n        else if (isAsciiDigit(cp)) {\n            this.state = State.DECIMAL_CHARACTER_REFERENCE;\n            this._stateDecimalCharacterReference(cp);\n        }\n        else {\n            this._err(ERR.absenceOfDigitsInNumericCharacterReference);\n            this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);\n            this._flushCodePointConsumedAsCharacterReference($.NUMBER_SIGN);\n            this._reconsumeInState(this.returnState, cp);\n        }\n    }\n    // Hexademical character reference start state\n    //------------------------------------------------------------------\n    _stateHexademicalCharacterReferenceStart(cp) {\n        if (isAsciiHexDigit(cp)) {\n            this.state = State.HEXADEMICAL_CHARACTER_REFERENCE;\n            this._stateHexademicalCharacterReference(cp);\n        }\n        else {\n            this._err(ERR.absenceOfDigitsInNumericCharacterReference);\n            this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);\n            this._flushCodePointConsumedAsCharacterReference($.NUMBER_SIGN);\n            this._unconsume(2);\n            this.state = this.returnState;\n        }\n    }\n    // Hexademical character reference state\n    //------------------------------------------------------------------\n    _stateHexademicalCharacterReference(cp) {\n        if (isAsciiUpperHexDigit(cp)) {\n            this.charRefCode = this.charRefCode * 16 + cp - 0x37;\n        }\n        else if (isAsciiLowerHexDigit(cp)) {\n            this.charRefCode = this.charRefCode * 16 + cp - 0x57;\n        }\n        else if (isAsciiDigit(cp)) {\n            this.charRefCode = this.charRefCode * 16 + cp - 0x30;\n        }\n        else if (cp === $.SEMICOLON) {\n            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;\n        }\n        else {\n            this._err(ERR.missingSemicolonAfterCharacterReference);\n            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;\n            this._stateNumericCharacterReferenceEnd(cp);\n        }\n    }\n    // Decimal character reference state\n    //------------------------------------------------------------------\n    _stateDecimalCharacterReference(cp) {\n        if (isAsciiDigit(cp)) {\n            this.charRefCode = this.charRefCode * 10 + cp - 0x30;\n        }\n        else if (cp === $.SEMICOLON) {\n            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;\n        }\n        else {\n            this._err(ERR.missingSemicolonAfterCharacterReference);\n            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;\n            this._stateNumericCharacterReferenceEnd(cp);\n        }\n    }\n    // Numeric character reference end state\n    //------------------------------------------------------------------\n    _stateNumericCharacterReferenceEnd(cp) {\n        if (this.charRefCode === $.NULL) {\n            this._err(ERR.nullCharacterReference);\n            this.charRefCode = $.REPLACEMENT_CHARACTER;\n        }\n        else if (this.charRefCode > 1114111) {\n            this._err(ERR.characterReferenceOutsideUnicodeRange);\n            this.charRefCode = $.REPLACEMENT_CHARACTER;\n        }\n        else if (isSurrogate(this.charRefCode)) {\n            this._err(ERR.surrogateCharacterReference);\n            this.charRefCode = $.REPLACEMENT_CHARACTER;\n        }\n        else if (isUndefinedCodePoint(this.charRefCode)) {\n            this._err(ERR.noncharacterCharacterReference);\n        }\n        else if (isControlCodePoint(this.charRefCode) || this.charRefCode === $.CARRIAGE_RETURN) {\n            this._err(ERR.controlCharacterReference);\n            const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS.get(this.charRefCode);\n            if (replacement !== undefined) {\n                this.charRefCode = replacement;\n            }\n        }\n        this._flushCodePointConsumedAsCharacterReference(this.charRefCode);\n        this._reconsumeInState(this.returnState, cp);\n    }\n}\n//# sourceMappingURL=index.js.map","import { TAG_ID as $, NS, isNumberedHeader } from '../common/html.js';\n//Element utils\nconst IMPLICIT_END_TAG_REQUIRED = new Set([$.DD, $.DT, $.LI, $.OPTGROUP, $.OPTION, $.P, $.RB, $.RP, $.RT, $.RTC]);\nconst IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([\n    ...IMPLICIT_END_TAG_REQUIRED,\n    $.CAPTION,\n    $.COLGROUP,\n    $.TBODY,\n    $.TD,\n    $.TFOOT,\n    $.TH,\n    $.THEAD,\n    $.TR,\n]);\nconst SCOPING_ELEMENT_NS = new Map([\n    [$.APPLET, NS.HTML],\n    [$.CAPTION, NS.HTML],\n    [$.HTML, NS.HTML],\n    [$.MARQUEE, NS.HTML],\n    [$.OBJECT, NS.HTML],\n    [$.TABLE, NS.HTML],\n    [$.TD, NS.HTML],\n    [$.TEMPLATE, NS.HTML],\n    [$.TH, NS.HTML],\n    [$.ANNOTATION_XML, NS.MATHML],\n    [$.MI, NS.MATHML],\n    [$.MN, NS.MATHML],\n    [$.MO, NS.MATHML],\n    [$.MS, NS.MATHML],\n    [$.MTEXT, NS.MATHML],\n    [$.DESC, NS.SVG],\n    [$.FOREIGN_OBJECT, NS.SVG],\n    [$.TITLE, NS.SVG],\n]);\nconst NAMED_HEADERS = [$.H1, $.H2, $.H3, $.H4, $.H5, $.H6];\nconst TABLE_ROW_CONTEXT = [$.TR, $.TEMPLATE, $.HTML];\nconst TABLE_BODY_CONTEXT = [$.TBODY, $.TFOOT, $.THEAD, $.TEMPLATE, $.HTML];\nconst TABLE_CONTEXT = [$.TABLE, $.TEMPLATE, $.HTML];\nconst TABLE_CELLS = [$.TD, $.TH];\n//Stack of open elements\nexport class OpenElementStack {\n    get currentTmplContentOrNode() {\n        return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current;\n    }\n    constructor(document, treeAdapter, handler) {\n        this.treeAdapter = treeAdapter;\n        this.handler = handler;\n        this.items = [];\n        this.tagIDs = [];\n        this.stackTop = -1;\n        this.tmplCount = 0;\n        this.currentTagId = $.UNKNOWN;\n        this.current = document;\n    }\n    //Index of element\n    _indexOf(element) {\n        return this.items.lastIndexOf(element, this.stackTop);\n    }\n    //Update current element\n    _isInTemplate() {\n        return this.currentTagId === $.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;\n    }\n    _updateCurrentElement() {\n        this.current = this.items[this.stackTop];\n        this.currentTagId = this.tagIDs[this.stackTop];\n    }\n    //Mutations\n    push(element, tagID) {\n        this.stackTop++;\n        this.items[this.stackTop] = element;\n        this.current = element;\n        this.tagIDs[this.stackTop] = tagID;\n        this.currentTagId = tagID;\n        if (this._isInTemplate()) {\n            this.tmplCount++;\n        }\n        this.handler.onItemPush(element, tagID, true);\n    }\n    pop() {\n        const popped = this.current;\n        if (this.tmplCount > 0 && this._isInTemplate()) {\n            this.tmplCount--;\n        }\n        this.stackTop--;\n        this._updateCurrentElement();\n        this.handler.onItemPop(popped, true);\n    }\n    replace(oldElement, newElement) {\n        const idx = this._indexOf(oldElement);\n        this.items[idx] = newElement;\n        if (idx === this.stackTop) {\n            this.current = newElement;\n        }\n    }\n    insertAfter(referenceElement, newElement, newElementID) {\n        const insertionIdx = this._indexOf(referenceElement) + 1;\n        this.items.splice(insertionIdx, 0, newElement);\n        this.tagIDs.splice(insertionIdx, 0, newElementID);\n        this.stackTop++;\n        if (insertionIdx === this.stackTop) {\n            this._updateCurrentElement();\n        }\n        this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop);\n    }\n    popUntilTagNamePopped(tagName) {\n        let targetIdx = this.stackTop + 1;\n        do {\n            targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1);\n        } while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== NS.HTML);\n        this.shortenToLength(targetIdx < 0 ? 0 : targetIdx);\n    }\n    shortenToLength(idx) {\n        while (this.stackTop >= idx) {\n            const popped = this.current;\n            if (this.tmplCount > 0 && this._isInTemplate()) {\n                this.tmplCount -= 1;\n            }\n            this.stackTop--;\n            this._updateCurrentElement();\n            this.handler.onItemPop(popped, this.stackTop < idx);\n        }\n    }\n    popUntilElementPopped(element) {\n        const idx = this._indexOf(element);\n        this.shortenToLength(idx < 0 ? 0 : idx);\n    }\n    popUntilPopped(tagNames, targetNS) {\n        const idx = this._indexOfTagNames(tagNames, targetNS);\n        this.shortenToLength(idx < 0 ? 0 : idx);\n    }\n    popUntilNumberedHeaderPopped() {\n        this.popUntilPopped(NAMED_HEADERS, NS.HTML);\n    }\n    popUntilTableCellPopped() {\n        this.popUntilPopped(TABLE_CELLS, NS.HTML);\n    }\n    popAllUpToHtmlElement() {\n        //NOTE: here we assume that the root <html> element is always first in the open element stack, so\n        //we perform this fast stack clean up.\n        this.tmplCount = 0;\n        this.shortenToLength(1);\n    }\n    _indexOfTagNames(tagNames, namespace) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            if (tagNames.includes(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) {\n                return i;\n            }\n        }\n        return -1;\n    }\n    clearBackTo(tagNames, targetNS) {\n        const idx = this._indexOfTagNames(tagNames, targetNS);\n        this.shortenToLength(idx + 1);\n    }\n    clearBackToTableContext() {\n        this.clearBackTo(TABLE_CONTEXT, NS.HTML);\n    }\n    clearBackToTableBodyContext() {\n        this.clearBackTo(TABLE_BODY_CONTEXT, NS.HTML);\n    }\n    clearBackToTableRowContext() {\n        this.clearBackTo(TABLE_ROW_CONTEXT, NS.HTML);\n    }\n    remove(element) {\n        const idx = this._indexOf(element);\n        if (idx >= 0) {\n            if (idx === this.stackTop) {\n                this.pop();\n            }\n            else {\n                this.items.splice(idx, 1);\n                this.tagIDs.splice(idx, 1);\n                this.stackTop--;\n                this._updateCurrentElement();\n                this.handler.onItemPop(element, false);\n            }\n        }\n    }\n    //Search\n    tryPeekProperlyNestedBodyElement() {\n        //Properly nested <body> element (should be second element in stack).\n        return this.stackTop >= 1 && this.tagIDs[1] === $.BODY ? this.items[1] : null;\n    }\n    contains(element) {\n        return this._indexOf(element) > -1;\n    }\n    getCommonAncestor(element) {\n        const elementIdx = this._indexOf(element) - 1;\n        return elementIdx >= 0 ? this.items[elementIdx] : null;\n    }\n    isRootHtmlElementCurrent() {\n        return this.stackTop === 0 && this.tagIDs[0] === $.HTML;\n    }\n    //Element in scope\n    hasInScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.tagIDs[i];\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n            if (tn === tagName && ns === NS.HTML) {\n                return true;\n            }\n            if (SCOPING_ELEMENT_NS.get(tn) === ns) {\n                return false;\n            }\n        }\n        return true;\n    }\n    hasNumberedHeaderInScope() {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.tagIDs[i];\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n            if (isNumberedHeader(tn) && ns === NS.HTML) {\n                return true;\n            }\n            if (SCOPING_ELEMENT_NS.get(tn) === ns) {\n                return false;\n            }\n        }\n        return true;\n    }\n    hasInListItemScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.tagIDs[i];\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n            if (tn === tagName && ns === NS.HTML) {\n                return true;\n            }\n            if (((tn === $.UL || tn === $.OL) && ns === NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) {\n                return false;\n            }\n        }\n        return true;\n    }\n    hasInButtonScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.tagIDs[i];\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n            if (tn === tagName && ns === NS.HTML) {\n                return true;\n            }\n            if ((tn === $.BUTTON && ns === NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) {\n                return false;\n            }\n        }\n        return true;\n    }\n    hasInTableScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.tagIDs[i];\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n            if (ns !== NS.HTML) {\n                continue;\n            }\n            if (tn === tagName) {\n                return true;\n            }\n            if (tn === $.TABLE || tn === $.TEMPLATE || tn === $.HTML) {\n                return false;\n            }\n        }\n        return true;\n    }\n    hasTableBodyContextInTableScope() {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.tagIDs[i];\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n            if (ns !== NS.HTML) {\n                continue;\n            }\n            if (tn === $.TBODY || tn === $.THEAD || tn === $.TFOOT) {\n                return true;\n            }\n            if (tn === $.TABLE || tn === $.HTML) {\n                return false;\n            }\n        }\n        return true;\n    }\n    hasInSelectScope(tagName) {\n        for (let i = this.stackTop; i >= 0; i--) {\n            const tn = this.tagIDs[i];\n            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n            if (ns !== NS.HTML) {\n                continue;\n            }\n            if (tn === tagName) {\n                return true;\n            }\n            if (tn !== $.OPTION && tn !== $.OPTGROUP) {\n                return false;\n            }\n        }\n        return true;\n    }\n    //Implied end tags\n    generateImpliedEndTags() {\n        while (IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) {\n            this.pop();\n        }\n    }\n    generateImpliedEndTagsThoroughly() {\n        while (IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {\n            this.pop();\n        }\n    }\n    generateImpliedEndTagsWithExclusion(exclusionId) {\n        while (this.currentTagId !== exclusionId && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {\n            this.pop();\n        }\n    }\n}\n//# sourceMappingURL=open-element-stack.js.map","//Const\nconst NOAH_ARK_CAPACITY = 3;\nexport var EntryType;\n(function (EntryType) {\n    EntryType[EntryType[\"Marker\"] = 0] = \"Marker\";\n    EntryType[EntryType[\"Element\"] = 1] = \"Element\";\n})(EntryType = EntryType || (EntryType = {}));\nconst MARKER = { type: EntryType.Marker };\n//List of formatting elements\nexport class FormattingElementList {\n    constructor(treeAdapter) {\n        this.treeAdapter = treeAdapter;\n        this.entries = [];\n        this.bookmark = null;\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, neAttrs) {\n        const candidates = [];\n        const neAttrsLength = neAttrs.length;\n        const neTagName = this.treeAdapter.getTagName(newElement);\n        const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);\n        for (let i = 0; i < this.entries.length; i++) {\n            const entry = this.entries[i];\n            if (entry.type === EntryType.Marker) {\n                break;\n            }\n            const { element } = entry;\n            if (this.treeAdapter.getTagName(element) === neTagName &&\n                this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) {\n                const elementAttrs = this.treeAdapter.getAttrList(element);\n                if (elementAttrs.length === neAttrsLength) {\n                    candidates.push({ idx: i, attrs: elementAttrs });\n                }\n            }\n        }\n        return candidates;\n    }\n    _ensureNoahArkCondition(newElement) {\n        if (this.entries.length < NOAH_ARK_CAPACITY)\n            return;\n        const neAttrs = this.treeAdapter.getAttrList(newElement);\n        const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs);\n        if (candidates.length < NOAH_ARK_CAPACITY)\n            return;\n        //NOTE: build attrs map for the new element, so we can perform fast lookups\n        const neAttrsMap = new Map(neAttrs.map((neAttr) => [neAttr.name, neAttr.value]));\n        let validCandidates = 0;\n        //NOTE: remove bottommost candidates, until Noah's Ark condition will not be met\n        for (let i = 0; i < candidates.length; i++) {\n            const candidate = candidates[i];\n            // We know that `candidate.attrs.length === neAttrs.length`\n            if (candidate.attrs.every((cAttr) => neAttrsMap.get(cAttr.name) === cAttr.value)) {\n                validCandidates += 1;\n                if (validCandidates >= NOAH_ARK_CAPACITY) {\n                    this.entries.splice(candidate.idx, 1);\n                }\n            }\n        }\n    }\n    //Mutations\n    insertMarker() {\n        this.entries.unshift(MARKER);\n    }\n    pushElement(element, token) {\n        this._ensureNoahArkCondition(element);\n        this.entries.unshift({\n            type: EntryType.Element,\n            element,\n            token,\n        });\n    }\n    insertElementAfterBookmark(element, token) {\n        const bookmarkIdx = this.entries.indexOf(this.bookmark);\n        this.entries.splice(bookmarkIdx, 0, {\n            type: EntryType.Element,\n            element,\n            token,\n        });\n    }\n    removeEntry(entry) {\n        const entryIndex = this.entries.indexOf(entry);\n        if (entryIndex >= 0) {\n            this.entries.splice(entryIndex, 1);\n        }\n    }\n    /**\n     * Clears the list of formatting elements up to the last marker.\n     *\n     * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker\n     */\n    clearToLastMarker() {\n        const markerIdx = this.entries.indexOf(MARKER);\n        if (markerIdx >= 0) {\n            this.entries.splice(0, markerIdx + 1);\n        }\n        else {\n            this.entries.length = 0;\n        }\n    }\n    //Search\n    getElementEntryInScopeWithTagName(tagName) {\n        const entry = this.entries.find((entry) => entry.type === EntryType.Marker || this.treeAdapter.getTagName(entry.element) === tagName);\n        return entry && entry.type === EntryType.Element ? entry : null;\n    }\n    getElementEntry(element) {\n        return this.entries.find((entry) => entry.type === EntryType.Element && entry.element === element);\n    }\n}\n//# sourceMappingURL=formatting-element-list.js.map","import { DOCUMENT_MODE } from '../common/html.js';\nfunction createTextNode(value) {\n    return {\n        nodeName: '#text',\n        value,\n        parentNode: null,\n    };\n}\nexport const defaultTreeAdapter = {\n    //Node construction\n    createDocument() {\n        return {\n            nodeName: '#document',\n            mode: DOCUMENT_MODE.NO_QUIRKS,\n            childNodes: [],\n        };\n    },\n    createDocumentFragment() {\n        return {\n            nodeName: '#document-fragment',\n            childNodes: [],\n        };\n    },\n    createElement(tagName, namespaceURI, attrs) {\n        return {\n            nodeName: tagName,\n            tagName,\n            attrs,\n            namespaceURI,\n            childNodes: [],\n            parentNode: null,\n        };\n    },\n    createCommentNode(data) {\n        return {\n            nodeName: '#comment',\n            data,\n            parentNode: null,\n        };\n    },\n    //Tree mutation\n    appendChild(parentNode, newNode) {\n        parentNode.childNodes.push(newNode);\n        newNode.parentNode = parentNode;\n    },\n    insertBefore(parentNode, newNode, referenceNode) {\n        const insertionIdx = parentNode.childNodes.indexOf(referenceNode);\n        parentNode.childNodes.splice(insertionIdx, 0, newNode);\n        newNode.parentNode = parentNode;\n    },\n    setTemplateContent(templateElement, contentElement) {\n        templateElement.content = contentElement;\n    },\n    getTemplateContent(templateElement) {\n        return templateElement.content;\n    },\n    setDocumentType(document, name, publicId, systemId) {\n        const doctypeNode = document.childNodes.find((node) => node.nodeName === '#documentType');\n        if (doctypeNode) {\n            doctypeNode.name = name;\n            doctypeNode.publicId = publicId;\n            doctypeNode.systemId = systemId;\n        }\n        else {\n            const node = {\n                nodeName: '#documentType',\n                name,\n                publicId,\n                systemId,\n                parentNode: null,\n            };\n            defaultTreeAdapter.appendChild(document, node);\n        }\n    },\n    setDocumentMode(document, mode) {\n        document.mode = mode;\n    },\n    getDocumentMode(document) {\n        return document.mode;\n    },\n    detachNode(node) {\n        if (node.parentNode) {\n            const idx = node.parentNode.childNodes.indexOf(node);\n            node.parentNode.childNodes.splice(idx, 1);\n            node.parentNode = null;\n        }\n    },\n    insertText(parentNode, text) {\n        if (parentNode.childNodes.length > 0) {\n            const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];\n            if (defaultTreeAdapter.isTextNode(prevNode)) {\n                prevNode.value += text;\n                return;\n            }\n        }\n        defaultTreeAdapter.appendChild(parentNode, createTextNode(text));\n    },\n    insertTextBefore(parentNode, text, referenceNode) {\n        const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];\n        if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) {\n            prevNode.value += text;\n        }\n        else {\n            defaultTreeAdapter.insertBefore(parentNode, createTextNode(text), referenceNode);\n        }\n    },\n    adoptAttributes(recipient, attrs) {\n        const recipientAttrsMap = new Set(recipient.attrs.map((attr) => attr.name));\n        for (let j = 0; j < attrs.length; j++) {\n            if (!recipientAttrsMap.has(attrs[j].name)) {\n                recipient.attrs.push(attrs[j]);\n            }\n        }\n    },\n    //Tree traversing\n    getFirstChild(node) {\n        return node.childNodes[0];\n    },\n    getChildNodes(node) {\n        return node.childNodes;\n    },\n    getParentNode(node) {\n        return node.parentNode;\n    },\n    getAttrList(element) {\n        return element.attrs;\n    },\n    //Node data\n    getTagName(element) {\n        return element.tagName;\n    },\n    getNamespaceURI(element) {\n        return element.namespaceURI;\n    },\n    getTextNodeContent(textNode) {\n        return textNode.value;\n    },\n    getCommentNodeContent(commentNode) {\n        return commentNode.data;\n    },\n    getDocumentTypeNodeName(doctypeNode) {\n        return doctypeNode.name;\n    },\n    getDocumentTypeNodePublicId(doctypeNode) {\n        return doctypeNode.publicId;\n    },\n    getDocumentTypeNodeSystemId(doctypeNode) {\n        return doctypeNode.systemId;\n    },\n    //Node types\n    isTextNode(node) {\n        return node.nodeName === '#text';\n    },\n    isCommentNode(node) {\n        return node.nodeName === '#comment';\n    },\n    isDocumentTypeNode(node) {\n        return node.nodeName === '#documentType';\n    },\n    isElementNode(node) {\n        return Object.prototype.hasOwnProperty.call(node, 'tagName');\n    },\n    // Source code location\n    setNodeSourceCodeLocation(node, location) {\n        node.sourceCodeLocation = location;\n    },\n    getNodeSourceCodeLocation(node) {\n        return node.sourceCodeLocation;\n    },\n    updateNodeSourceCodeLocation(node, endLocation) {\n        node.sourceCodeLocation = { ...node.sourceCodeLocation, ...endLocation };\n    },\n};\n//# sourceMappingURL=default.js.map","import { DOCUMENT_MODE } from './html.js';\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';\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];\nconst QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = [\n    ...QUIRKS_MODE_PUBLIC_ID_PREFIXES,\n    '-//w3c//dtd html 4.01 frameset//',\n    '-//w3c//dtd html 4.01 transitional//',\n];\nconst QUIRKS_MODE_PUBLIC_IDS = new Set([\n    '-//w3o//dtd w3 html strict 3.0//en//',\n    '-/w3c/dtd html 4.0 transitional/en',\n    'html',\n]);\nconst LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ['-//w3c//dtd xhtml 1.0 frameset//', '-//w3c//dtd xhtml 1.0 transitional//'];\nconst LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = [\n    ...LIMITED_QUIRKS_PUBLIC_ID_PREFIXES,\n    '-//w3c//dtd html 4.01 frameset//',\n    '-//w3c//dtd html 4.01 transitional//',\n];\n//Utils\nfunction hasPrefix(publicId, prefixes) {\n    return prefixes.some((prefix) => publicId.startsWith(prefix));\n}\n//API\nexport function isConforming(token) {\n    return (token.name === VALID_DOCTYPE_NAME &&\n        token.publicId === null &&\n        (token.systemId === null || token.systemId === VALID_SYSTEM_ID));\n}\nexport function getDocumentMode(token) {\n    if (token.name !== VALID_DOCTYPE_NAME) {\n        return DOCUMENT_MODE.QUIRKS;\n    }\n    const { systemId } = token;\n    if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) {\n        return DOCUMENT_MODE.QUIRKS;\n    }\n    let { publicId } = token;\n    if (publicId !== null) {\n        publicId = publicId.toLowerCase();\n        if (QUIRKS_MODE_PUBLIC_IDS.has(publicId)) {\n            return DOCUMENT_MODE.QUIRKS;\n        }\n        let prefixes = systemId === null ? QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES : QUIRKS_MODE_PUBLIC_ID_PREFIXES;\n        if (hasPrefix(publicId, prefixes)) {\n            return DOCUMENT_MODE.QUIRKS;\n        }\n        prefixes =\n            systemId === null ? LIMITED_QUIRKS_PUBLIC_ID_PREFIXES : LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES;\n        if (hasPrefix(publicId, prefixes)) {\n            return DOCUMENT_MODE.LIMITED_QUIRKS;\n        }\n    }\n    return DOCUMENT_MODE.NO_QUIRKS;\n}\n//# sourceMappingURL=doctype.js.map","import { TAG_ID as $, NS, ATTRS, getTagID } from './html.js';\n//MIME types\nconst MIME_TYPES = {\n    TEXT_HTML: 'text/html',\n    APPLICATION_XML: 'application/xhtml+xml',\n};\n//Attributes\nconst DEFINITION_URL_ATTR = 'definitionurl';\nconst ADJUSTED_DEFINITION_URL_ATTR = 'definitionURL';\nconst SVG_ATTRS_ADJUSTMENT_MAP = new Map([\n    'attributeName',\n    'attributeType',\n    'baseFrequency',\n    'baseProfile',\n    'calcMode',\n    'clipPathUnits',\n    'diffuseConstant',\n    'edgeMode',\n    'filterUnits',\n    'glyphRef',\n    'gradientTransform',\n    'gradientUnits',\n    'kernelMatrix',\n    'kernelUnitLength',\n    'keyPoints',\n    'keySplines',\n    'keyTimes',\n    'lengthAdjust',\n    'limitingConeAngle',\n    'markerHeight',\n    'markerUnits',\n    'markerWidth',\n    'maskContentUnits',\n    'maskUnits',\n    'numOctaves',\n    'pathLength',\n    'patternContentUnits',\n    'patternTransform',\n    'patternUnits',\n    'pointsAtX',\n    'pointsAtY',\n    'pointsAtZ',\n    'preserveAlpha',\n    'preserveAspectRatio',\n    'primitiveUnits',\n    'refX',\n    'refY',\n    'repeatCount',\n    'repeatDur',\n    'requiredExtensions',\n    'requiredFeatures',\n    'specularConstant',\n    'specularExponent',\n    'spreadMethod',\n    'startOffset',\n    'stdDeviation',\n    'stitchTiles',\n    'surfaceScale',\n    'systemLanguage',\n    'tableValues',\n    'targetX',\n    'targetY',\n    'textLength',\n    'viewBox',\n    'viewTarget',\n    'xChannelSelector',\n    'yChannelSelector',\n    'zoomAndPan',\n].map((attr) => [attr.toLowerCase(), attr]));\nconst XML_ATTRS_ADJUSTMENT_MAP = new 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//SVG tag names adjustment map\nexport const SVG_TAG_NAMES_ADJUSTMENT_MAP = new Map([\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    '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    'textPath',\n].map((tn) => [tn.toLowerCase(), tn]));\n//Tags that causes exit from foreign content\nconst EXITS_FOREIGN_CONTENT = new Set([\n    $.B,\n    $.BIG,\n    $.BLOCKQUOTE,\n    $.BODY,\n    $.BR,\n    $.CENTER,\n    $.CODE,\n    $.DD,\n    $.DIV,\n    $.DL,\n    $.DT,\n    $.EM,\n    $.EMBED,\n    $.H1,\n    $.H2,\n    $.H3,\n    $.H4,\n    $.H5,\n    $.H6,\n    $.HEAD,\n    $.HR,\n    $.I,\n    $.IMG,\n    $.LI,\n    $.LISTING,\n    $.MENU,\n    $.META,\n    $.NOBR,\n    $.OL,\n    $.P,\n    $.PRE,\n    $.RUBY,\n    $.S,\n    $.SMALL,\n    $.SPAN,\n    $.STRONG,\n    $.STRIKE,\n    $.SUB,\n    $.SUP,\n    $.TABLE,\n    $.TT,\n    $.U,\n    $.UL,\n    $.VAR,\n]);\n//Check exit from foreign content\nexport function causesExit(startTagToken) {\n    const tn = startTagToken.tagID;\n    const isFontWithAttrs = tn === $.FONT &&\n        startTagToken.attrs.some(({ name }) => name === ATTRS.COLOR || name === ATTRS.SIZE || name === ATTRS.FACE);\n    return isFontWithAttrs || EXITS_FOREIGN_CONTENT.has(tn);\n}\n//Token adjustments\nexport function adjustTokenMathMLAttrs(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}\nexport function adjustTokenSVGAttrs(token) {\n    for (let i = 0; i < token.attrs.length; i++) {\n        const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name);\n        if (adjustedAttrName != null) {\n            token.attrs[i].name = adjustedAttrName;\n        }\n    }\n}\nexport function adjustTokenXMLAttrs(token) {\n    for (let i = 0; i < token.attrs.length; i++) {\n        const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name);\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}\nexport function adjustTokenSVGTagName(token) {\n    const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP.get(token.tagName);\n    if (adjustedTagName != null) {\n        token.tagName = adjustedTagName;\n        token.tagID = getTagID(token.tagName);\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}\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                return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML;\n            }\n        }\n    }\n    return ns === NS.SVG && (tn === $.FOREIGN_OBJECT || tn === $.DESC || tn === $.TITLE);\n}\nexport function isIntegrationPoint(tn, ns, attrs, foreignNS) {\n    return (((!foreignNS || foreignNS === NS.HTML) && isHtmlIntegrationPoint(tn, ns, attrs)) ||\n        ((!foreignNS || foreignNS === NS.MATHML) && isMathMLTextIntegrationPoint(tn, ns)));\n}\n//# sourceMappingURL=foreign-content.js.map","import { Tokenizer, TokenizerMode } from '../tokenizer/index.js';\nimport { OpenElementStack } from './open-element-stack.js';\nimport { FormattingElementList, EntryType } from './formatting-element-list.js';\nimport { defaultTreeAdapter } from '../tree-adapters/default.js';\nimport * as doctype from '../common/doctype.js';\nimport * as foreignContent from '../common/foreign-content.js';\nimport { ERR } from '../common/error-codes.js';\nimport * as unicode from '../common/unicode.js';\nimport { TAG_ID as $, TAG_NAMES as TN, NS, ATTRS, SPECIAL_ELEMENTS, DOCUMENT_MODE, isNumberedHeader, getTagID, } from '../common/html.js';\nimport { TokenType, getTokenAttr, } from '../common/token.js';\n//Misc constants\nconst HIDDEN_INPUT_TYPE = 'hidden';\n//Adoption agency loops iteration count\nconst AA_OUTER_LOOP_ITER = 8;\nconst AA_INNER_LOOP_ITER = 3;\n//Insertion modes\nvar InsertionMode;\n(function (InsertionMode) {\n    InsertionMode[InsertionMode[\"INITIAL\"] = 0] = \"INITIAL\";\n    InsertionMode[InsertionMode[\"BEFORE_HTML\"] = 1] = \"BEFORE_HTML\";\n    InsertionMode[InsertionMode[\"BEFORE_HEAD\"] = 2] = \"BEFORE_HEAD\";\n    InsertionMode[InsertionMode[\"IN_HEAD\"] = 3] = \"IN_HEAD\";\n    InsertionMode[InsertionMode[\"IN_HEAD_NO_SCRIPT\"] = 4] = \"IN_HEAD_NO_SCRIPT\";\n    InsertionMode[InsertionMode[\"AFTER_HEAD\"] = 5] = \"AFTER_HEAD\";\n    InsertionMode[InsertionMode[\"IN_BODY\"] = 6] = \"IN_BODY\";\n    InsertionMode[InsertionMode[\"TEXT\"] = 7] = \"TEXT\";\n    InsertionMode[InsertionMode[\"IN_TABLE\"] = 8] = \"IN_TABLE\";\n    InsertionMode[InsertionMode[\"IN_TABLE_TEXT\"] = 9] = \"IN_TABLE_TEXT\";\n    InsertionMode[InsertionMode[\"IN_CAPTION\"] = 10] = \"IN_CAPTION\";\n    InsertionMode[InsertionMode[\"IN_COLUMN_GROUP\"] = 11] = \"IN_COLUMN_GROUP\";\n    InsertionMode[InsertionMode[\"IN_TABLE_BODY\"] = 12] = \"IN_TABLE_BODY\";\n    InsertionMode[InsertionMode[\"IN_ROW\"] = 13] = \"IN_ROW\";\n    InsertionMode[InsertionMode[\"IN_CELL\"] = 14] = \"IN_CELL\";\n    InsertionMode[InsertionMode[\"IN_SELECT\"] = 15] = \"IN_SELECT\";\n    InsertionMode[InsertionMode[\"IN_SELECT_IN_TABLE\"] = 16] = \"IN_SELECT_IN_TABLE\";\n    InsertionMode[InsertionMode[\"IN_TEMPLATE\"] = 17] = \"IN_TEMPLATE\";\n    InsertionMode[InsertionMode[\"AFTER_BODY\"] = 18] = \"AFTER_BODY\";\n    InsertionMode[InsertionMode[\"IN_FRAMESET\"] = 19] = \"IN_FRAMESET\";\n    InsertionMode[InsertionMode[\"AFTER_FRAMESET\"] = 20] = \"AFTER_FRAMESET\";\n    InsertionMode[InsertionMode[\"AFTER_AFTER_BODY\"] = 21] = \"AFTER_AFTER_BODY\";\n    InsertionMode[InsertionMode[\"AFTER_AFTER_FRAMESET\"] = 22] = \"AFTER_AFTER_FRAMESET\";\n})(InsertionMode || (InsertionMode = {}));\nconst BASE_LOC = {\n    startLine: -1,\n    startCol: -1,\n    startOffset: -1,\n    endLine: -1,\n    endCol: -1,\n    endOffset: -1,\n};\nconst TABLE_STRUCTURE_TAGS = new Set([$.TABLE, $.TBODY, $.TFOOT, $.THEAD, $.TR]);\nconst defaultParserOptions = {\n    scriptingEnabled: true,\n    sourceCodeLocationInfo: false,\n    treeAdapter: defaultTreeAdapter,\n    onParseError: null,\n};\n//Parser\nexport class Parser {\n    constructor(options, document, fragmentContext = null, scriptHandler = null) {\n        this.fragmentContext = fragmentContext;\n        this.scriptHandler = scriptHandler;\n        this.currentToken = null;\n        this.stopped = false;\n        this.insertionMode = InsertionMode.INITIAL;\n        this.originalInsertionMode = InsertionMode.INITIAL;\n        this.headElement = null;\n        this.formElement = null;\n        /** Indicates that the current node is not an element in the HTML namespace */\n        this.currentNotInHTML = false;\n        /**\n         * The template insertion mode stack is maintained from the left.\n         * Ie. the topmost element will always have index 0.\n         */\n        this.tmplInsertionModeStack = [];\n        this.pendingCharacterTokens = [];\n        this.hasNonWhitespacePendingCharacterToken = false;\n        this.framesetOk = true;\n        this.skipNextNewLine = false;\n        this.fosterParentingEnabled = false;\n        this.options = {\n            ...defaultParserOptions,\n            ...options,\n        };\n        this.treeAdapter = this.options.treeAdapter;\n        this.onParseError = this.options.onParseError;\n        // Always enable location info if we report parse errors.\n        if (this.onParseError) {\n            this.options.sourceCodeLocationInfo = true;\n        }\n        this.document = document !== null && document !== void 0 ? document : this.treeAdapter.createDocument();\n        this.tokenizer = new Tokenizer(this.options, this);\n        this.activeFormattingElements = new FormattingElementList(this.treeAdapter);\n        this.fragmentContextID = fragmentContext ? getTagID(this.treeAdapter.getTagName(fragmentContext)) : $.UNKNOWN;\n        this._setContextModes(fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : this.document, this.fragmentContextID);\n        this.openElements = new OpenElementStack(this.document, this.treeAdapter, this);\n    }\n    // API\n    static parse(html, options) {\n        const parser = new this(options);\n        parser.tokenizer.write(html, true);\n        return parser.document;\n    }\n    static getFragmentParser(fragmentContext, options) {\n        const opts = {\n            ...defaultParserOptions,\n            ...options,\n        };\n        //NOTE: use a <template> element as the fragment context if no context element was provided,\n        //so we will parse in a \"forgiving\" manner\n        fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : (fragmentContext = opts.treeAdapter.createElement(TN.TEMPLATE, NS.HTML, []));\n        //NOTE: create a fake element which will be used as the `document` for fragment parsing.\n        //This is important for jsdom, where a new `document` cannot be created. This led to\n        //fragment parsing messing with the main `document`.\n        const documentMock = opts.treeAdapter.createElement('documentmock', NS.HTML, []);\n        const parser = new this(opts, documentMock, fragmentContext);\n        if (parser.fragmentContextID === $.TEMPLATE) {\n            parser.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);\n        }\n        parser._initTokenizerForFragmentParsing();\n        parser._insertFakeRootElement();\n        parser._resetInsertionMode();\n        parser._findFormInFragmentContext();\n        return parser;\n    }\n    getFragment() {\n        const rootElement = this.treeAdapter.getFirstChild(this.document);\n        const fragment = this.treeAdapter.createDocumentFragment();\n        this._adoptNodes(rootElement, fragment);\n        return fragment;\n    }\n    //Errors\n    _err(token, code, beforeToken) {\n        var _a;\n        if (!this.onParseError)\n            return;\n        const loc = (_a = token.location) !== null && _a !== void 0 ? _a : BASE_LOC;\n        const err = {\n            code,\n            startLine: loc.startLine,\n            startCol: loc.startCol,\n            startOffset: loc.startOffset,\n            endLine: beforeToken ? loc.startLine : loc.endLine,\n            endCol: beforeToken ? loc.startCol : loc.endCol,\n            endOffset: beforeToken ? loc.startOffset : loc.endOffset,\n        };\n        this.onParseError(err);\n    }\n    //Stack events\n    onItemPush(node, tid, isTop) {\n        var _a, _b;\n        (_b = (_a = this.treeAdapter).onItemPush) === null || _b === void 0 ? void 0 : _b.call(_a, node);\n        if (isTop && this.openElements.stackTop > 0)\n            this._setContextModes(node, tid);\n    }\n    onItemPop(node, isTop) {\n        var _a, _b;\n        if (this.options.sourceCodeLocationInfo) {\n            this._setEndLocation(node, this.currentToken);\n        }\n        (_b = (_a = this.treeAdapter).onItemPop) === null || _b === void 0 ? void 0 : _b.call(_a, node, this.openElements.current);\n        if (isTop) {\n            let current;\n            let currentTagId;\n            if (this.openElements.stackTop === 0 && this.fragmentContext) {\n                current = this.fragmentContext;\n                currentTagId = this.fragmentContextID;\n            }\n            else {\n                ({ current, currentTagId } = this.openElements);\n            }\n            this._setContextModes(current, currentTagId);\n        }\n    }\n    _setContextModes(current, tid) {\n        const isHTML = current === this.document || this.treeAdapter.getNamespaceURI(current) === NS.HTML;\n        this.currentNotInHTML = !isHTML;\n        this.tokenizer.inForeignNode = !isHTML && !this._isIntegrationPoint(tid, current);\n    }\n    _switchToTextParsing(currentToken, nextTokenizerState) {\n        this._insertElement(currentToken, NS.HTML);\n        this.tokenizer.state = nextTokenizerState;\n        this.originalInsertionMode = this.insertionMode;\n        this.insertionMode = InsertionMode.TEXT;\n    }\n    switchToPlaintextParsing() {\n        this.insertionMode = InsertionMode.TEXT;\n        this.originalInsertionMode = InsertionMode.IN_BODY;\n        this.tokenizer.state = TokenizerMode.PLAINTEXT;\n    }\n    //Fragment parsing\n    _getAdjustedCurrentElement() {\n        return this.openElements.stackTop === 0 && this.fragmentContext\n            ? this.fragmentContext\n            : this.openElements.current;\n    }\n    _findFormInFragmentContext() {\n        let node = this.fragmentContext;\n        while (node) {\n            if (this.treeAdapter.getTagName(node) === TN.FORM) {\n                this.formElement = node;\n                break;\n            }\n            node = this.treeAdapter.getParentNode(node);\n        }\n    }\n    _initTokenizerForFragmentParsing() {\n        if (!this.fragmentContext || this.treeAdapter.getNamespaceURI(this.fragmentContext) !== NS.HTML) {\n            return;\n        }\n        switch (this.fragmentContextID) {\n            case $.TITLE:\n            case $.TEXTAREA: {\n                this.tokenizer.state = TokenizerMode.RCDATA;\n                break;\n            }\n            case $.STYLE:\n            case $.XMP:\n            case $.IFRAME:\n            case $.NOEMBED:\n            case $.NOFRAMES:\n            case $.NOSCRIPT: {\n                this.tokenizer.state = TokenizerMode.RAWTEXT;\n                break;\n            }\n            case $.SCRIPT: {\n                this.tokenizer.state = TokenizerMode.SCRIPT_DATA;\n                break;\n            }\n            case $.PLAINTEXT: {\n                this.tokenizer.state = TokenizerMode.PLAINTEXT;\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    //Tree mutation\n    _setDocumentType(token) {\n        const name = token.name || '';\n        const publicId = token.publicId || '';\n        const systemId = token.systemId || '';\n        this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);\n        if (token.location) {\n            const documentChildren = this.treeAdapter.getChildNodes(this.document);\n            const docTypeNode = documentChildren.find((node) => this.treeAdapter.isDocumentTypeNode(node));\n            if (docTypeNode) {\n                this.treeAdapter.setNodeSourceCodeLocation(docTypeNode, token.location);\n            }\n        }\n    }\n    _attachElementToTree(element, location) {\n        if (this.options.sourceCodeLocationInfo) {\n            const loc = location && {\n                ...location,\n                startTag: location,\n            };\n            this.treeAdapter.setNodeSourceCodeLocation(element, loc);\n        }\n        if (this._shouldFosterParentOnInsertion()) {\n            this._fosterParentElement(element);\n        }\n        else {\n            const parent = this.openElements.currentTmplContentOrNode;\n            this.treeAdapter.appendChild(parent, element);\n        }\n    }\n    _appendElement(token, namespaceURI) {\n        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);\n        this._attachElementToTree(element, token.location);\n    }\n    _insertElement(token, namespaceURI) {\n        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);\n        this._attachElementToTree(element, token.location);\n        this.openElements.push(element, token.tagID);\n    }\n    _insertFakeElement(tagName, tagID) {\n        const element = this.treeAdapter.createElement(tagName, NS.HTML, []);\n        this._attachElementToTree(element, null);\n        this.openElements.push(element, tagID);\n    }\n    _insertTemplate(token) {\n        const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);\n        const content = this.treeAdapter.createDocumentFragment();\n        this.treeAdapter.setTemplateContent(tmpl, content);\n        this._attachElementToTree(tmpl, token.location);\n        this.openElements.push(tmpl, token.tagID);\n        if (this.options.sourceCodeLocationInfo)\n            this.treeAdapter.setNodeSourceCodeLocation(content, null);\n    }\n    _insertFakeRootElement() {\n        const element = this.treeAdapter.createElement(TN.HTML, NS.HTML, []);\n        if (this.options.sourceCodeLocationInfo)\n            this.treeAdapter.setNodeSourceCodeLocation(element, null);\n        this.treeAdapter.appendChild(this.openElements.current, element);\n        this.openElements.push(element, $.HTML);\n    }\n    _appendCommentNode(token, parent) {\n        const commentNode = this.treeAdapter.createCommentNode(token.data);\n        this.treeAdapter.appendChild(parent, commentNode);\n        if (this.options.sourceCodeLocationInfo) {\n            this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);\n        }\n    }\n    _insertCharacters(token) {\n        let parent;\n        let beforeElement;\n        if (this._shouldFosterParentOnInsertion()) {\n            ({ parent, beforeElement } = this._findFosterParentingLocation());\n            if (beforeElement) {\n                this.treeAdapter.insertTextBefore(parent, token.chars, beforeElement);\n            }\n            else {\n                this.treeAdapter.insertText(parent, token.chars);\n            }\n        }\n        else {\n            parent = this.openElements.currentTmplContentOrNode;\n            this.treeAdapter.insertText(parent, token.chars);\n        }\n        if (!token.location)\n            return;\n        const siblings = this.treeAdapter.getChildNodes(parent);\n        const textNodeIdx = beforeElement ? siblings.lastIndexOf(beforeElement) : siblings.length;\n        const textNode = siblings[textNodeIdx - 1];\n        //NOTE: if we have a location assigned by another token, then just update the end position\n        const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode);\n        if (tnLoc) {\n            const { endLine, endCol, endOffset } = token.location;\n            this.treeAdapter.updateNodeSourceCodeLocation(textNode, { endLine, endCol, endOffset });\n        }\n        else if (this.options.sourceCodeLocationInfo) {\n            this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);\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    _setEndLocation(element, closingToken) {\n        if (this.treeAdapter.getNodeSourceCodeLocation(element) && closingToken.location) {\n            const ctLoc = closingToken.location;\n            const tn = this.treeAdapter.getTagName(element);\n            const endLoc = \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            closingToken.type === TokenType.END_TAG && tn === closingToken.tagName\n                ? {\n                    endTag: { ...ctLoc },\n                    endLine: ctLoc.endLine,\n                    endCol: ctLoc.endCol,\n                    endOffset: ctLoc.endOffset,\n                }\n                : {\n                    endLine: ctLoc.startLine,\n                    endCol: ctLoc.startCol,\n                    endOffset: ctLoc.startOffset,\n                };\n            this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc);\n        }\n    }\n    //Token processing\n    shouldProcessStartTagTokenInForeignContent(token) {\n        // Check that neither current === document, or ns === NS.HTML\n        if (!this.currentNotInHTML)\n            return false;\n        let current;\n        let currentTagId;\n        if (this.openElements.stackTop === 0 && this.fragmentContext) {\n            current = this.fragmentContext;\n            currentTagId = this.fragmentContextID;\n        }\n        else {\n            ({ current, currentTagId } = this.openElements);\n        }\n        if (token.tagID === $.SVG &&\n            this.treeAdapter.getTagName(current) === TN.ANNOTATION_XML &&\n            this.treeAdapter.getNamespaceURI(current) === NS.MATHML) {\n            return false;\n        }\n        return (\n        // Check that `current` is not an integration point for HTML or MathML elements.\n        this.tokenizer.inForeignNode ||\n            // If it _is_ an integration point, then we might have to check that it is not an HTML\n            // integration point.\n            ((token.tagID === $.MGLYPH || token.tagID === $.MALIGNMARK) &&\n                !this._isIntegrationPoint(currentTagId, current, NS.HTML)));\n    }\n    _processToken(token) {\n        switch (token.type) {\n            case TokenType.CHARACTER: {\n                this.onCharacter(token);\n                break;\n            }\n            case TokenType.NULL_CHARACTER: {\n                this.onNullCharacter(token);\n                break;\n            }\n            case TokenType.COMMENT: {\n                this.onComment(token);\n                break;\n            }\n            case TokenType.DOCTYPE: {\n                this.onDoctype(token);\n                break;\n            }\n            case TokenType.START_TAG: {\n                this._processStartTag(token);\n                break;\n            }\n            case TokenType.END_TAG: {\n                this.onEndTag(token);\n                break;\n            }\n            case TokenType.EOF: {\n                this.onEof(token);\n                break;\n            }\n            case TokenType.WHITESPACE_CHARACTER: {\n                this.onWhitespaceCharacter(token);\n                break;\n            }\n        }\n    }\n    //Integration points\n    _isIntegrationPoint(tid, element, foreignNS) {\n        const ns = this.treeAdapter.getNamespaceURI(element);\n        const attrs = this.treeAdapter.getAttrList(element);\n        return foreignContent.isIntegrationPoint(tid, ns, attrs, foreignNS);\n    }\n    //Active formatting elements reconstruction\n    _reconstructActiveFormattingElements() {\n        const listLength = this.activeFormattingElements.entries.length;\n        if (listLength) {\n            const endIndex = this.activeFormattingElements.entries.findIndex((entry) => entry.type === EntryType.Marker || this.openElements.contains(entry.element));\n            const unopenIdx = endIndex < 0 ? listLength - 1 : endIndex - 1;\n            for (let i = unopenIdx; i >= 0; i--) {\n                const 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    //Close elements\n    _closeTableCell() {\n        this.openElements.generateImpliedEndTags();\n        this.openElements.popUntilTableCellPopped();\n        this.activeFormattingElements.clearToLastMarker();\n        this.insertionMode = InsertionMode.IN_ROW;\n    }\n    _closePElement() {\n        this.openElements.generateImpliedEndTagsWithExclusion($.P);\n        this.openElements.popUntilTagNamePopped($.P);\n    }\n    //Insertion modes\n    _resetInsertionMode() {\n        for (let i = this.openElements.stackTop; i >= 0; i--) {\n            //Insertion mode reset map\n            switch (i === 0 && this.fragmentContext ? this.fragmentContextID : this.openElements.tagIDs[i]) {\n                case $.TR: {\n                    this.insertionMode = InsertionMode.IN_ROW;\n                    return;\n                }\n                case $.TBODY:\n                case $.THEAD:\n                case $.TFOOT: {\n                    this.insertionMode = InsertionMode.IN_TABLE_BODY;\n                    return;\n                }\n                case $.CAPTION: {\n                    this.insertionMode = InsertionMode.IN_CAPTION;\n                    return;\n                }\n                case $.COLGROUP: {\n                    this.insertionMode = InsertionMode.IN_COLUMN_GROUP;\n                    return;\n                }\n                case $.TABLE: {\n                    this.insertionMode = InsertionMode.IN_TABLE;\n                    return;\n                }\n                case $.BODY: {\n                    this.insertionMode = InsertionMode.IN_BODY;\n                    return;\n                }\n                case $.FRAMESET: {\n                    this.insertionMode = InsertionMode.IN_FRAMESET;\n                    return;\n                }\n                case $.SELECT: {\n                    this._resetInsertionModeForSelect(i);\n                    return;\n                }\n                case $.TEMPLATE: {\n                    this.insertionMode = this.tmplInsertionModeStack[0];\n                    return;\n                }\n                case $.HTML: {\n                    this.insertionMode = this.headElement ? InsertionMode.AFTER_HEAD : InsertionMode.BEFORE_HEAD;\n                    return;\n                }\n                case $.TD:\n                case $.TH: {\n                    if (i > 0) {\n                        this.insertionMode = InsertionMode.IN_CELL;\n                        return;\n                    }\n                    break;\n                }\n                case $.HEAD: {\n                    if (i > 0) {\n                        this.insertionMode = InsertionMode.IN_HEAD;\n                        return;\n                    }\n                    break;\n                }\n            }\n        }\n        this.insertionMode = InsertionMode.IN_BODY;\n    }\n    _resetInsertionModeForSelect(selectIdx) {\n        if (selectIdx > 0) {\n            for (let i = selectIdx - 1; i > 0; i--) {\n                const tn = this.openElements.tagIDs[i];\n                if (tn === $.TEMPLATE) {\n                    break;\n                }\n                else if (tn === $.TABLE) {\n                    this.insertionMode = InsertionMode.IN_SELECT_IN_TABLE;\n                    return;\n                }\n            }\n        }\n        this.insertionMode = InsertionMode.IN_SELECT;\n    }\n    //Foster parenting\n    _isElementCausesFosterParenting(tn) {\n        return TABLE_STRUCTURE_TAGS.has(tn);\n    }\n    _shouldFosterParentOnInsertion() {\n        return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.currentTagId);\n    }\n    _findFosterParentingLocation() {\n        for (let i = this.openElements.stackTop; i >= 0; i--) {\n            const openElement = this.openElements.items[i];\n            switch (this.openElements.tagIDs[i]) {\n                case $.TEMPLATE: {\n                    if (this.treeAdapter.getNamespaceURI(openElement) === NS.HTML) {\n                        return { parent: this.treeAdapter.getTemplateContent(openElement), beforeElement: null };\n                    }\n                    break;\n                }\n                case $.TABLE: {\n                    const parent = this.treeAdapter.getParentNode(openElement);\n                    if (parent) {\n                        return { parent, beforeElement: openElement };\n                    }\n                    return { parent: this.openElements.items[i - 1], beforeElement: null };\n                }\n                default:\n                // Do nothing\n            }\n        }\n        return { parent: this.openElements.items[0], beforeElement: null };\n    }\n    _fosterParentElement(element) {\n        const location = this._findFosterParentingLocation();\n        if (location.beforeElement) {\n            this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);\n        }\n        else {\n            this.treeAdapter.appendChild(location.parent, element);\n        }\n    }\n    //Special elements\n    _isSpecialElement(element, id) {\n        const ns = this.treeAdapter.getNamespaceURI(element);\n        return SPECIAL_ELEMENTS[ns].has(id);\n    }\n    onCharacter(token) {\n        this.skipNextNewLine = false;\n        if (this.tokenizer.inForeignNode) {\n            characterInForeignContent(this, token);\n            return;\n        }\n        switch (this.insertionMode) {\n            case InsertionMode.INITIAL: {\n                tokenInInitialMode(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HTML: {\n                tokenBeforeHtml(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HEAD: {\n                tokenBeforeHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD: {\n                tokenInHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD_NO_SCRIPT: {\n                tokenInHeadNoScript(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_HEAD: {\n                tokenAfterHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_BODY:\n            case InsertionMode.IN_CAPTION:\n            case InsertionMode.IN_CELL:\n            case InsertionMode.IN_TEMPLATE: {\n                characterInBody(this, token);\n                break;\n            }\n            case InsertionMode.TEXT:\n            case InsertionMode.IN_SELECT:\n            case InsertionMode.IN_SELECT_IN_TABLE: {\n                this._insertCharacters(token);\n                break;\n            }\n            case InsertionMode.IN_TABLE:\n            case InsertionMode.IN_TABLE_BODY:\n            case InsertionMode.IN_ROW: {\n                characterInTable(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE_TEXT: {\n                characterInTableText(this, token);\n                break;\n            }\n            case InsertionMode.IN_COLUMN_GROUP: {\n                tokenInColumnGroup(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_BODY: {\n                tokenAfterBody(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_AFTER_BODY: {\n                tokenAfterAfterBody(this, token);\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    onNullCharacter(token) {\n        this.skipNextNewLine = false;\n        if (this.tokenizer.inForeignNode) {\n            nullCharacterInForeignContent(this, token);\n            return;\n        }\n        switch (this.insertionMode) {\n            case InsertionMode.INITIAL: {\n                tokenInInitialMode(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HTML: {\n                tokenBeforeHtml(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HEAD: {\n                tokenBeforeHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD: {\n                tokenInHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD_NO_SCRIPT: {\n                tokenInHeadNoScript(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_HEAD: {\n                tokenAfterHead(this, token);\n                break;\n            }\n            case InsertionMode.TEXT: {\n                this._insertCharacters(token);\n                break;\n            }\n            case InsertionMode.IN_TABLE:\n            case InsertionMode.IN_TABLE_BODY:\n            case InsertionMode.IN_ROW: {\n                characterInTable(this, token);\n                break;\n            }\n            case InsertionMode.IN_COLUMN_GROUP: {\n                tokenInColumnGroup(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_BODY: {\n                tokenAfterBody(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_AFTER_BODY: {\n                tokenAfterAfterBody(this, token);\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    onComment(token) {\n        this.skipNextNewLine = false;\n        if (this.currentNotInHTML) {\n            appendComment(this, token);\n            return;\n        }\n        switch (this.insertionMode) {\n            case InsertionMode.INITIAL:\n            case InsertionMode.BEFORE_HTML:\n            case InsertionMode.BEFORE_HEAD:\n            case InsertionMode.IN_HEAD:\n            case InsertionMode.IN_HEAD_NO_SCRIPT:\n            case InsertionMode.AFTER_HEAD:\n            case InsertionMode.IN_BODY:\n            case InsertionMode.IN_TABLE:\n            case InsertionMode.IN_CAPTION:\n            case InsertionMode.IN_COLUMN_GROUP:\n            case InsertionMode.IN_TABLE_BODY:\n            case InsertionMode.IN_ROW:\n            case InsertionMode.IN_CELL:\n            case InsertionMode.IN_SELECT:\n            case InsertionMode.IN_SELECT_IN_TABLE:\n            case InsertionMode.IN_TEMPLATE:\n            case InsertionMode.IN_FRAMESET:\n            case InsertionMode.AFTER_FRAMESET: {\n                appendComment(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE_TEXT: {\n                tokenInTableText(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_BODY: {\n                appendCommentToRootHtmlElement(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_AFTER_BODY:\n            case InsertionMode.AFTER_AFTER_FRAMESET: {\n                appendCommentToDocument(this, token);\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    onDoctype(token) {\n        this.skipNextNewLine = false;\n        switch (this.insertionMode) {\n            case InsertionMode.INITIAL: {\n                doctypeInInitialMode(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HEAD:\n            case InsertionMode.IN_HEAD:\n            case InsertionMode.IN_HEAD_NO_SCRIPT:\n            case InsertionMode.AFTER_HEAD: {\n                this._err(token, ERR.misplacedDoctype);\n                break;\n            }\n            case InsertionMode.IN_TABLE_TEXT: {\n                tokenInTableText(this, token);\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    onStartTag(token) {\n        this.skipNextNewLine = false;\n        this.currentToken = token;\n        this._processStartTag(token);\n        if (token.selfClosing && !token.ackSelfClosing) {\n            this._err(token, ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);\n        }\n    }\n    /**\n     * Processes a given start tag.\n     *\n     * `onStartTag` checks if a self-closing tag was recognized. When a token\n     * is moved inbetween multiple insertion modes, this check for self-closing\n     * could lead to false positives. To avoid this, `_processStartTag` is used\n     * for nested calls.\n     *\n     * @param token The token to process.\n     */\n    _processStartTag(token) {\n        if (this.shouldProcessStartTagTokenInForeignContent(token)) {\n            startTagInForeignContent(this, token);\n        }\n        else {\n            this._startTagOutsideForeignContent(token);\n        }\n    }\n    _startTagOutsideForeignContent(token) {\n        switch (this.insertionMode) {\n            case InsertionMode.INITIAL: {\n                tokenInInitialMode(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HTML: {\n                startTagBeforeHtml(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HEAD: {\n                startTagBeforeHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD: {\n                startTagInHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD_NO_SCRIPT: {\n                startTagInHeadNoScript(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_HEAD: {\n                startTagAfterHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_BODY: {\n                startTagInBody(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE: {\n                startTagInTable(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE_TEXT: {\n                tokenInTableText(this, token);\n                break;\n            }\n            case InsertionMode.IN_CAPTION: {\n                startTagInCaption(this, token);\n                break;\n            }\n            case InsertionMode.IN_COLUMN_GROUP: {\n                startTagInColumnGroup(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE_BODY: {\n                startTagInTableBody(this, token);\n                break;\n            }\n            case InsertionMode.IN_ROW: {\n                startTagInRow(this, token);\n                break;\n            }\n            case InsertionMode.IN_CELL: {\n                startTagInCell(this, token);\n                break;\n            }\n            case InsertionMode.IN_SELECT: {\n                startTagInSelect(this, token);\n                break;\n            }\n            case InsertionMode.IN_SELECT_IN_TABLE: {\n                startTagInSelectInTable(this, token);\n                break;\n            }\n            case InsertionMode.IN_TEMPLATE: {\n                startTagInTemplate(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_BODY: {\n                startTagAfterBody(this, token);\n                break;\n            }\n            case InsertionMode.IN_FRAMESET: {\n                startTagInFrameset(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_FRAMESET: {\n                startTagAfterFrameset(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_AFTER_BODY: {\n                startTagAfterAfterBody(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_AFTER_FRAMESET: {\n                startTagAfterAfterFrameset(this, token);\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    onEndTag(token) {\n        this.skipNextNewLine = false;\n        this.currentToken = token;\n        if (this.currentNotInHTML) {\n            endTagInForeignContent(this, token);\n        }\n        else {\n            this._endTagOutsideForeignContent(token);\n        }\n    }\n    _endTagOutsideForeignContent(token) {\n        switch (this.insertionMode) {\n            case InsertionMode.INITIAL: {\n                tokenInInitialMode(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HTML: {\n                endTagBeforeHtml(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HEAD: {\n                endTagBeforeHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD: {\n                endTagInHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD_NO_SCRIPT: {\n                endTagInHeadNoScript(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_HEAD: {\n                endTagAfterHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_BODY: {\n                endTagInBody(this, token);\n                break;\n            }\n            case InsertionMode.TEXT: {\n                endTagInText(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE: {\n                endTagInTable(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE_TEXT: {\n                tokenInTableText(this, token);\n                break;\n            }\n            case InsertionMode.IN_CAPTION: {\n                endTagInCaption(this, token);\n                break;\n            }\n            case InsertionMode.IN_COLUMN_GROUP: {\n                endTagInColumnGroup(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE_BODY: {\n                endTagInTableBody(this, token);\n                break;\n            }\n            case InsertionMode.IN_ROW: {\n                endTagInRow(this, token);\n                break;\n            }\n            case InsertionMode.IN_CELL: {\n                endTagInCell(this, token);\n                break;\n            }\n            case InsertionMode.IN_SELECT: {\n                endTagInSelect(this, token);\n                break;\n            }\n            case InsertionMode.IN_SELECT_IN_TABLE: {\n                endTagInSelectInTable(this, token);\n                break;\n            }\n            case InsertionMode.IN_TEMPLATE: {\n                endTagInTemplate(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_BODY: {\n                endTagAfterBody(this, token);\n                break;\n            }\n            case InsertionMode.IN_FRAMESET: {\n                endTagInFrameset(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_FRAMESET: {\n                endTagAfterFrameset(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_AFTER_BODY: {\n                tokenAfterAfterBody(this, token);\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    onEof(token) {\n        switch (this.insertionMode) {\n            case InsertionMode.INITIAL: {\n                tokenInInitialMode(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HTML: {\n                tokenBeforeHtml(this, token);\n                break;\n            }\n            case InsertionMode.BEFORE_HEAD: {\n                tokenBeforeHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD: {\n                tokenInHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_HEAD_NO_SCRIPT: {\n                tokenInHeadNoScript(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_HEAD: {\n                tokenAfterHead(this, token);\n                break;\n            }\n            case InsertionMode.IN_BODY:\n            case InsertionMode.IN_TABLE:\n            case InsertionMode.IN_CAPTION:\n            case InsertionMode.IN_COLUMN_GROUP:\n            case InsertionMode.IN_TABLE_BODY:\n            case InsertionMode.IN_ROW:\n            case InsertionMode.IN_CELL:\n            case InsertionMode.IN_SELECT:\n            case InsertionMode.IN_SELECT_IN_TABLE: {\n                eofInBody(this, token);\n                break;\n            }\n            case InsertionMode.TEXT: {\n                eofInText(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE_TEXT: {\n                tokenInTableText(this, token);\n                break;\n            }\n            case InsertionMode.IN_TEMPLATE: {\n                eofInTemplate(this, token);\n                break;\n            }\n            case InsertionMode.AFTER_BODY:\n            case InsertionMode.IN_FRAMESET:\n            case InsertionMode.AFTER_FRAMESET:\n            case InsertionMode.AFTER_AFTER_BODY:\n            case InsertionMode.AFTER_AFTER_FRAMESET: {\n                stopParsing(this, token);\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n    onWhitespaceCharacter(token) {\n        if (this.skipNextNewLine) {\n            this.skipNextNewLine = false;\n            if (token.chars.charCodeAt(0) === unicode.CODE_POINTS.LINE_FEED) {\n                if (token.chars.length === 1) {\n                    return;\n                }\n                token.chars = token.chars.substr(1);\n            }\n        }\n        if (this.tokenizer.inForeignNode) {\n            this._insertCharacters(token);\n            return;\n        }\n        switch (this.insertionMode) {\n            case InsertionMode.IN_HEAD:\n            case InsertionMode.IN_HEAD_NO_SCRIPT:\n            case InsertionMode.AFTER_HEAD:\n            case InsertionMode.TEXT:\n            case InsertionMode.IN_COLUMN_GROUP:\n            case InsertionMode.IN_SELECT:\n            case InsertionMode.IN_SELECT_IN_TABLE:\n            case InsertionMode.IN_FRAMESET:\n            case InsertionMode.AFTER_FRAMESET: {\n                this._insertCharacters(token);\n                break;\n            }\n            case InsertionMode.IN_BODY:\n            case InsertionMode.IN_CAPTION:\n            case InsertionMode.IN_CELL:\n            case InsertionMode.IN_TEMPLATE:\n            case InsertionMode.AFTER_BODY:\n            case InsertionMode.AFTER_AFTER_BODY:\n            case InsertionMode.AFTER_AFTER_FRAMESET: {\n                whitespaceCharacterInBody(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE:\n            case InsertionMode.IN_TABLE_BODY:\n            case InsertionMode.IN_ROW: {\n                characterInTable(this, token);\n                break;\n            }\n            case InsertionMode.IN_TABLE_TEXT: {\n                whitespaceCharacterInTableText(this, token);\n                break;\n            }\n            default:\n            // Do nothing\n        }\n    }\n}\n//Adoption agency algorithm\n//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency)\n//------------------------------------------------------------------\n//Steps 5-8 of the algorithm\nfunction aaObtainFormattingElementEntry(p, token) {\n    let formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);\n    if (formattingElementEntry) {\n        if (!p.openElements.contains(formattingElementEntry.element)) {\n            p.activeFormattingElements.removeEntry(formattingElementEntry);\n            formattingElementEntry = null;\n        }\n        else if (!p.openElements.hasInScope(token.tagID)) {\n            formattingElementEntry = null;\n        }\n    }\n    else {\n        genericEndTagInBody(p, token);\n    }\n    return formattingElementEntry;\n}\n//Steps 9 and 10 of the algorithm\nfunction aaObtainFurthestBlock(p, formattingElementEntry) {\n    let furthestBlock = null;\n    let idx = p.openElements.stackTop;\n    for (; idx >= 0; idx--) {\n        const element = p.openElements.items[idx];\n        if (element === formattingElementEntry.element) {\n            break;\n        }\n        if (p._isSpecialElement(element, p.openElements.tagIDs[idx])) {\n            furthestBlock = element;\n        }\n    }\n    if (!furthestBlock) {\n        p.openElements.shortenToLength(idx < 0 ? 0 : idx);\n        p.activeFormattingElements.removeEntry(formattingElementEntry);\n    }\n    return furthestBlock;\n}\n//Step 13 of the algorithm\nfunction aaInnerLoop(p, furthestBlock, formattingElement) {\n    let lastElement = furthestBlock;\n    let nextElement = p.openElements.getCommonAncestor(furthestBlock);\n    for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {\n        //NOTE: store the 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        const elementEntry = p.activeFormattingElements.getElementEntry(element);\n        const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;\n        const shouldRemoveFromOpenElements = !elementEntry || counterOverflow;\n        if (shouldRemoveFromOpenElements) {\n            if (counterOverflow) {\n                p.activeFormattingElements.removeEntry(elementEntry);\n            }\n            p.openElements.remove(element);\n        }\n        else {\n            element = aaRecreateElementFromEntry(p, elementEntry);\n            if (lastElement === furthestBlock) {\n                p.activeFormattingElements.bookmark = elementEntry;\n            }\n            p.treeAdapter.detachNode(lastElement);\n            p.treeAdapter.appendChild(element, lastElement);\n            lastElement = element;\n        }\n    }\n    return lastElement;\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    p.openElements.replace(elementEntry.element, newElement);\n    elementEntry.element = newElement;\n    return newElement;\n}\n//Step 14 of the algorithm\nfunction aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {\n    const tn = p.treeAdapter.getTagName(commonAncestor);\n    const tid = getTagID(tn);\n    if (p._isElementCausesFosterParenting(tid)) {\n        p._fosterParentElement(lastElement);\n    }\n    else {\n        const ns = p.treeAdapter.getNamespaceURI(commonAncestor);\n        if (tid === $.TEMPLATE && ns === NS.HTML) {\n            commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);\n        }\n        p.treeAdapter.appendChild(commonAncestor, lastElement);\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;\n    const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);\n    p._adoptNodes(furthestBlock, newElement);\n    p.treeAdapter.appendChild(furthestBlock, newElement);\n    p.activeFormattingElements.insertElementAfterBookmark(newElement, token);\n    p.activeFormattingElements.removeEntry(formattingElementEntry);\n    p.openElements.remove(formattingElementEntry.element);\n    p.openElements.insertAfter(furthestBlock, newElement, token.tagID);\n}\n//Algorithm entry point\nfunction callAdoptionAgency(p, token) {\n    for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {\n        const formattingElementEntry = aaObtainFormattingElementEntry(p, token);\n        if (!formattingElementEntry) {\n            break;\n        }\n        const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);\n        if (!furthestBlock) {\n            break;\n        }\n        p.activeFormattingElements.bookmark = formattingElementEntry;\n        const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);\n        const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);\n        p.treeAdapter.detachNode(lastElement);\n        if (commonAncestor)\n            aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);\n        aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry);\n    }\n}\n//Generic token handlers\n//------------------------------------------------------------------\nfunction appendComment(p, token) {\n    p._appendCommentNode(token, p.openElements.currentTmplContentOrNode);\n}\nfunction appendCommentToRootHtmlElement(p, token) {\n    p._appendCommentNode(token, p.openElements.items[0]);\n}\nfunction appendCommentToDocument(p, token) {\n    p._appendCommentNode(token, p.document);\n}\nfunction stopParsing(p, token) {\n    p.stopped = true;\n    // NOTE: Set end locations for elements that remain on the open element stack.\n    if (token.location) {\n        // NOTE: If we are not in a fragment, `html` and `body` will stay on the stack.\n        // This is a problem, as we might overwrite their end position here.\n        const target = p.fragmentContext ? 0 : 2;\n        for (let i = p.openElements.stackTop; i >= target; i--) {\n            p._setEndLocation(p.openElements.items[i], token);\n        }\n        // Handle `html` and `body`\n        if (!p.fragmentContext && p.openElements.stackTop >= 0) {\n            const htmlElement = p.openElements.items[0];\n            const htmlLocation = p.treeAdapter.getNodeSourceCodeLocation(htmlElement);\n            if (htmlLocation && !htmlLocation.endTag) {\n                p._setEndLocation(htmlElement, token);\n                if (p.openElements.stackTop >= 1) {\n                    const bodyElement = p.openElements.items[1];\n                    const bodyLocation = p.treeAdapter.getNodeSourceCodeLocation(bodyElement);\n                    if (bodyLocation && !bodyLocation.endTag) {\n                        p._setEndLocation(bodyElement, token);\n                    }\n                }\n            }\n        }\n    }\n}\n// The \"initial\" insertion mode\n//------------------------------------------------------------------\nfunction doctypeInInitialMode(p, token) {\n    p._setDocumentType(token);\n    const mode = token.forceQuirks ? DOCUMENT_MODE.QUIRKS : doctype.getDocumentMode(token);\n    if (!doctype.isConforming(token)) {\n        p._err(token, ERR.nonConformingDoctype);\n    }\n    p.treeAdapter.setDocumentMode(p.document, mode);\n    p.insertionMode = InsertionMode.BEFORE_HTML;\n}\nfunction tokenInInitialMode(p, token) {\n    p._err(token, ERR.missingDoctype, true);\n    p.treeAdapter.setDocumentMode(p.document, DOCUMENT_MODE.QUIRKS);\n    p.insertionMode = InsertionMode.BEFORE_HTML;\n    p._processToken(token);\n}\n// The \"before html\" insertion mode\n//------------------------------------------------------------------\nfunction startTagBeforeHtml(p, token) {\n    if (token.tagID === $.HTML) {\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = InsertionMode.BEFORE_HEAD;\n    }\n    else {\n        tokenBeforeHtml(p, token);\n    }\n}\nfunction endTagBeforeHtml(p, token) {\n    const tn = token.tagID;\n    if (tn === $.HTML || tn === $.HEAD || tn === $.BODY || tn === $.BR) {\n        tokenBeforeHtml(p, token);\n    }\n}\nfunction tokenBeforeHtml(p, token) {\n    p._insertFakeRootElement();\n    p.insertionMode = InsertionMode.BEFORE_HEAD;\n    p._processToken(token);\n}\n// The \"before head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagBeforeHead(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.HEAD: {\n            p._insertElement(token, NS.HTML);\n            p.headElement = p.openElements.current;\n            p.insertionMode = InsertionMode.IN_HEAD;\n            break;\n        }\n        default: {\n            tokenBeforeHead(p, token);\n        }\n    }\n}\nfunction endTagBeforeHead(p, token) {\n    const tn = token.tagID;\n    if (tn === $.HEAD || tn === $.BODY || tn === $.HTML || tn === $.BR) {\n        tokenBeforeHead(p, token);\n    }\n    else {\n        p._err(token, ERR.endTagWithoutMatchingOpenElement);\n    }\n}\nfunction tokenBeforeHead(p, token) {\n    p._insertFakeElement(TN.HEAD, $.HEAD);\n    p.headElement = p.openElements.current;\n    p.insertionMode = InsertionMode.IN_HEAD;\n    p._processToken(token);\n}\n// The \"in head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInHead(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.BASE:\n        case $.BASEFONT:\n        case $.BGSOUND:\n        case $.LINK:\n        case $.META: {\n            p._appendElement(token, NS.HTML);\n            token.ackSelfClosing = true;\n            break;\n        }\n        case $.TITLE: {\n            p._switchToTextParsing(token, TokenizerMode.RCDATA);\n            break;\n        }\n        case $.NOSCRIPT: {\n            if (p.options.scriptingEnabled) {\n                p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n            }\n            else {\n                p._insertElement(token, NS.HTML);\n                p.insertionMode = InsertionMode.IN_HEAD_NO_SCRIPT;\n            }\n            break;\n        }\n        case $.NOFRAMES:\n        case $.STYLE: {\n            p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n            break;\n        }\n        case $.SCRIPT: {\n            p._switchToTextParsing(token, TokenizerMode.SCRIPT_DATA);\n            break;\n        }\n        case $.TEMPLATE: {\n            p._insertTemplate(token);\n            p.activeFormattingElements.insertMarker();\n            p.framesetOk = false;\n            p.insertionMode = InsertionMode.IN_TEMPLATE;\n            p.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);\n            break;\n        }\n        case $.HEAD: {\n            p._err(token, ERR.misplacedStartTagForHeadElement);\n            break;\n        }\n        default: {\n            tokenInHead(p, token);\n        }\n    }\n}\nfunction endTagInHead(p, token) {\n    switch (token.tagID) {\n        case $.HEAD: {\n            p.openElements.pop();\n            p.insertionMode = InsertionMode.AFTER_HEAD;\n            break;\n        }\n        case $.BODY:\n        case $.BR:\n        case $.HTML: {\n            tokenInHead(p, token);\n            break;\n        }\n        case $.TEMPLATE: {\n            templateEndTagInHead(p, token);\n            break;\n        }\n        default: {\n            p._err(token, ERR.endTagWithoutMatchingOpenElement);\n        }\n    }\n}\nfunction templateEndTagInHead(p, token) {\n    if (p.openElements.tmplCount > 0) {\n        p.openElements.generateImpliedEndTagsThoroughly();\n        if (p.openElements.currentTagId !== $.TEMPLATE) {\n            p._err(token, ERR.closingOfElementWithOpenChildElements);\n        }\n        p.openElements.popUntilTagNamePopped($.TEMPLATE);\n        p.activeFormattingElements.clearToLastMarker();\n        p.tmplInsertionModeStack.shift();\n        p._resetInsertionMode();\n    }\n    else {\n        p._err(token, ERR.endTagWithoutMatchingOpenElement);\n    }\n}\nfunction tokenInHead(p, token) {\n    p.openElements.pop();\n    p.insertionMode = InsertionMode.AFTER_HEAD;\n    p._processToken(token);\n}\n// The \"in head no script\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInHeadNoScript(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.BASEFONT:\n        case $.BGSOUND:\n        case $.HEAD:\n        case $.LINK:\n        case $.META:\n        case $.NOFRAMES:\n        case $.STYLE: {\n            startTagInHead(p, token);\n            break;\n        }\n        case $.NOSCRIPT: {\n            p._err(token, ERR.nestedNoscriptInHead);\n            break;\n        }\n        default: {\n            tokenInHeadNoScript(p, token);\n        }\n    }\n}\nfunction endTagInHeadNoScript(p, token) {\n    switch (token.tagID) {\n        case $.NOSCRIPT: {\n            p.openElements.pop();\n            p.insertionMode = InsertionMode.IN_HEAD;\n            break;\n        }\n        case $.BR: {\n            tokenInHeadNoScript(p, token);\n            break;\n        }\n        default: {\n            p._err(token, ERR.endTagWithoutMatchingOpenElement);\n        }\n    }\n}\nfunction tokenInHeadNoScript(p, token) {\n    const errCode = token.type === TokenType.EOF ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead;\n    p._err(token, errCode);\n    p.openElements.pop();\n    p.insertionMode = InsertionMode.IN_HEAD;\n    p._processToken(token);\n}\n// The \"after head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterHead(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.BODY: {\n            p._insertElement(token, NS.HTML);\n            p.framesetOk = false;\n            p.insertionMode = InsertionMode.IN_BODY;\n            break;\n        }\n        case $.FRAMESET: {\n            p._insertElement(token, NS.HTML);\n            p.insertionMode = InsertionMode.IN_FRAMESET;\n            break;\n        }\n        case $.BASE:\n        case $.BASEFONT:\n        case $.BGSOUND:\n        case $.LINK:\n        case $.META:\n        case $.NOFRAMES:\n        case $.SCRIPT:\n        case $.STYLE:\n        case $.TEMPLATE:\n        case $.TITLE: {\n            p._err(token, ERR.abandonedHeadElementChild);\n            p.openElements.push(p.headElement, $.HEAD);\n            startTagInHead(p, token);\n            p.openElements.remove(p.headElement);\n            break;\n        }\n        case $.HEAD: {\n            p._err(token, ERR.misplacedStartTagForHeadElement);\n            break;\n        }\n        default: {\n            tokenAfterHead(p, token);\n        }\n    }\n}\nfunction endTagAfterHead(p, token) {\n    switch (token.tagID) {\n        case $.BODY:\n        case $.HTML:\n        case $.BR: {\n            tokenAfterHead(p, token);\n            break;\n        }\n        case $.TEMPLATE: {\n            templateEndTagInHead(p, token);\n            break;\n        }\n        default: {\n            p._err(token, ERR.endTagWithoutMatchingOpenElement);\n        }\n    }\n}\nfunction tokenAfterHead(p, token) {\n    p._insertFakeElement(TN.BODY, $.BODY);\n    p.insertionMode = InsertionMode.IN_BODY;\n    modeInBody(p, token);\n}\n// The \"in body\" insertion mode\n//------------------------------------------------------------------\nfunction modeInBody(p, token) {\n    switch (token.type) {\n        case TokenType.CHARACTER: {\n            characterInBody(p, token);\n            break;\n        }\n        case TokenType.WHITESPACE_CHARACTER: {\n            whitespaceCharacterInBody(p, token);\n            break;\n        }\n        case TokenType.COMMENT: {\n            appendComment(p, token);\n            break;\n        }\n        case TokenType.START_TAG: {\n            startTagInBody(p, token);\n            break;\n        }\n        case TokenType.END_TAG: {\n            endTagInBody(p, token);\n            break;\n        }\n        case TokenType.EOF: {\n            eofInBody(p, token);\n            break;\n        }\n        default:\n        // Do nothing\n    }\n}\nfunction whitespaceCharacterInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertCharacters(token);\n}\nfunction characterInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertCharacters(token);\n    p.framesetOk = false;\n}\nfunction htmlStartTagInBody(p, token) {\n    if (p.openElements.tmplCount === 0) {\n        p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);\n    }\n}\nfunction bodyStartTagInBody(p, token) {\n    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();\n    if (bodyElement && p.openElements.tmplCount === 0) {\n        p.framesetOk = false;\n        p.treeAdapter.adoptAttributes(bodyElement, token.attrs);\n    }\n}\nfunction framesetStartTagInBody(p, token) {\n    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();\n    if (p.framesetOk && bodyElement) {\n        p.treeAdapter.detachNode(bodyElement);\n        p.openElements.popAllUpToHtmlElement();\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = InsertionMode.IN_FRAMESET;\n    }\n}\nfunction addressStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n    p._insertElement(token, NS.HTML);\n}\nfunction numberedHeaderStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n    if (isNumberedHeader(p.openElements.currentTagId)) {\n        p.openElements.pop();\n    }\n    p._insertElement(token, NS.HTML);\n}\nfunction preStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\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}\nfunction formStartTagInBody(p, token) {\n    const inTemplate = p.openElements.tmplCount > 0;\n    if (!p.formElement || inTemplate) {\n        if (p.openElements.hasInButtonScope($.P)) {\n            p._closePElement();\n        }\n        p._insertElement(token, NS.HTML);\n        if (!inTemplate) {\n            p.formElement = p.openElements.current;\n        }\n    }\n}\nfunction listItemStartTagInBody(p, token) {\n    p.framesetOk = false;\n    const tn = token.tagID;\n    for (let i = p.openElements.stackTop; i >= 0; i--) {\n        const elementId = p.openElements.tagIDs[i];\n        if ((tn === $.LI && elementId === $.LI) ||\n            ((tn === $.DD || tn === $.DT) && (elementId === $.DD || elementId === $.DT))) {\n            p.openElements.generateImpliedEndTagsWithExclusion(elementId);\n            p.openElements.popUntilTagNamePopped(elementId);\n            break;\n        }\n        if (elementId !== $.ADDRESS &&\n            elementId !== $.DIV &&\n            elementId !== $.P &&\n            p._isSpecialElement(p.openElements.items[i], elementId)) {\n            break;\n        }\n    }\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n    p._insertElement(token, NS.HTML);\n}\nfunction plaintextStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n    p._insertElement(token, NS.HTML);\n    p.tokenizer.state = TokenizerMode.PLAINTEXT;\n}\nfunction buttonStartTagInBody(p, token) {\n    if (p.openElements.hasInScope($.BUTTON)) {\n        p.openElements.generateImpliedEndTags();\n        p.openElements.popUntilTagNamePopped($.BUTTON);\n    }\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.framesetOk = false;\n}\nfunction aStartTagInBody(p, token) {\n    const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(TN.A);\n    if (activeElementEntry) {\n        callAdoptionAgency(p, token);\n        p.openElements.remove(activeElementEntry.element);\n        p.activeFormattingElements.removeEntry(activeElementEntry);\n    }\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\nfunction bStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\nfunction nobrStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    if (p.openElements.hasInScope($.NOBR)) {\n        callAdoptionAgency(p, token);\n        p._reconstructActiveFormattingElements();\n    }\n    p._insertElement(token, NS.HTML);\n    p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\nfunction appletStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.activeFormattingElements.insertMarker();\n    p.framesetOk = false;\n}\nfunction tableStartTagInBody(p, token) {\n    if (p.treeAdapter.getDocumentMode(p.document) !== DOCUMENT_MODE.QUIRKS && p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n    p._insertElement(token, NS.HTML);\n    p.framesetOk = false;\n    p.insertionMode = InsertionMode.IN_TABLE;\n}\nfunction areaStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._appendElement(token, NS.HTML);\n    p.framesetOk = false;\n    token.ackSelfClosing = true;\n}\nfunction isHiddenInput(token) {\n    const inputType = getTokenAttr(token, ATTRS.TYPE);\n    return inputType != null && inputType.toLowerCase() === HIDDEN_INPUT_TYPE;\n}\nfunction inputStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._appendElement(token, NS.HTML);\n    if (!isHiddenInput(token)) {\n        p.framesetOk = false;\n    }\n    token.ackSelfClosing = true;\n}\nfunction paramStartTagInBody(p, token) {\n    p._appendElement(token, NS.HTML);\n    token.ackSelfClosing = true;\n}\nfunction hrStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n    p._appendElement(token, NS.HTML);\n    p.framesetOk = false;\n    token.ackSelfClosing = true;\n}\nfunction imageStartTagInBody(p, token) {\n    token.tagName = TN.IMG;\n    token.tagID = $.IMG;\n    areaStartTagInBody(p, token);\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 = TokenizerMode.RCDATA;\n    p.originalInsertionMode = p.insertionMode;\n    p.framesetOk = false;\n    p.insertionMode = InsertionMode.TEXT;\n}\nfunction xmpStartTagInBody(p, token) {\n    if (p.openElements.hasInButtonScope($.P)) {\n        p._closePElement();\n    }\n    p._reconstructActiveFormattingElements();\n    p.framesetOk = false;\n    p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n}\nfunction iframeStartTagInBody(p, token) {\n    p.framesetOk = false;\n    p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n}\n//NOTE: here we assume that we always act as an user agent with enabled plugins, so we parse\n//<noembed> as rawtext.\nfunction noembedStartTagInBody(p, token) {\n    p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n}\nfunction selectStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n    p.framesetOk = false;\n    p.insertionMode =\n        p.insertionMode === InsertionMode.IN_TABLE ||\n            p.insertionMode === InsertionMode.IN_CAPTION ||\n            p.insertionMode === InsertionMode.IN_TABLE_BODY ||\n            p.insertionMode === InsertionMode.IN_ROW ||\n            p.insertionMode === InsertionMode.IN_CELL\n            ? InsertionMode.IN_SELECT_IN_TABLE\n            : InsertionMode.IN_SELECT;\n}\nfunction optgroupStartTagInBody(p, token) {\n    if (p.openElements.currentTagId === $.OPTION) {\n        p.openElements.pop();\n    }\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n}\nfunction rbStartTagInBody(p, token) {\n    if (p.openElements.hasInScope($.RUBY)) {\n        p.openElements.generateImpliedEndTags();\n    }\n    p._insertElement(token, NS.HTML);\n}\nfunction rtStartTagInBody(p, token) {\n    if (p.openElements.hasInScope($.RUBY)) {\n        p.openElements.generateImpliedEndTagsWithExclusion($.RTC);\n    }\n    p._insertElement(token, NS.HTML);\n}\nfunction mathStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    foreignContent.adjustTokenMathMLAttrs(token);\n    foreignContent.adjustTokenXMLAttrs(token);\n    if (token.selfClosing) {\n        p._appendElement(token, NS.MATHML);\n    }\n    else {\n        p._insertElement(token, NS.MATHML);\n    }\n    token.ackSelfClosing = true;\n}\nfunction svgStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    foreignContent.adjustTokenSVGAttrs(token);\n    foreignContent.adjustTokenXMLAttrs(token);\n    if (token.selfClosing) {\n        p._appendElement(token, NS.SVG);\n    }\n    else {\n        p._insertElement(token, NS.SVG);\n    }\n    token.ackSelfClosing = true;\n}\nfunction genericStartTagInBody(p, token) {\n    p._reconstructActiveFormattingElements();\n    p._insertElement(token, NS.HTML);\n}\nfunction startTagInBody(p, token) {\n    switch (token.tagID) {\n        case $.I:\n        case $.S:\n        case $.B:\n        case $.U:\n        case $.EM:\n        case $.TT:\n        case $.BIG:\n        case $.CODE:\n        case $.FONT:\n        case $.SMALL:\n        case $.STRIKE:\n        case $.STRONG: {\n            bStartTagInBody(p, token);\n            break;\n        }\n        case $.A: {\n            aStartTagInBody(p, token);\n            break;\n        }\n        case $.H1:\n        case $.H2:\n        case $.H3:\n        case $.H4:\n        case $.H5:\n        case $.H6: {\n            numberedHeaderStartTagInBody(p, token);\n            break;\n        }\n        case $.P:\n        case $.DL:\n        case $.OL:\n        case $.UL:\n        case $.DIV:\n        case $.DIR:\n        case $.NAV:\n        case $.MAIN:\n        case $.MENU:\n        case $.ASIDE:\n        case $.CENTER:\n        case $.FIGURE:\n        case $.FOOTER:\n        case $.HEADER:\n        case $.HGROUP:\n        case $.DIALOG:\n        case $.DETAILS:\n        case $.ADDRESS:\n        case $.ARTICLE:\n        case $.SECTION:\n        case $.SUMMARY:\n        case $.FIELDSET:\n        case $.BLOCKQUOTE:\n        case $.FIGCAPTION: {\n            addressStartTagInBody(p, token);\n            break;\n        }\n        case $.LI:\n        case $.DD:\n        case $.DT: {\n            listItemStartTagInBody(p, token);\n            break;\n        }\n        case $.BR:\n        case $.IMG:\n        case $.WBR:\n        case $.AREA:\n        case $.EMBED:\n        case $.KEYGEN: {\n            areaStartTagInBody(p, token);\n            break;\n        }\n        case $.HR: {\n            hrStartTagInBody(p, token);\n            break;\n        }\n        case $.RB:\n        case $.RTC: {\n            rbStartTagInBody(p, token);\n            break;\n        }\n        case $.RT:\n        case $.RP: {\n            rtStartTagInBody(p, token);\n            break;\n        }\n        case $.PRE:\n        case $.LISTING: {\n            preStartTagInBody(p, token);\n            break;\n        }\n        case $.XMP: {\n            xmpStartTagInBody(p, token);\n            break;\n        }\n        case $.SVG: {\n            svgStartTagInBody(p, token);\n            break;\n        }\n        case $.HTML: {\n            htmlStartTagInBody(p, token);\n            break;\n        }\n        case $.BASE:\n        case $.LINK:\n        case $.META:\n        case $.STYLE:\n        case $.TITLE:\n        case $.SCRIPT:\n        case $.BGSOUND:\n        case $.BASEFONT:\n        case $.TEMPLATE: {\n            startTagInHead(p, token);\n            break;\n        }\n        case $.BODY: {\n            bodyStartTagInBody(p, token);\n            break;\n        }\n        case $.FORM: {\n            formStartTagInBody(p, token);\n            break;\n        }\n        case $.NOBR: {\n            nobrStartTagInBody(p, token);\n            break;\n        }\n        case $.MATH: {\n            mathStartTagInBody(p, token);\n            break;\n        }\n        case $.TABLE: {\n            tableStartTagInBody(p, token);\n            break;\n        }\n        case $.INPUT: {\n            inputStartTagInBody(p, token);\n            break;\n        }\n        case $.PARAM:\n        case $.TRACK:\n        case $.SOURCE: {\n            paramStartTagInBody(p, token);\n            break;\n        }\n        case $.IMAGE: {\n            imageStartTagInBody(p, token);\n            break;\n        }\n        case $.BUTTON: {\n            buttonStartTagInBody(p, token);\n            break;\n        }\n        case $.APPLET:\n        case $.OBJECT:\n        case $.MARQUEE: {\n            appletStartTagInBody(p, token);\n            break;\n        }\n        case $.IFRAME: {\n            iframeStartTagInBody(p, token);\n            break;\n        }\n        case $.SELECT: {\n            selectStartTagInBody(p, token);\n            break;\n        }\n        case $.OPTION:\n        case $.OPTGROUP: {\n            optgroupStartTagInBody(p, token);\n            break;\n        }\n        case $.NOEMBED: {\n            noembedStartTagInBody(p, token);\n            break;\n        }\n        case $.FRAMESET: {\n            framesetStartTagInBody(p, token);\n            break;\n        }\n        case $.TEXTAREA: {\n            textareaStartTagInBody(p, token);\n            break;\n        }\n        case $.NOSCRIPT: {\n            if (p.options.scriptingEnabled) {\n                noembedStartTagInBody(p, token);\n            }\n            else {\n                genericStartTagInBody(p, token);\n            }\n            break;\n        }\n        case $.PLAINTEXT: {\n            plaintextStartTagInBody(p, token);\n            break;\n        }\n        case $.COL:\n        case $.TH:\n        case $.TD:\n        case $.TR:\n        case $.HEAD:\n        case $.FRAME:\n        case $.TBODY:\n        case $.TFOOT:\n        case $.THEAD:\n        case $.CAPTION:\n        case $.COLGROUP: {\n            // Ignore token\n            break;\n        }\n        default: {\n            genericStartTagInBody(p, token);\n        }\n    }\n}\nfunction bodyEndTagInBody(p, token) {\n    if (p.openElements.hasInScope($.BODY)) {\n        p.insertionMode = InsertionMode.AFTER_BODY;\n        //NOTE: <body> is never popped from the stack, so we need to updated\n        //the end location explicitly.\n        if (p.options.sourceCodeLocationInfo) {\n            const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();\n            if (bodyElement) {\n                p._setEndLocation(bodyElement, token);\n            }\n        }\n    }\n}\nfunction htmlEndTagInBody(p, token) {\n    if (p.openElements.hasInScope($.BODY)) {\n        p.insertionMode = InsertionMode.AFTER_BODY;\n        endTagAfterBody(p, token);\n    }\n}\nfunction addressEndTagInBody(p, token) {\n    const tn = token.tagID;\n    if (p.openElements.hasInScope(tn)) {\n        p.openElements.generateImpliedEndTags();\n        p.openElements.popUntilTagNamePopped(tn);\n    }\n}\nfunction formEndTagInBody(p) {\n    const inTemplate = p.openElements.tmplCount > 0;\n    const { formElement } = p;\n    if (!inTemplate) {\n        p.formElement = null;\n    }\n    if ((formElement || inTemplate) && p.openElements.hasInScope($.FORM)) {\n        p.openElements.generateImpliedEndTags();\n        if (inTemplate) {\n            p.openElements.popUntilTagNamePopped($.FORM);\n        }\n        else if (formElement) {\n            p.openElements.remove(formElement);\n        }\n    }\n}\nfunction pEndTagInBody(p) {\n    if (!p.openElements.hasInButtonScope($.P)) {\n        p._insertFakeElement(TN.P, $.P);\n    }\n    p._closePElement();\n}\nfunction liEndTagInBody(p) {\n    if (p.openElements.hasInListItemScope($.LI)) {\n        p.openElements.generateImpliedEndTagsWithExclusion($.LI);\n        p.openElements.popUntilTagNamePopped($.LI);\n    }\n}\nfunction ddEndTagInBody(p, token) {\n    const tn = token.tagID;\n    if (p.openElements.hasInScope(tn)) {\n        p.openElements.generateImpliedEndTagsWithExclusion(tn);\n        p.openElements.popUntilTagNamePopped(tn);\n    }\n}\nfunction numberedHeaderEndTagInBody(p) {\n    if (p.openElements.hasNumberedHeaderInScope()) {\n        p.openElements.generateImpliedEndTags();\n        p.openElements.popUntilNumberedHeaderPopped();\n    }\n}\nfunction appletEndTagInBody(p, token) {\n    const tn = token.tagID;\n    if (p.openElements.hasInScope(tn)) {\n        p.openElements.generateImpliedEndTags();\n        p.openElements.popUntilTagNamePopped(tn);\n        p.activeFormattingElements.clearToLastMarker();\n    }\n}\nfunction brEndTagInBody(p) {\n    p._reconstructActiveFormattingElements();\n    p._insertFakeElement(TN.BR, $.BR);\n    p.openElements.pop();\n    p.framesetOk = false;\n}\nfunction genericEndTagInBody(p, token) {\n    const tn = token.tagName;\n    const tid = token.tagID;\n    for (let i = p.openElements.stackTop; i > 0; i--) {\n        const element = p.openElements.items[i];\n        const elementId = p.openElements.tagIDs[i];\n        // Compare the tag name here, as the tag might not be a known tag with an ID.\n        if (tid === elementId && (tid !== $.UNKNOWN || p.treeAdapter.getTagName(element) === tn)) {\n            p.openElements.generateImpliedEndTagsWithExclusion(tid);\n            if (p.openElements.stackTop >= i)\n                p.openElements.shortenToLength(i);\n            break;\n        }\n        if (p._isSpecialElement(element, elementId)) {\n            break;\n        }\n    }\n}\nfunction endTagInBody(p, token) {\n    switch (token.tagID) {\n        case $.A:\n        case $.B:\n        case $.I:\n        case $.S:\n        case $.U:\n        case $.EM:\n        case $.TT:\n        case $.BIG:\n        case $.CODE:\n        case $.FONT:\n        case $.NOBR:\n        case $.SMALL:\n        case $.STRIKE:\n        case $.STRONG: {\n            callAdoptionAgency(p, token);\n            break;\n        }\n        case $.P: {\n            pEndTagInBody(p);\n            break;\n        }\n        case $.DL:\n        case $.UL:\n        case $.OL:\n        case $.DIR:\n        case $.DIV:\n        case $.NAV:\n        case $.PRE:\n        case $.MAIN:\n        case $.MENU:\n        case $.ASIDE:\n        case $.BUTTON:\n        case $.CENTER:\n        case $.FIGURE:\n        case $.FOOTER:\n        case $.HEADER:\n        case $.HGROUP:\n        case $.DIALOG:\n        case $.ADDRESS:\n        case $.ARTICLE:\n        case $.DETAILS:\n        case $.SECTION:\n        case $.SUMMARY:\n        case $.LISTING:\n        case $.FIELDSET:\n        case $.BLOCKQUOTE:\n        case $.FIGCAPTION: {\n            addressEndTagInBody(p, token);\n            break;\n        }\n        case $.LI: {\n            liEndTagInBody(p);\n            break;\n        }\n        case $.DD:\n        case $.DT: {\n            ddEndTagInBody(p, token);\n            break;\n        }\n        case $.H1:\n        case $.H2:\n        case $.H3:\n        case $.H4:\n        case $.H5:\n        case $.H6: {\n            numberedHeaderEndTagInBody(p);\n            break;\n        }\n        case $.BR: {\n            brEndTagInBody(p);\n            break;\n        }\n        case $.BODY: {\n            bodyEndTagInBody(p, token);\n            break;\n        }\n        case $.HTML: {\n            htmlEndTagInBody(p, token);\n            break;\n        }\n        case $.FORM: {\n            formEndTagInBody(p);\n            break;\n        }\n        case $.APPLET:\n        case $.OBJECT:\n        case $.MARQUEE: {\n            appletEndTagInBody(p, token);\n            break;\n        }\n        case $.TEMPLATE: {\n            templateEndTagInHead(p, token);\n            break;\n        }\n        default: {\n            genericEndTagInBody(p, token);\n        }\n    }\n}\nfunction eofInBody(p, token) {\n    if (p.tmplInsertionModeStack.length > 0) {\n        eofInTemplate(p, token);\n    }\n    else {\n        stopParsing(p, token);\n    }\n}\n// The \"text\" insertion mode\n//------------------------------------------------------------------\nfunction endTagInText(p, token) {\n    var _a;\n    if (token.tagID === $.SCRIPT) {\n        (_a = p.scriptHandler) === null || _a === void 0 ? void 0 : _a.call(p, p.openElements.current);\n    }\n    p.openElements.pop();\n    p.insertionMode = p.originalInsertionMode;\n}\nfunction eofInText(p, token) {\n    p._err(token, ERR.eofInElementThatCanContainOnlyText);\n    p.openElements.pop();\n    p.insertionMode = p.originalInsertionMode;\n    p.onEof(token);\n}\n// The \"in table\" insertion mode\n//------------------------------------------------------------------\nfunction characterInTable(p, token) {\n    if (TABLE_STRUCTURE_TAGS.has(p.openElements.currentTagId)) {\n        p.pendingCharacterTokens.length = 0;\n        p.hasNonWhitespacePendingCharacterToken = false;\n        p.originalInsertionMode = p.insertionMode;\n        p.insertionMode = InsertionMode.IN_TABLE_TEXT;\n        switch (token.type) {\n            case TokenType.CHARACTER: {\n                characterInTableText(p, token);\n                break;\n            }\n            case TokenType.WHITESPACE_CHARACTER: {\n                whitespaceCharacterInTableText(p, token);\n                break;\n            }\n            // Ignore null\n        }\n    }\n    else {\n        tokenInTable(p, token);\n    }\n}\nfunction captionStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p.activeFormattingElements.insertMarker();\n    p._insertElement(token, NS.HTML);\n    p.insertionMode = InsertionMode.IN_CAPTION;\n}\nfunction colgroupStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p._insertElement(token, NS.HTML);\n    p.insertionMode = InsertionMode.IN_COLUMN_GROUP;\n}\nfunction colStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p._insertFakeElement(TN.COLGROUP, $.COLGROUP);\n    p.insertionMode = InsertionMode.IN_COLUMN_GROUP;\n    startTagInColumnGroup(p, token);\n}\nfunction tbodyStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p._insertElement(token, NS.HTML);\n    p.insertionMode = InsertionMode.IN_TABLE_BODY;\n}\nfunction tdStartTagInTable(p, token) {\n    p.openElements.clearBackToTableContext();\n    p._insertFakeElement(TN.TBODY, $.TBODY);\n    p.insertionMode = InsertionMode.IN_TABLE_BODY;\n    startTagInTableBody(p, token);\n}\nfunction tableStartTagInTable(p, token) {\n    if (p.openElements.hasInTableScope($.TABLE)) {\n        p.openElements.popUntilTagNamePopped($.TABLE);\n        p._resetInsertionMode();\n        p._processStartTag(token);\n    }\n}\nfunction inputStartTagInTable(p, token) {\n    if (isHiddenInput(token)) {\n        p._appendElement(token, NS.HTML);\n    }\n    else {\n        tokenInTable(p, token);\n    }\n    token.ackSelfClosing = true;\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}\nfunction startTagInTable(p, token) {\n    switch (token.tagID) {\n        case $.TD:\n        case $.TH:\n        case $.TR: {\n            tdStartTagInTable(p, token);\n            break;\n        }\n        case $.STYLE:\n        case $.SCRIPT:\n        case $.TEMPLATE: {\n            startTagInHead(p, token);\n            break;\n        }\n        case $.COL: {\n            colStartTagInTable(p, token);\n            break;\n        }\n        case $.FORM: {\n            formStartTagInTable(p, token);\n            break;\n        }\n        case $.TABLE: {\n            tableStartTagInTable(p, token);\n            break;\n        }\n        case $.TBODY:\n        case $.TFOOT:\n        case $.THEAD: {\n            tbodyStartTagInTable(p, token);\n            break;\n        }\n        case $.INPUT: {\n            inputStartTagInTable(p, token);\n            break;\n        }\n        case $.CAPTION: {\n            captionStartTagInTable(p, token);\n            break;\n        }\n        case $.COLGROUP: {\n            colgroupStartTagInTable(p, token);\n            break;\n        }\n        default: {\n            tokenInTable(p, token);\n        }\n    }\n}\nfunction endTagInTable(p, token) {\n    switch (token.tagID) {\n        case $.TABLE: {\n            if (p.openElements.hasInTableScope($.TABLE)) {\n                p.openElements.popUntilTagNamePopped($.TABLE);\n                p._resetInsertionMode();\n            }\n            break;\n        }\n        case $.TEMPLATE: {\n            templateEndTagInHead(p, token);\n            break;\n        }\n        case $.BODY:\n        case $.CAPTION:\n        case $.COL:\n        case $.COLGROUP:\n        case $.HTML:\n        case $.TBODY:\n        case $.TD:\n        case $.TFOOT:\n        case $.TH:\n        case $.THEAD:\n        case $.TR: {\n            // Ignore token\n            break;\n        }\n        default: {\n            tokenInTable(p, token);\n        }\n    }\n}\nfunction tokenInTable(p, token) {\n    const savedFosterParentingState = p.fosterParentingEnabled;\n    p.fosterParentingEnabled = true;\n    // Process token in `In Body` mode\n    modeInBody(p, token);\n    p.fosterParentingEnabled = savedFosterParentingState;\n}\n// The \"in table text\" insertion mode\n//------------------------------------------------------------------\nfunction whitespaceCharacterInTableText(p, token) {\n    p.pendingCharacterTokens.push(token);\n}\nfunction characterInTableText(p, token) {\n    p.pendingCharacterTokens.push(token);\n    p.hasNonWhitespacePendingCharacterToken = true;\n}\nfunction tokenInTableText(p, token) {\n    let i = 0;\n    if (p.hasNonWhitespacePendingCharacterToken) {\n        for (; i < p.pendingCharacterTokens.length; i++) {\n            tokenInTable(p, p.pendingCharacterTokens[i]);\n        }\n    }\n    else {\n        for (; i < p.pendingCharacterTokens.length; i++) {\n            p._insertCharacters(p.pendingCharacterTokens[i]);\n        }\n    }\n    p.insertionMode = p.originalInsertionMode;\n    p._processToken(token);\n}\n// The \"in caption\" insertion mode\n//------------------------------------------------------------------\nconst TABLE_VOID_ELEMENTS = new Set([$.CAPTION, $.COL, $.COLGROUP, $.TBODY, $.TD, $.TFOOT, $.TH, $.THEAD, $.TR]);\nfunction startTagInCaption(p, token) {\n    const tn = token.tagID;\n    if (TABLE_VOID_ELEMENTS.has(tn)) {\n        if (p.openElements.hasInTableScope($.CAPTION)) {\n            p.openElements.generateImpliedEndTags();\n            p.openElements.popUntilTagNamePopped($.CAPTION);\n            p.activeFormattingElements.clearToLastMarker();\n            p.insertionMode = InsertionMode.IN_TABLE;\n            startTagInTable(p, token);\n        }\n    }\n    else {\n        startTagInBody(p, token);\n    }\n}\nfunction endTagInCaption(p, token) {\n    const tn = token.tagID;\n    switch (tn) {\n        case $.CAPTION:\n        case $.TABLE: {\n            if (p.openElements.hasInTableScope($.CAPTION)) {\n                p.openElements.generateImpliedEndTags();\n                p.openElements.popUntilTagNamePopped($.CAPTION);\n                p.activeFormattingElements.clearToLastMarker();\n                p.insertionMode = InsertionMode.IN_TABLE;\n                if (tn === $.TABLE) {\n                    endTagInTable(p, token);\n                }\n            }\n            break;\n        }\n        case $.BODY:\n        case $.COL:\n        case $.COLGROUP:\n        case $.HTML:\n        case $.TBODY:\n        case $.TD:\n        case $.TFOOT:\n        case $.TH:\n        case $.THEAD:\n        case $.TR: {\n            // Ignore token\n            break;\n        }\n        default: {\n            endTagInBody(p, token);\n        }\n    }\n}\n// The \"in column group\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInColumnGroup(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.COL: {\n            p._appendElement(token, NS.HTML);\n            token.ackSelfClosing = true;\n            break;\n        }\n        case $.TEMPLATE: {\n            startTagInHead(p, token);\n            break;\n        }\n        default: {\n            tokenInColumnGroup(p, token);\n        }\n    }\n}\nfunction endTagInColumnGroup(p, token) {\n    switch (token.tagID) {\n        case $.COLGROUP: {\n            if (p.openElements.currentTagId === $.COLGROUP) {\n                p.openElements.pop();\n                p.insertionMode = InsertionMode.IN_TABLE;\n            }\n            break;\n        }\n        case $.TEMPLATE: {\n            templateEndTagInHead(p, token);\n            break;\n        }\n        case $.COL: {\n            // Ignore token\n            break;\n        }\n        default: {\n            tokenInColumnGroup(p, token);\n        }\n    }\n}\nfunction tokenInColumnGroup(p, token) {\n    if (p.openElements.currentTagId === $.COLGROUP) {\n        p.openElements.pop();\n        p.insertionMode = InsertionMode.IN_TABLE;\n        p._processToken(token);\n    }\n}\n// The \"in table body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInTableBody(p, token) {\n    switch (token.tagID) {\n        case $.TR: {\n            p.openElements.clearBackToTableBodyContext();\n            p._insertElement(token, NS.HTML);\n            p.insertionMode = InsertionMode.IN_ROW;\n            break;\n        }\n        case $.TH:\n        case $.TD: {\n            p.openElements.clearBackToTableBodyContext();\n            p._insertFakeElement(TN.TR, $.TR);\n            p.insertionMode = InsertionMode.IN_ROW;\n            startTagInRow(p, token);\n            break;\n        }\n        case $.CAPTION:\n        case $.COL:\n        case $.COLGROUP:\n        case $.TBODY:\n        case $.TFOOT:\n        case $.THEAD: {\n            if (p.openElements.hasTableBodyContextInTableScope()) {\n                p.openElements.clearBackToTableBodyContext();\n                p.openElements.pop();\n                p.insertionMode = InsertionMode.IN_TABLE;\n                startTagInTable(p, token);\n            }\n            break;\n        }\n        default: {\n            startTagInTable(p, token);\n        }\n    }\n}\nfunction endTagInTableBody(p, token) {\n    const tn = token.tagID;\n    switch (token.tagID) {\n        case $.TBODY:\n        case $.TFOOT:\n        case $.THEAD: {\n            if (p.openElements.hasInTableScope(tn)) {\n                p.openElements.clearBackToTableBodyContext();\n                p.openElements.pop();\n                p.insertionMode = InsertionMode.IN_TABLE;\n            }\n            break;\n        }\n        case $.TABLE: {\n            if (p.openElements.hasTableBodyContextInTableScope()) {\n                p.openElements.clearBackToTableBodyContext();\n                p.openElements.pop();\n                p.insertionMode = InsertionMode.IN_TABLE;\n                endTagInTable(p, token);\n            }\n            break;\n        }\n        case $.BODY:\n        case $.CAPTION:\n        case $.COL:\n        case $.COLGROUP:\n        case $.HTML:\n        case $.TD:\n        case $.TH:\n        case $.TR: {\n            // Ignore token\n            break;\n        }\n        default: {\n            endTagInTable(p, token);\n        }\n    }\n}\n// The \"in row\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInRow(p, token) {\n    switch (token.tagID) {\n        case $.TH:\n        case $.TD: {\n            p.openElements.clearBackToTableRowContext();\n            p._insertElement(token, NS.HTML);\n            p.insertionMode = InsertionMode.IN_CELL;\n            p.activeFormattingElements.insertMarker();\n            break;\n        }\n        case $.CAPTION:\n        case $.COL:\n        case $.COLGROUP:\n        case $.TBODY:\n        case $.TFOOT:\n        case $.THEAD:\n        case $.TR: {\n            if (p.openElements.hasInTableScope($.TR)) {\n                p.openElements.clearBackToTableRowContext();\n                p.openElements.pop();\n                p.insertionMode = InsertionMode.IN_TABLE_BODY;\n                startTagInTableBody(p, token);\n            }\n            break;\n        }\n        default: {\n            startTagInTable(p, token);\n        }\n    }\n}\nfunction endTagInRow(p, token) {\n    switch (token.tagID) {\n        case $.TR: {\n            if (p.openElements.hasInTableScope($.TR)) {\n                p.openElements.clearBackToTableRowContext();\n                p.openElements.pop();\n                p.insertionMode = InsertionMode.IN_TABLE_BODY;\n            }\n            break;\n        }\n        case $.TABLE: {\n            if (p.openElements.hasInTableScope($.TR)) {\n                p.openElements.clearBackToTableRowContext();\n                p.openElements.pop();\n                p.insertionMode = InsertionMode.IN_TABLE_BODY;\n                endTagInTableBody(p, token);\n            }\n            break;\n        }\n        case $.TBODY:\n        case $.TFOOT:\n        case $.THEAD: {\n            if (p.openElements.hasInTableScope(token.tagID) || p.openElements.hasInTableScope($.TR)) {\n                p.openElements.clearBackToTableRowContext();\n                p.openElements.pop();\n                p.insertionMode = InsertionMode.IN_TABLE_BODY;\n                endTagInTableBody(p, token);\n            }\n            break;\n        }\n        case $.BODY:\n        case $.CAPTION:\n        case $.COL:\n        case $.COLGROUP:\n        case $.HTML:\n        case $.TD:\n        case $.TH: {\n            // Ignore end tag\n            break;\n        }\n        default: {\n            endTagInTable(p, token);\n        }\n    }\n}\n// The \"in cell\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInCell(p, token) {\n    const tn = token.tagID;\n    if (TABLE_VOID_ELEMENTS.has(tn)) {\n        if (p.openElements.hasInTableScope($.TD) || p.openElements.hasInTableScope($.TH)) {\n            p._closeTableCell();\n            startTagInRow(p, token);\n        }\n    }\n    else {\n        startTagInBody(p, token);\n    }\n}\nfunction endTagInCell(p, token) {\n    const tn = token.tagID;\n    switch (tn) {\n        case $.TD:\n        case $.TH: {\n            if (p.openElements.hasInTableScope(tn)) {\n                p.openElements.generateImpliedEndTags();\n                p.openElements.popUntilTagNamePopped(tn);\n                p.activeFormattingElements.clearToLastMarker();\n                p.insertionMode = InsertionMode.IN_ROW;\n            }\n            break;\n        }\n        case $.TABLE:\n        case $.TBODY:\n        case $.TFOOT:\n        case $.THEAD:\n        case $.TR: {\n            if (p.openElements.hasInTableScope(tn)) {\n                p._closeTableCell();\n                endTagInRow(p, token);\n            }\n            break;\n        }\n        case $.BODY:\n        case $.CAPTION:\n        case $.COL:\n        case $.COLGROUP:\n        case $.HTML: {\n            // Ignore token\n            break;\n        }\n        default: {\n            endTagInBody(p, token);\n        }\n    }\n}\n// The \"in select\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInSelect(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.OPTION: {\n            if (p.openElements.currentTagId === $.OPTION) {\n                p.openElements.pop();\n            }\n            p._insertElement(token, NS.HTML);\n            break;\n        }\n        case $.OPTGROUP: {\n            if (p.openElements.currentTagId === $.OPTION) {\n                p.openElements.pop();\n            }\n            if (p.openElements.currentTagId === $.OPTGROUP) {\n                p.openElements.pop();\n            }\n            p._insertElement(token, NS.HTML);\n            break;\n        }\n        case $.INPUT:\n        case $.KEYGEN:\n        case $.TEXTAREA:\n        case $.SELECT: {\n            if (p.openElements.hasInSelectScope($.SELECT)) {\n                p.openElements.popUntilTagNamePopped($.SELECT);\n                p._resetInsertionMode();\n                if (token.tagID !== $.SELECT) {\n                    p._processStartTag(token);\n                }\n            }\n            break;\n        }\n        case $.SCRIPT:\n        case $.TEMPLATE: {\n            startTagInHead(p, token);\n            break;\n        }\n        default:\n        // Do nothing\n    }\n}\nfunction endTagInSelect(p, token) {\n    switch (token.tagID) {\n        case $.OPTGROUP: {\n            if (p.openElements.stackTop > 0 &&\n                p.openElements.currentTagId === $.OPTION &&\n                p.openElements.tagIDs[p.openElements.stackTop - 1] === $.OPTGROUP) {\n                p.openElements.pop();\n            }\n            if (p.openElements.currentTagId === $.OPTGROUP) {\n                p.openElements.pop();\n            }\n            break;\n        }\n        case $.OPTION: {\n            if (p.openElements.currentTagId === $.OPTION) {\n                p.openElements.pop();\n            }\n            break;\n        }\n        case $.SELECT: {\n            if (p.openElements.hasInSelectScope($.SELECT)) {\n                p.openElements.popUntilTagNamePopped($.SELECT);\n                p._resetInsertionMode();\n            }\n            break;\n        }\n        case $.TEMPLATE: {\n            templateEndTagInHead(p, token);\n            break;\n        }\n        default:\n        // Do nothing\n    }\n}\n// The \"in select in table\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInSelectInTable(p, token) {\n    const tn = token.tagID;\n    if (tn === $.CAPTION ||\n        tn === $.TABLE ||\n        tn === $.TBODY ||\n        tn === $.TFOOT ||\n        tn === $.THEAD ||\n        tn === $.TR ||\n        tn === $.TD ||\n        tn === $.TH) {\n        p.openElements.popUntilTagNamePopped($.SELECT);\n        p._resetInsertionMode();\n        p._processStartTag(token);\n    }\n    else {\n        startTagInSelect(p, token);\n    }\n}\nfunction endTagInSelectInTable(p, token) {\n    const tn = token.tagID;\n    if (tn === $.CAPTION ||\n        tn === $.TABLE ||\n        tn === $.TBODY ||\n        tn === $.TFOOT ||\n        tn === $.THEAD ||\n        tn === $.TR ||\n        tn === $.TD ||\n        tn === $.TH) {\n        if (p.openElements.hasInTableScope(tn)) {\n            p.openElements.popUntilTagNamePopped($.SELECT);\n            p._resetInsertionMode();\n            p.onEndTag(token);\n        }\n    }\n    else {\n        endTagInSelect(p, token);\n    }\n}\n// The \"in template\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInTemplate(p, token) {\n    switch (token.tagID) {\n        // First, handle tags that can start without a mode change\n        case $.BASE:\n        case $.BASEFONT:\n        case $.BGSOUND:\n        case $.LINK:\n        case $.META:\n        case $.NOFRAMES:\n        case $.SCRIPT:\n        case $.STYLE:\n        case $.TEMPLATE:\n        case $.TITLE: {\n            startTagInHead(p, token);\n            break;\n        }\n        // Re-process the token in the appropriate mode\n        case $.CAPTION:\n        case $.COLGROUP:\n        case $.TBODY:\n        case $.TFOOT:\n        case $.THEAD: {\n            p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE;\n            p.insertionMode = InsertionMode.IN_TABLE;\n            startTagInTable(p, token);\n            break;\n        }\n        case $.COL: {\n            p.tmplInsertionModeStack[0] = InsertionMode.IN_COLUMN_GROUP;\n            p.insertionMode = InsertionMode.IN_COLUMN_GROUP;\n            startTagInColumnGroup(p, token);\n            break;\n        }\n        case $.TR: {\n            p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE_BODY;\n            p.insertionMode = InsertionMode.IN_TABLE_BODY;\n            startTagInTableBody(p, token);\n            break;\n        }\n        case $.TD:\n        case $.TH: {\n            p.tmplInsertionModeStack[0] = InsertionMode.IN_ROW;\n            p.insertionMode = InsertionMode.IN_ROW;\n            startTagInRow(p, token);\n            break;\n        }\n        default: {\n            p.tmplInsertionModeStack[0] = InsertionMode.IN_BODY;\n            p.insertionMode = InsertionMode.IN_BODY;\n            startTagInBody(p, token);\n        }\n    }\n}\nfunction endTagInTemplate(p, token) {\n    if (token.tagID === $.TEMPLATE) {\n        templateEndTagInHead(p, token);\n    }\n}\nfunction eofInTemplate(p, token) {\n    if (p.openElements.tmplCount > 0) {\n        p.openElements.popUntilTagNamePopped($.TEMPLATE);\n        p.activeFormattingElements.clearToLastMarker();\n        p.tmplInsertionModeStack.shift();\n        p._resetInsertionMode();\n        p.onEof(token);\n    }\n    else {\n        stopParsing(p, token);\n    }\n}\n// The \"after body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterBody(p, token) {\n    if (token.tagID === $.HTML) {\n        startTagInBody(p, token);\n    }\n    else {\n        tokenAfterBody(p, token);\n    }\n}\nfunction endTagAfterBody(p, token) {\n    var _a;\n    if (token.tagID === $.HTML) {\n        if (!p.fragmentContext) {\n            p.insertionMode = InsertionMode.AFTER_AFTER_BODY;\n        }\n        //NOTE: <html> is never popped from the stack, so we need to updated\n        //the end location explicitly.\n        if (p.options.sourceCodeLocationInfo && p.openElements.tagIDs[0] === $.HTML) {\n            p._setEndLocation(p.openElements.items[0], token);\n            // Update the body element, if it doesn't have an end tag\n            const bodyElement = p.openElements.items[1];\n            if (bodyElement && !((_a = p.treeAdapter.getNodeSourceCodeLocation(bodyElement)) === null || _a === void 0 ? void 0 : _a.endTag)) {\n                p._setEndLocation(bodyElement, token);\n            }\n        }\n    }\n    else {\n        tokenAfterBody(p, token);\n    }\n}\nfunction tokenAfterBody(p, token) {\n    p.insertionMode = InsertionMode.IN_BODY;\n    modeInBody(p, token);\n}\n// The \"in frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInFrameset(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.FRAMESET: {\n            p._insertElement(token, NS.HTML);\n            break;\n        }\n        case $.FRAME: {\n            p._appendElement(token, NS.HTML);\n            token.ackSelfClosing = true;\n            break;\n        }\n        case $.NOFRAMES: {\n            startTagInHead(p, token);\n            break;\n        }\n        default:\n        // Do nothing\n    }\n}\nfunction endTagInFrameset(p, token) {\n    if (token.tagID === $.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {\n        p.openElements.pop();\n        if (!p.fragmentContext && p.openElements.currentTagId !== $.FRAMESET) {\n            p.insertionMode = InsertionMode.AFTER_FRAMESET;\n        }\n    }\n}\n// The \"after frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterFrameset(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.NOFRAMES: {\n            startTagInHead(p, token);\n            break;\n        }\n        default:\n        // Do nothing\n    }\n}\nfunction endTagAfterFrameset(p, token) {\n    if (token.tagID === $.HTML) {\n        p.insertionMode = InsertionMode.AFTER_AFTER_FRAMESET;\n    }\n}\n// The \"after after body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterAfterBody(p, token) {\n    if (token.tagID === $.HTML) {\n        startTagInBody(p, token);\n    }\n    else {\n        tokenAfterAfterBody(p, token);\n    }\n}\nfunction tokenAfterAfterBody(p, token) {\n    p.insertionMode = InsertionMode.IN_BODY;\n    modeInBody(p, token);\n}\n// The \"after after frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterAfterFrameset(p, token) {\n    switch (token.tagID) {\n        case $.HTML: {\n            startTagInBody(p, token);\n            break;\n        }\n        case $.NOFRAMES: {\n            startTagInHead(p, token);\n            break;\n        }\n        default:\n        // Do nothing\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}\nfunction characterInForeignContent(p, token) {\n    p._insertCharacters(token);\n    p.framesetOk = false;\n}\nfunction popUntilHtmlOrIntegrationPoint(p) {\n    while (p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML &&\n        !p._isIntegrationPoint(p.openElements.currentTagId, p.openElements.current)) {\n        p.openElements.pop();\n    }\n}\nfunction startTagInForeignContent(p, token) {\n    if (foreignContent.causesExit(token)) {\n        popUntilHtmlOrIntegrationPoint(p);\n        p._startTagOutsideForeignContent(token);\n    }\n    else {\n        const current = p._getAdjustedCurrentElement();\n        const currentNs = p.treeAdapter.getNamespaceURI(current);\n        if (currentNs === NS.MATHML) {\n            foreignContent.adjustTokenMathMLAttrs(token);\n        }\n        else if (currentNs === NS.SVG) {\n            foreignContent.adjustTokenSVGTagName(token);\n            foreignContent.adjustTokenSVGAttrs(token);\n        }\n        foreignContent.adjustTokenXMLAttrs(token);\n        if (token.selfClosing) {\n            p._appendElement(token, currentNs);\n        }\n        else {\n            p._insertElement(token, currentNs);\n        }\n        token.ackSelfClosing = true;\n    }\n}\nfunction endTagInForeignContent(p, token) {\n    if (token.tagID === $.P || token.tagID === $.BR) {\n        popUntilHtmlOrIntegrationPoint(p);\n        p._endTagOutsideForeignContent(token);\n        return;\n    }\n    for (let i = p.openElements.stackTop; i > 0; i--) {\n        const element = p.openElements.items[i];\n        if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {\n            p._endTagOutsideForeignContent(token);\n            break;\n        }\n        const tagName = p.treeAdapter.getTagName(element);\n        if (tagName.toLowerCase() === token.tagName) {\n            //NOTE: update the token tag name for `_setEndLocation`.\n            token.tagName = tagName;\n            p.openElements.shortenToLength(i);\n            break;\n        }\n    }\n}\n//# sourceMappingURL=index.js.map","export const xmlReplacer = /[\"&'<>$\\x80-\\uFFFF]/g;\nconst xmlCodeMap = new Map([\n    [34, \"&quot;\"],\n    [38, \"&amp;\"],\n    [39, \"&apos;\"],\n    [60, \"&lt;\"],\n    [62, \"&gt;\"],\n]);\n// For compatibility with node < 4, we wrap `codePointAt`\nexport const getCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.prototype.codePointAt != null\n    ? (str, index) => str.codePointAt(index)\n    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n        (c, index) => (c.charCodeAt(index) & 0xfc00) === 0xd800\n            ? (c.charCodeAt(index) - 0xd800) * 0x400 +\n                c.charCodeAt(index + 1) -\n                0xdc00 +\n                0x10000\n            : c.charCodeAt(index);\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using XML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexport function encodeXML(str) {\n    let ret = \"\";\n    let lastIdx = 0;\n    let match;\n    while ((match = xmlReplacer.exec(str)) !== null) {\n        const i = match.index;\n        const char = str.charCodeAt(i);\n        const next = xmlCodeMap.get(char);\n        if (next !== undefined) {\n            ret += str.substring(lastIdx, i) + next;\n            lastIdx = i + 1;\n        }\n        else {\n            ret += `${str.substring(lastIdx, i)}&#x${getCodePoint(str, i).toString(16)};`;\n            // Increase by 1 if we have a surrogate pair\n            lastIdx = xmlReplacer.lastIndex += Number((char & 0xfc00) === 0xd800);\n        }\n    }\n    return ret + str.substr(lastIdx);\n}\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using numeric hexadecimal reference (eg. `&#xfc;`).\n *\n * Have a look at `escapeUTF8` if you want a more concise output at the expense\n * of reduced transportability.\n *\n * @param data String to escape.\n */\nexport const escape = encodeXML;\n/**\n * Creates a function that escapes all characters matched by the given regular\n * expression using the given map of characters to escape to their entities.\n *\n * @param regex Regular expression to match characters to escape.\n * @param map Map of characters to escape to their entities.\n *\n * @returns Function that escapes all characters matched by the given regular\n * expression using the given map of characters to escape to their entities.\n */\nfunction getEscaper(regex, map) {\n    return function escape(data) {\n        let match;\n        let lastIdx = 0;\n        let result = \"\";\n        while ((match = regex.exec(data))) {\n            if (lastIdx !== match.index) {\n                result += data.substring(lastIdx, match.index);\n            }\n            // We know that this character will be in the map.\n            result += map.get(match[0].charCodeAt(0));\n            // Every match will be of length 1\n            lastIdx = match.index + 1;\n        }\n        return result + data.substring(lastIdx);\n    };\n}\n/**\n * Encodes all characters not valid in XML documents using XML entities.\n *\n * Note that the output will be character-set dependent.\n *\n * @param data String to escape.\n */\nexport const escapeUTF8 = getEscaper(/[&<>'\"]/g, xmlCodeMap);\n/**\n * Encodes all characters that have to be escaped in HTML attributes,\n * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n *\n * @param data String to escape.\n */\nexport const escapeAttribute = getEscaper(/[\"&\\u00A0]/g, new Map([\n    [34, \"&quot;\"],\n    [38, \"&amp;\"],\n    [160, \"&nbsp;\"],\n]));\n/**\n * Encodes all characters that have to be escaped in HTML text,\n * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n *\n * @param data String to escape.\n */\nexport const escapeText = getEscaper(/[&<>\\u00A0]/g, new Map([\n    [38, \"&amp;\"],\n    [60, \"&lt;\"],\n    [62, \"&gt;\"],\n    [160, \"&nbsp;\"],\n]));\n//# sourceMappingURL=escape.js.map","import { TAG_NAMES as $, NS, hasUnescapedText } from '../common/html.js';\nimport { escapeText, escapeAttribute } from 'entities/lib/escape.js';\nimport { defaultTreeAdapter } from '../tree-adapters/default.js';\n// Sets\nconst VOID_ELEMENTS = new Set([\n    $.AREA,\n    $.BASE,\n    $.BASEFONT,\n    $.BGSOUND,\n    $.BR,\n    $.COL,\n    $.EMBED,\n    $.FRAME,\n    $.HR,\n    $.IMG,\n    $.INPUT,\n    $.KEYGEN,\n    $.LINK,\n    $.META,\n    $.PARAM,\n    $.SOURCE,\n    $.TRACK,\n    $.WBR,\n]);\nfunction isVoidElement(node, options) {\n    return (options.treeAdapter.isElementNode(node) &&\n        options.treeAdapter.getNamespaceURI(node) === NS.HTML &&\n        VOID_ELEMENTS.has(options.treeAdapter.getTagName(node)));\n}\nconst defaultOpts = { treeAdapter: defaultTreeAdapter, scriptingEnabled: true };\n/**\n * Serializes an AST node to an HTML string.\n *\n * @example\n *\n * ```js\n * const parse5 = require('parse5');\n *\n * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');\n *\n * // Serializes a document.\n * const html = parse5.serialize(document);\n *\n * // Serializes the <html> element content.\n * const str = parse5.serialize(document.childNodes[1]);\n *\n * console.log(str); //> '<head></head><body>Hi there!</body>'\n * ```\n *\n * @param node Node to serialize.\n * @param options Serialization options.\n */\nexport function serialize(node, options) {\n    const opts = { ...defaultOpts, ...options };\n    if (isVoidElement(node, opts)) {\n        return '';\n    }\n    return serializeChildNodes(node, opts);\n}\n/**\n * Serializes an AST element node to an HTML string, including the element node.\n *\n * @example\n *\n * ```js\n * const parse5 = require('parse5');\n *\n * const document = parse5.parseFragment('<div>Hello, <b>world</b>!</div>');\n *\n * // Serializes the <div> element.\n * const html = parse5.serializeOuter(document.childNodes[0]);\n *\n * console.log(str); //> '<div>Hello, <b>world</b>!</div>'\n * ```\n *\n * @param node Node to serialize.\n * @param options Serialization options.\n */\nexport function serializeOuter(node, options) {\n    const opts = { ...defaultOpts, ...options };\n    return serializeNode(node, opts);\n}\nfunction serializeChildNodes(parentNode, options) {\n    let html = '';\n    // Get container of the child nodes\n    const container = options.treeAdapter.isElementNode(parentNode) &&\n        options.treeAdapter.getTagName(parentNode) === $.TEMPLATE &&\n        options.treeAdapter.getNamespaceURI(parentNode) === NS.HTML\n        ? options.treeAdapter.getTemplateContent(parentNode)\n        : parentNode;\n    const childNodes = options.treeAdapter.getChildNodes(container);\n    if (childNodes) {\n        for (const currentNode of childNodes) {\n            html += serializeNode(currentNode, options);\n        }\n    }\n    return html;\n}\nfunction serializeNode(node, options) {\n    if (options.treeAdapter.isElementNode(node)) {\n        return serializeElement(node, options);\n    }\n    if (options.treeAdapter.isTextNode(node)) {\n        return serializeTextNode(node, options);\n    }\n    if (options.treeAdapter.isCommentNode(node)) {\n        return serializeCommentNode(node, options);\n    }\n    if (options.treeAdapter.isDocumentTypeNode(node)) {\n        return serializeDocumentTypeNode(node, options);\n    }\n    // Return an empty string for unknown nodes\n    return '';\n}\nfunction serializeElement(node, options) {\n    const tn = options.treeAdapter.getTagName(node);\n    return `<${tn}${serializeAttributes(node, options)}>${isVoidElement(node, options) ? '' : `${serializeChildNodes(node, options)}</${tn}>`}`;\n}\nfunction serializeAttributes(node, { treeAdapter }) {\n    let html = '';\n    for (const attr of treeAdapter.getAttrList(node)) {\n        html += ' ';\n        if (!attr.namespace) {\n            html += attr.name;\n        }\n        else\n            switch (attr.namespace) {\n                case NS.XML: {\n                    html += `xml:${attr.name}`;\n                    break;\n                }\n                case NS.XMLNS: {\n                    if (attr.name !== 'xmlns') {\n                        html += 'xmlns:';\n                    }\n                    html += attr.name;\n                    break;\n                }\n                case NS.XLINK: {\n                    html += `xlink:${attr.name}`;\n                    break;\n                }\n                default: {\n                    html += `${attr.prefix}:${attr.name}`;\n                }\n            }\n        html += `=\"${escapeAttribute(attr.value)}\"`;\n    }\n    return html;\n}\nfunction serializeTextNode(node, options) {\n    const { treeAdapter } = options;\n    const content = treeAdapter.getTextNodeContent(node);\n    const parent = treeAdapter.getParentNode(node);\n    const parentTn = parent && treeAdapter.isElementNode(parent) && treeAdapter.getTagName(parent);\n    return parentTn &&\n        treeAdapter.getNamespaceURI(parent) === NS.HTML &&\n        hasUnescapedText(parentTn, options.scriptingEnabled)\n        ? content\n        : escapeText(content);\n}\nfunction serializeCommentNode(node, { treeAdapter }) {\n    return `<!--${treeAdapter.getCommentNodeContent(node)}-->`;\n}\nfunction serializeDocumentTypeNode(node, { treeAdapter }) {\n    return `<!DOCTYPE ${treeAdapter.getDocumentTypeNodeName(node)}>`;\n}\n//# sourceMappingURL=index.js.map","import { Parser } from './parser/index.js';\nexport { defaultTreeAdapter } from './tree-adapters/default.js';\nexport { /** @internal */ Parser } from './parser/index.js';\nexport { serialize, serializeOuter } from './serializer/index.js';\nexport { ERR as ErrorCodes } from './common/error-codes.js';\n/** @internal */\nexport * as foreignContent from './common/foreign-content.js';\n/** @internal */\nexport * as html from './common/html.js';\n/** @internal */\nexport * as Token from './common/token.js';\n/** @internal */\nexport { Tokenizer, TokenizerMode } from './tokenizer/index.js';\n// Shorthands\n/**\n * Parses an HTML string.\n *\n * @param html Input HTML string.\n * @param options Parsing options.\n * @returns Document\n *\n * @example\n *\n * ```js\n * const parse5 = require('parse5');\n *\n * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');\n *\n * console.log(document.childNodes[1].tagName); //> 'html'\n *```\n */\nexport function parse(html, options) {\n    return Parser.parse(html, options);\n}\nexport function parseFragment(fragmentContext, html, options) {\n    if (typeof fragmentContext === 'string') {\n        options = html;\n        html = fragmentContext;\n        fragmentContext = null;\n    }\n    const parser = Parser.getFragmentParser(fragmentContext, options);\n    parser.tokenizer.write(html, true);\n    return parser.getFragment();\n}\n//# sourceMappingURL=index.js.map","/**\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Doctype} Doctype\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').RootContent} RootContent\n * @typedef {import('hast').Text} Text\n *\n * @typedef {import('hast-util-raw').Options} Options\n *\n * @typedef {import('mdast-util-to-hast').Raw} Raw\n *\n * @typedef {import('parse5').DefaultTreeAdapterMap} DefaultTreeAdapterMap\n * @typedef {import('parse5').ParserOptions<DefaultTreeAdapterMap>} ParserOptions\n * @typedef {import('parse5').Token.CharacterToken} CharacterToken\n * @typedef {import('parse5').Token.CommentToken} CommentToken\n * @typedef {import('parse5').Token.DoctypeToken} DoctypeToken\n * @typedef {import('parse5').Token.Location} Location\n * @typedef {import('parse5').Token.TagToken} TagToken\n *\n * @typedef {import('unist').Point} Point\n */\n\n/**\n * @typedef State\n *   Info passed around about the current state.\n * @property {(node: Nodes) => undefined} handle\n *   Add a hast node to the parser.\n * @property {Options} options\n *   User configuration.\n * @property {Parser<DefaultTreeAdapterMap>} parser\n *   Current parser.\n * @property {boolean} stitches\n *   Whether there are stitches.\n */\n\n/**\n * @typedef Stitch\n *   Custom comment-like value we pass through parse5, which contains a\n *   replacement node that we’ll swap back in afterwards.\n * @property {'comment'} type\n *   Node type.\n * @property {{stitch: Nodes}} value\n *   Replacement value.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {fromParse5} from 'hast-util-from-parse5'\nimport {toParse5} from 'hast-util-to-parse5'\nimport {htmlVoidElements} from 'html-void-elements'\nimport {Parser, Token, TokenizerMode, html} from 'parse5'\nimport {pointEnd, pointStart} from 'unist-util-position'\nimport {visit} from 'unist-util-visit'\nimport {webNamespaces} from 'web-namespaces'\nimport {zwitch} from 'zwitch'\n\n// Node types associated with MDX.\n// <https://github.com/mdx-js/mdx/blob/8a56312/packages/mdx/lib/node-types.js>\nconst knownMdxNames = new Set([\n  'mdxFlowExpression',\n  'mdxJsxFlowElement',\n  'mdxJsxTextElement',\n  'mdxTextExpression',\n  'mdxjsEsm'\n])\n\n/** @type {ParserOptions} */\nconst parseOptions = {sourceCodeLocationInfo: true, scriptingEnabled: false}\n\n/**\n * Pass a hast tree through an HTML parser, which will fix nesting, and turn\n * raw nodes into actual nodes.\n *\n * @param {Nodes} tree\n *   Original hast tree to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {Nodes}\n *   Parsed again tree.\n */\nexport function raw(tree, options) {\n  const document = documentMode(tree)\n  /** @type {(node: Nodes, state: State) => undefined} */\n  const one = zwitch('type', {\n    handlers: {root, element, text, comment, doctype, raw: handleRaw},\n    unknown\n  })\n\n  /** @type {State} */\n  const state = {\n    parser: document\n      ? new Parser(parseOptions)\n      : Parser.getFragmentParser(undefined, parseOptions),\n    handle(node) {\n      one(node, state)\n    },\n    stitches: false,\n    options: options || {}\n  }\n\n  one(tree, state)\n  resetTokenizer(state, pointStart())\n\n  const p5 = document ? state.parser.document : state.parser.getFragment()\n  const result = fromParse5(p5, {\n    // To do: support `space`?\n    file: state.options.file\n  })\n\n  if (state.stitches) {\n    visit(result, 'comment', function (node, index, parent) {\n      const stitch = /** @type {Stitch} */ (/** @type {unknown} */ (node))\n      if (stitch.value.stitch && parent && index !== undefined) {\n        /** @type {Array<RootContent>} */\n        const siblings = parent.children\n        // @ts-expect-error: assume the stitch is allowed.\n        siblings[index] = stitch.value.stitch\n        return index\n      }\n    })\n  }\n\n  // Unpack if possible and when not given a `root`.\n  if (\n    result.type === 'root' &&\n    result.children.length === 1 &&\n    result.children[0].type === tree.type\n  ) {\n    return result.children[0]\n  }\n\n  return result\n}\n\n/**\n * Transform all nodes\n *\n * @param {Array<RootContent>} nodes\n *   hast content.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction all(nodes, state) {\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      state.handle(nodes[index])\n    }\n  }\n}\n\n/**\n * Transform a root.\n *\n * @param {Root} node\n *   hast root node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction root(node, state) {\n  all(node.children, state)\n}\n\n/**\n * Transform an element.\n *\n * @param {Element} node\n *   hast element node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction element(node, state) {\n  startTag(node, state)\n\n  all(node.children, state)\n\n  endTag(node, state)\n}\n\n/**\n * Transform a text.\n *\n * @param {Text} node\n *   hast text node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction text(node, state) {\n  // Allow `DATA` through `PLAINTEXT`,\n  // but when hanging in a tag for example,\n  // switch back to `DATA`.\n  // Note: `State` is not exposed by `parse5`, so these numbers are fragile.\n  // See: <https://github.com/inikulin/parse5/blob/46cba43/packages/parse5/lib/tokenizer/index.ts#L58>\n  if (state.parser.tokenizer.state > 4) {\n    state.parser.tokenizer.state = 0\n  }\n\n  /** @type {CharacterToken} */\n  const token = {\n    type: Token.TokenType.CHARACTER,\n    chars: node.value,\n    location: createParse5Location(node)\n  }\n\n  resetTokenizer(state, pointStart(node))\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = token\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken)\n}\n\n/**\n * Transform a doctype.\n *\n * @param {Doctype} node\n *   hast doctype node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction doctype(node, state) {\n  /** @type {DoctypeToken} */\n  const token = {\n    type: Token.TokenType.DOCTYPE,\n    name: 'html',\n    forceQuirks: false,\n    publicId: '',\n    systemId: '',\n    location: createParse5Location(node)\n  }\n\n  resetTokenizer(state, pointStart(node))\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = token\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken)\n}\n\n/**\n * Transform a stitch.\n *\n * @param {Nodes} node\n *   unknown node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction stitch(node, state) {\n  // Mark that there are stitches, so we need to walk the tree and revert them.\n  state.stitches = true\n\n  /** @type {Nodes} */\n  const clone = cloneWithoutChildren(node)\n\n  // Recurse, because to somewhat handle `[<x>]</x>` (where `[]` denotes the\n  // passed through node).\n  if ('children' in node && 'children' in clone) {\n    // Root in root out.\n    const fakeRoot = /** @type {Root} */ (\n      raw({type: 'root', children: node.children}, state.options)\n    )\n    clone.children = fakeRoot.children\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}}, state)\n}\n\n/**\n * Transform a comment (or stitch).\n *\n * @param {Comment | Stitch} node\n *   hast comment node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction comment(node, state) {\n  /** @type {string} */\n  // @ts-expect-error: we pass stitches through.\n  const data = node.value\n\n  /** @type {CommentToken} */\n  const token = {\n    type: Token.TokenType.COMMENT,\n    data,\n    location: createParse5Location(node)\n  }\n  resetTokenizer(state, pointStart(node))\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = token\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken)\n}\n\n/**\n * Transform a raw node.\n *\n * @param {Raw} node\n *   hast raw node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction handleRaw(node, state) {\n  // Reset preprocessor:\n  // See: <https://github.com/inikulin/parse5/blob/6f7ca60/packages/parse5/lib/tokenizer/preprocessor.ts#L18-L31>.\n  state.parser.tokenizer.preprocessor.html = ''\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.pos = -1\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.lastGapPos = -2\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.gapStack = []\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.skipNextNewLine = false\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.lastChunkWritten = false\n  state.parser.tokenizer.preprocessor.endOfChunkHit = false\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.isEol = false\n\n  // Now pass `node.value`.\n  setPoint(state, pointStart(node))\n  state.parser.tokenizer.write(node.value, false)\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer._runParsingLoop()\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\n  // Note: `State` is not exposed by `parse5`, so these numbers are fragile.\n  // See: <https://github.com/inikulin/parse5/blob/46cba43/packages/parse5/lib/tokenizer/index.ts#L58>\n  // Note: a change to `parse5`, which breaks this, was merged but not released.\n  // Investigate when it is.\n  if (\n    state.parser.tokenizer.state === 72 /* NAMED_CHARACTER_REFERENCE */ ||\n    state.parser.tokenizer.state === 78 /* NUMERIC_CHARACTER_REFERENCE_END */\n  ) {\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.tokenizer.preprocessor.lastChunkWritten = true\n    /** @type {number} */\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    const cp = state.parser.tokenizer._consume()\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.tokenizer._callState(cp)\n  }\n}\n\n/**\n * Crash on an unknown node.\n *\n * @param {unknown} node_\n *   unknown node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Never.\n */\nfunction unknown(node_, state) {\n  const node = /** @type {Nodes} */ (node_)\n\n  if (\n    state.options.passThrough &&\n    state.options.passThrough.includes(node.type)\n  ) {\n    stitch(node, state)\n  } else {\n    let extra = ''\n\n    if (knownMdxNames.has(node.type)) {\n      extra =\n        \". It looks like you are using MDX nodes with `hast-util-raw` (or `rehype-raw`). If you use this because you are using remark or rehype plugins that inject `'html'` nodes, then please raise an issue with that plugin, as its a bad and slow idea. If you use this because you are using markdown syntax, then you have to configure this utility (or plugin) to pass through these nodes (see `passThrough` in docs), but you can also migrate to use the MDX syntax\"\n    }\n\n    throw new Error('Cannot compile `' + node.type + '` node' + extra)\n  }\n}\n\n/**\n * Reset the tokenizer of a parser.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Point | undefined} point\n *   Point.\n * @returns {undefined}\n *   Nothing.\n */\nfunction resetTokenizer(state, point) {\n  setPoint(state, point)\n\n  // Process final characters if they’re still there after hibernating.\n  /** @type {CharacterToken} */\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  const token = state.parser.tokenizer.currentCharacterToken\n\n  if (token && token.location) {\n    token.location.endLine = state.parser.tokenizer.preprocessor.line\n    token.location.endCol = state.parser.tokenizer.preprocessor.col + 1\n    token.location.endOffset = state.parser.tokenizer.preprocessor.offset + 1\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.currentToken = token\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser._processToken(state.parser.currentToken)\n  }\n\n  // Reset tokenizer:\n  // See: <https://github.com/inikulin/parse5/blob/6f7ca60/packages/parse5/lib/tokenizer/index.ts#L187-L223>.\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  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.paused = false\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.inLoop = false\n\n  // Note: don’t reset `state`, `inForeignNode`, or `lastStartTagName`, we\n  // manually update those when needed.\n  state.parser.tokenizer.active = false\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.returnState = TokenizerMode.DATA\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.charRefCode = -1\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.consumedAfterSnapshot = -1\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.currentLocation = null\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.currentCharacterToken = null\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.currentToken = null\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.currentAttr = {name: '', value: ''}\n}\n\n/**\n * Set current location.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Point | undefined} point\n *   Point.\n * @returns {undefined}\n *   Nothing.\n */\nfunction setPoint(state, point) {\n  if (point && point.offset !== undefined) {\n    /** @type {Location} */\n    const location = {\n      startLine: point.line,\n      startCol: point.column,\n      startOffset: point.offset,\n      endLine: -1,\n      endCol: -1,\n      endOffset: -1\n    }\n\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.tokenizer.preprocessor.lineStartPos = -point.column + 1 // Looks weird, but ensures we get correct positional info.\n    state.parser.tokenizer.preprocessor.droppedBufferSize = point.offset\n    state.parser.tokenizer.preprocessor.line = point.line\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.tokenizer.currentLocation = location\n  }\n}\n\n/**\n * Emit a start tag.\n *\n * @param {Element} node\n *   Element.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction startTag(node, state) {\n  const tagName = node.tagName.toLowerCase()\n\n  // Ignore tags if we’re in plain text.\n  if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return\n\n  resetTokenizer(state, pointStart(node))\n\n  const current = state.parser.openElements.current\n  let ns = 'namespaceURI' in current ? current.namespaceURI : webNamespaces.html\n\n  if (ns === webNamespaces.html && tagName === 'svg') {\n    ns = webNamespaces.svg\n  }\n\n  const result = toParse5(\n    // Shallow clone to not delve into `children`: we only need the attributes.\n    {...node, children: []},\n    {space: ns === webNamespaces.svg ? 'svg' : 'html'}\n  )\n\n  /** @type {TagToken} */\n  const tag = {\n    type: Token.TokenType.START_TAG,\n    tagName,\n    tagID: html.getTagID(tagName),\n    // We always send start and end tags.\n    selfClosing: false,\n    ackSelfClosing: false,\n    // Always element.\n    /* c8 ignore next */\n    attrs: 'attrs' in result ? result.attrs : [],\n    location: createParse5Location(node)\n  }\n\n  // The HTML parsing algorithm works by doing half of the state management in\n  // the tokenizer and half in the parser.\n  // We can’t use the tokenizer here, as we don’t have strings.\n  // So we act *as if* the tokenizer emits tokens:\n\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = tag\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken)\n\n  // …but then we still need a bunch of work that the tokenizer would normally\n  // do, such as:\n\n  // Set a tag name, similar to how the tokenizer would do it.\n  state.parser.tokenizer.lastStartTagName = tagName\n\n  // `inForeignNode` is correctly set by the parser.\n}\n\n/**\n * Emit an end tag.\n *\n * @param {Element} node\n *   Element.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction endTag(node, state) {\n  const tagName = node.tagName.toLowerCase()\n  // Do not emit closing tags for HTML void elements.\n  if (\n    !state.parser.tokenizer.inForeignNode &&\n    htmlVoidElements.includes(tagName)\n  ) {\n    return\n  }\n\n  // Ignore tags if we’re in plain text.\n  if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return\n\n  resetTokenizer(state, pointEnd(node))\n\n  /** @type {TagToken} */\n  const tag = {\n    type: Token.TokenType.END_TAG,\n    tagName,\n    tagID: html.getTagID(tagName),\n    selfClosing: false,\n    ackSelfClosing: false,\n    attrs: [],\n    location: createParse5Location(node)\n  }\n\n  // The HTML parsing algorithm works by doing half of the state management in\n  // the tokenizer and half in the parser.\n  // We can’t use the tokenizer here, as we don’t have strings.\n  // So we act *as if* the tokenizer emits tokens:\n\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = tag\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken)\n\n  // …but then we still need a bunch of work that the tokenizer would normally\n  // do, such as:\n\n  // Switch back to the data state after alternative states that don’t accept\n  // tags:\n  if (\n    // Current element is closed.\n    tagName === state.parser.tokenizer.lastStartTagName &&\n    // `<textarea>` and `<title>`\n    (state.parser.tokenizer.state === TokenizerMode.RCDATA ||\n      // `<iframe>`, `<noembed>`, `<style>`, `<xmp>`\n      state.parser.tokenizer.state === TokenizerMode.RAWTEXT ||\n      // `<script>`\n      state.parser.tokenizer.state === TokenizerMode.SCRIPT_DATA)\n  ) {\n    state.parser.tokenizer.state = TokenizerMode.DATA\n  }\n}\n\n/**\n * Check if `node` represents a whole document or a fragment.\n *\n * @param {Nodes} node\n *   hast node.\n * @returns {boolean}\n *   Whether this represents a whole document or a fragment.\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.toLowerCase() === 'html'))\n  )\n}\n\n/**\n * Get a `parse5` location from a node.\n *\n * @param {Nodes | Stitch} node\n *   hast node.\n * @returns {Location}\n *   `parse5` location.\n */\nfunction createParse5Location(node) {\n  const start = pointStart(node) || {\n    line: undefined,\n    column: undefined,\n    offset: undefined\n  }\n  const end = pointEnd(node) || {\n    line: undefined,\n    column: undefined,\n    offset: undefined\n  }\n\n  /** @type {Record<keyof Location, number | undefined>} */\n  const location = {\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  // @ts-expect-error: unist point values can be `undefined` in hast, which\n  // `parse5` types don’t want.\n  return location\n}\n\n/**\n * @template {Nodes} NodeType\n *   Node type.\n * @param {NodeType} node\n *   Node to clone.\n * @returns {NodeType}\n *   Cloned node, without children.\n */\nfunction cloneWithoutChildren(node) {\n  return 'children' in node\n    ? structuredClone({...node, children: []})\n    : structuredClone(node)\n}\n","/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast-util-raw').Options} RawOptions\n * @typedef {import('vfile').VFile} VFile\n */\n\n/**\n * @typedef {Omit<RawOptions, 'file'>} Options\n *   Configuration.\n */\n\nimport {raw} from 'hast-util-raw'\n\n/**\n * Parse the tree (and raw nodes) again, keeping positional info okay.\n *\n * @param {Options | null | undefined}  [options]\n *   Configuration (optional).\n * @returns\n *   Transform.\n */\nexport default function rehypeRaw(options) {\n  /**\n   * @param {Root} tree\n   *   Tree.\n   * @param {VFile} file\n   *   File.\n   * @returns {Root}\n   *   New tree.\n   */\n  return function (tree, file) {\n    // Assume root in -> root out.\n    const result = /** @type {Root} */ (raw(tree, {...options, file}))\n    return result\n  }\n}\n","/**\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction\n */\n\nimport {findAndReplace} from 'mdast-util-find-and-replace'\n\n/**\n * Turn normal line endings into hard breaks.\n *\n * @param {Nodes} tree\n *   Tree to change.\n * @returns {undefined}\n *   Nothing.\n */\nexport function newlineToBreak(tree) {\n  findAndReplace(tree, [/\\r?\\n|\\r/g, replace])\n}\n\n/**\n * Replace line endings.\n *\n * @type {ReplaceFunction}\n */\nfunction replace() {\n  return {type: 'break'}\n}\n","/**\n * @typedef {import('mdast').Root} Root\n */\n\nimport {newlineToBreak} from 'mdast-util-newline-to-break'\n\n/**\n * Support hard breaks without needing spaces or escapes (turns enters into\n * `<br>`s).\n *\n * @returns\n *   Transform.\n */\nexport default function remarkBreaks() {\n  /**\n   * Transform.\n   *\n   * @param {Root} tree\n   *   Tree.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  return function (tree) {\n    newlineToBreak(tree)\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 {import('mdast').Link} Link\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-from-markdown').Transform} FromMarkdownTransform\n *\n * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n *\n * @typedef {import('mdast-util-find-and-replace').RegExpMatchObject} RegExpMatchObject\n * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction\n */\n\nimport {ccount} from 'ccount'\nimport {ok as assert} from 'devlop'\nimport {unicodePunctuation, unicodeWhitespace} from 'micromark-util-character'\nimport {findAndReplace} from 'mdast-util-find-and-replace'\n\n/** @type {ConstructName} */\nconst inConstruct = 'phrasing'\n/** @type {Array<ConstructName>} */\nconst notInConstruct = ['autolink', 'link', 'image', 'label']\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM autolink\n * literals in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.\n */\nexport function gfmAutolinkLiteralFromMarkdown() {\n  return {\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\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM autolink\n * literals in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.\n */\nexport function gfmAutolinkLiteralToMarkdown() {\n  return {\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      {\n        character: ':',\n        before: '[ps]',\n        after: '\\\\/',\n        inConstruct,\n        notInConstruct\n      }\n    ]\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterLiteralAutolink(token) {\n  this.enter({type: 'link', title: null, url: '', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterLiteralAutolinkValue(token) {\n  this.config.enter.autolinkProtocol.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkHttp(token) {\n  this.config.exit.autolinkProtocol.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkWww(token) {\n  this.config.exit.data.call(this, token)\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'link')\n  node.url = 'http://' + this.sliceSerialize(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkEmail(token) {\n  this.config.exit.autolinkEmail.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\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 * @returns {Array<PhrasingContent> | Link | false}\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 {Link} */\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 * @returns {Link | false}\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\n  if (!trailExec) {\n    return [url, undefined]\n  }\n\n  url = url.slice(0, trailExec.index)\n\n  let trail = trailExec[0]\n  let closingParenIndex = trail.indexOf(')')\n  const openingParens = ccount(url, '(')\n  let 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  return [url, trail]\n}\n\n/**\n * @param {RegExpMatchObject} match\n * @param {boolean | null | undefined} [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').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\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').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Map} Map\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n */\n\nimport {ok as assert} from 'devlop'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\n\nfootnoteReference.peek = footnoteReferencePeek\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM footnotes\n * in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown`.\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\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM footnotes\n * in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown`.\n */\nexport function gfmFootnoteToMarkdown() {\n  return {\n    // This is on by default already.\n    unsafe: [{character: '[', inConstruct: ['phrasing', 'label', 'reference']}],\n    handlers: {footnoteDefinition, footnoteReference}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteDefinition(token) {\n  this.enter(\n    {type: 'footnoteDefinition', identifier: '', label: '', children: []},\n    token\n  )\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteDefinitionLabelString() {\n  this.buffer()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteDefinitionLabelString(token) {\n  const label = this.resume()\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'footnoteDefinition')\n  node.label = label\n  node.identifier = normalizeIdentifier(\n    this.sliceSerialize(token)\n  ).toLowerCase()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteDefinition(token) {\n  this.exit(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteCall(token) {\n  this.enter({type: 'footnoteReference', identifier: '', label: ''}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteCallString() {\n  this.buffer()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteCallString(token) {\n  const label = this.resume()\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'footnoteReference')\n  node.label = label\n  node.identifier = normalizeIdentifier(\n    this.sliceSerialize(token)\n  ).toLowerCase()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteCall(token) {\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {FootnoteReference} node\n */\nfunction footnoteReference(node, _, state, info) {\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[^')\n  const exit = state.enter('footnoteReference')\n  const subexit = state.enter('reference')\n  value += tracker.move(\n    state.safe(state.associationId(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} */\nfunction footnoteReferencePeek() {\n  return '['\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {FootnoteDefinition} node\n */\nfunction footnoteDefinition(node, _, state, info) {\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[^')\n  const exit = state.enter('footnoteDefinition')\n  const subexit = state.enter('label')\n  value += tracker.move(\n    state.safe(state.associationId(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    state.indentLines(state.containerFlow(node, tracker.current()), map)\n  )\n  exit()\n\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, index, blank) {\n  if (index === 0) {\n    return line\n  }\n\n  return (blank ? '' : '    ') + line\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n *\n * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n */\n\n/**\n * List of constructs that occur in phrasing (paragraphs, headings), but cannot\n * contain strikethrough.\n * So they sort of cancel each other out.\n * Note: could use a better name.\n *\n * Note: keep in sync with: <https://github.com/syntax-tree/mdast-util-to-markdown/blob/8ce8dbf/lib/unsafe.js#L14>\n *\n * @type {Array<ConstructName>}\n */\nconst constructsWithoutStrikethrough = [\n  'autolink',\n  'destinationLiteral',\n  'destinationRaw',\n  'reference',\n  'titleQuote',\n  'titleApostrophe'\n]\n\nhandleDelete.peek = peekDelete\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM\n * strikethrough in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM strikethrough.\n */\nexport function gfmStrikethroughFromMarkdown() {\n  return {\n    canContainEols: ['delete'],\n    enter: {strikethrough: enterStrikethrough},\n    exit: {strikethrough: exitStrikethrough}\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM\n * strikethrough in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM strikethrough.\n */\nexport function gfmStrikethroughToMarkdown() {\n  return {\n    unsafe: [\n      {\n        character: '~',\n        inConstruct: 'phrasing',\n        notInConstruct: constructsWithoutStrikethrough\n      }\n    ],\n    handlers: {delete: handleDelete}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterStrikethrough(token) {\n  this.enter({type: 'delete', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitStrikethrough(token) {\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {Delete} node\n */\nfunction handleDelete(node, _, state, info) {\n  const tracker = state.createTracker(info)\n  const exit = state.enter('strikethrough')\n  let value = tracker.move('~~')\n  value += state.containerPhrasing(node, {\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 Options\n *   Configuration (optional).\n * @property {string|null|ReadonlyArray<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 {ReadonlyArray<ReadonlyArray<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').Blockquote} Blockquote\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').Map} Map\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {Blockquote} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function blockquote(node, _, state, info) {\n  const exit = state.enter('blockquote')\n  const tracker = state.createTracker(info)\n  tracker.move('> ')\n  tracker.shift(2)\n  const value = state.indentLines(\n    state.containerFlow(node, tracker.current()),\n    map\n  )\n  exit()\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, _, blank) {\n  return '>' + (blank ? '' : ' ') + line\n}\n","/**\n * @typedef {import('../types.js').ConstructName} ConstructName\n * @typedef {import('../types.js').Unsafe} Unsafe\n */\n\n/**\n * @param {Array<ConstructName>} 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<ConstructName>} stack\n * @param {Unsafe['inConstruct']} list\n * @param {boolean} none\n * @returns {boolean}\n */\nfunction listInScope(stack, list, none) {\n  if (typeof list === 'string') {\n    list = [list]\n  }\n\n  if (!list || list.length === 0) {\n    return none\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('mdast').Break} Break\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {patternInScope} from '../util/pattern-in-scope.js'\n\n/**\n * @param {Break} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function hardBreak(_, _1, state, info) {\n  let index = -1\n\n  while (++index < state.unsafe.length) {\n    // If we can’t put eols in this construct (setext headings, tables), use a\n    // space instead.\n    if (\n      state.unsafe[index].character === '\\n' &&\n      patternInScope(state.stack, state.unsafe[index])\n    ) {\n      return /[ \\t]/.test(info.before) ? '' : ' '\n    }\n  }\n\n  return '\\\\\\n'\n}\n","/**\n * Get the count of the longest repeating streak of `substring` in `value`.\n *\n * @param {string} value\n *   Content to search in.\n * @param {string} substring\n *   Substring to look for, typically one character.\n * @returns {number}\n *   Count of most frequent adjacent `substring`s in `value`.\n */\nexport function longestStreak(value, substring) {\n  const source = String(value)\n  let index = source.indexOf(substring)\n  let expected = index\n  let count = 0\n  let max = 0\n\n  if (typeof substring !== 'string') {\n    throw new TypeError('Expected substring')\n  }\n\n  while (index !== -1) {\n    if (index === expected) {\n      if (++count > max) {\n        max = count\n      }\n    } else {\n      count = 1\n    }\n\n    expected = index + substring.length\n    index = source.indexOf(substring, expected)\n  }\n\n  return max\n}\n","/**\n * @typedef {import('mdast').Code} Code\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {Code} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatCodeAsIndented(node, state) {\n  return Boolean(\n    state.options.fences === false &&\n      node.value &&\n      // If there’s no info…\n      !node.lang &&\n      // And there’s a non-whitespace character…\n      /[^ \\r\\n]/.test(node.value) &&\n      // And the value doesn’t start or end in a blank…\n      !/^[\\t ]*(?:[\\r\\n]|$)|(?:^|[\\r\\n])[\\t ]*$/.test(node.value)\n  )\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['fence'], null | undefined>}\n */\nexport function checkFence(state) {\n  const marker = state.options.fence || '`'\n\n  if (marker !== '`' && marker !== '~') {\n    throw new Error(\n      'Cannot serialize code with `' +\n        marker +\n        '` for `options.fence`, expected `` ` `` or `~`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').Map} Map\n * @typedef {import('../types.js').State} State\n */\n\nimport {longestStreak} from 'longest-streak'\nimport {formatCodeAsIndented} from '../util/format-code-as-indented.js'\nimport {checkFence} from '../util/check-fence.js'\n\n/**\n * @param {Code} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function code(node, _, state, info) {\n  const marker = checkFence(state)\n  const raw = node.value || ''\n  const suffix = marker === '`' ? 'GraveAccent' : 'Tilde'\n\n  if (formatCodeAsIndented(node, state)) {\n    const exit = state.enter('codeIndented')\n    const value = state.indentLines(raw, map)\n    exit()\n    return value\n  }\n\n  const tracker = state.createTracker(info)\n  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3))\n  const exit = state.enter('codeFenced')\n  let value = tracker.move(sequence)\n\n  if (node.lang) {\n    const subexit = state.enter(`codeFencedLang${suffix}`)\n    value += tracker.move(\n      state.safe(node.lang, {\n        before: value,\n        after: ' ',\n        encode: ['`'],\n        ...tracker.current()\n      })\n    )\n    subexit()\n  }\n\n  if (node.lang && node.meta) {\n    const subexit = state.enter(`codeFencedMeta${suffix}`)\n    value += tracker.move(' ')\n    value += tracker.move(\n      state.safe(node.meta, {\n        before: value,\n        after: '\\n',\n        encode: ['`'],\n        ...tracker.current()\n      })\n    )\n    subexit()\n  }\n\n  value += tracker.move('\\n')\n\n  if (raw) {\n    value += tracker.move(raw + '\\n')\n  }\n\n  value += tracker.move(sequence)\n  exit()\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, _, blank) {\n  return (blank ? '' : '    ') + line\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['quote'], null | undefined>}\n */\nexport function checkQuote(state) {\n  const marker = state.options.quote || '\"'\n\n  if (marker !== '\"' && marker !== \"'\") {\n    throw new Error(\n      'Cannot serialize title with `' +\n        marker +\n        '` for `options.quote`, expected `\"`, or `\\'`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkQuote} from '../util/check-quote.js'\n\n/**\n * @param {Definition} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function definition(node, _, state, info) {\n  const quote = checkQuote(state)\n  const suffix = quote === '\"' ? 'Quote' : 'Apostrophe'\n  const exit = state.enter('definition')\n  let subexit = state.enter('label')\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[')\n  value += tracker.move(\n    state.safe(state.associationId(node), {\n      before: value,\n      after: ']',\n      ...tracker.current()\n    })\n  )\n  value += tracker.move(']: ')\n\n  subexit()\n\n  if (\n    // If there’s no url, or…\n    !node.url ||\n    // If there are control characters or whitespace.\n    /[\\0- \\u007F]/.test(node.url)\n  ) {\n    subexit = state.enter('destinationLiteral')\n    value += tracker.move('<')\n    value += tracker.move(\n      state.safe(node.url, {before: value, after: '>', ...tracker.current()})\n    )\n    value += tracker.move('>')\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = state.enter('destinationRaw')\n    value += tracker.move(\n      state.safe(node.url, {\n        before: value,\n        after: node.title ? ' ' : '\\n',\n        ...tracker.current()\n      })\n    )\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = state.enter(`title${suffix}`)\n    value += tracker.move(' ' + quote)\n    value += tracker.move(\n      state.safe(node.title, {\n        before: value,\n        after: quote,\n        ...tracker.current()\n      })\n    )\n    value += tracker.move(quote)\n    subexit()\n  }\n\n  exit()\n\n  return value\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['emphasis'], null | undefined>}\n */\nexport function checkEmphasis(state) {\n  const marker = state.options.emphasis || '*'\n\n  if (marker !== '*' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize emphasis with `' +\n        marker +\n        '` for `options.emphasis`, expected `*`, or `_`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkEmphasis} from '../util/check-emphasis.js'\n\nemphasis.peek = emphasisPeek\n\n// To do: there are cases where emphasis cannot “form” depending on the\n// previous or next character of sequences.\n// There’s no way around that though, except for injecting zero-width stuff.\n// Do we need to safeguard against that?\n/**\n * @param {Emphasis} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function emphasis(node, _, state, info) {\n  const marker = checkEmphasis(state)\n  const exit = state.enter('emphasis')\n  const tracker = state.createTracker(info)\n  let value = tracker.move(marker)\n  value += tracker.move(\n    state.containerPhrasing(node, {\n      before: value,\n      after: marker,\n      ...tracker.current()\n    })\n  )\n  value += tracker.move(marker)\n  exit()\n  return value\n}\n\n/**\n * @param {Emphasis} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @returns {string}\n */\nfunction emphasisPeek(_, _1, state) {\n  return state.options.emphasis || '*'\n}\n","/**\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../types.js').State} State\n */\n\nimport {EXIT, visit} from 'unist-util-visit'\nimport {toString} from 'mdast-util-to-string'\n\n/**\n * @param {Heading} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatHeadingAsSetext(node, state) {\n  let literalWithBreak = false\n\n  // Look for literals with a line break.\n  // Note that this also\n  visit(node, function (node) {\n    if (\n      ('value' in node && /\\r?\\n|\\r/.test(node.value)) ||\n      node.type === 'break'\n    ) {\n      literalWithBreak = true\n      return EXIT\n    }\n  })\n\n  return Boolean(\n    (!node.depth || node.depth < 3) &&\n      toString(node) &&\n      (state.options.setext || literalWithBreak)\n  )\n}\n","/**\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {formatHeadingAsSetext} from '../util/format-heading-as-setext.js'\n\n/**\n * @param {Heading} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function heading(node, _, state, info) {\n  const rank = Math.max(Math.min(6, node.depth || 1), 1)\n  const tracker = state.createTracker(info)\n\n  if (formatHeadingAsSetext(node, state)) {\n    const exit = state.enter('headingSetext')\n    const subexit = state.enter('phrasing')\n    const value = state.containerPhrasing(node, {\n      ...tracker.current(),\n      before: '\\n',\n      after: '\\n'\n    })\n    subexit()\n    exit()\n\n    return (\n      value +\n      '\\n' +\n      (rank === 1 ? '=' : '-').repeat(\n        // The whole size…\n        value.length -\n          // Minus the position of the character after the last EOL (or\n          // 0 if there is none)…\n          (Math.max(value.lastIndexOf('\\r'), value.lastIndexOf('\\n')) + 1)\n      )\n    )\n  }\n\n  const sequence = '#'.repeat(rank)\n  const exit = state.enter('headingAtx')\n  const subexit = state.enter('phrasing')\n\n  // Note: for proper tracking, we should reset the output positions when there\n  // is no content returned, because then the space is not output.\n  // Practically, in that case, there is no content, so it doesn’t matter that\n  // we’ve tracked one too many characters.\n  tracker.move(sequence + ' ')\n\n  let value = state.containerPhrasing(node, {\n    before: '# ',\n    after: '\\n',\n    ...tracker.current()\n  })\n\n  if (/^[\\t ]/.test(value)) {\n    // To do: what effect has the character reference on tracking?\n    value =\n      '&#x' +\n      value.charCodeAt(0).toString(16).toUpperCase() +\n      ';' +\n      value.slice(1)\n  }\n\n  value = value ? sequence + ' ' + value : sequence\n\n  if (state.options.closeAtx) {\n    value += ' ' + sequence\n  }\n\n  subexit()\n  exit()\n\n  return value\n}\n","/**\n * @typedef {import('mdast').Html} Html\n */\n\nhtml.peek = htmlPeek\n\n/**\n * @param {Html} node\n * @returns {string}\n */\nexport function html(node) {\n  return node.value || ''\n}\n\n/**\n * @returns {string}\n */\nfunction htmlPeek() {\n  return '<'\n}\n","/**\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkQuote} from '../util/check-quote.js'\n\nimage.peek = imagePeek\n\n/**\n * @param {Image} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function image(node, _, state, info) {\n  const quote = checkQuote(state)\n  const suffix = quote === '\"' ? 'Quote' : 'Apostrophe'\n  const exit = state.enter('image')\n  let subexit = state.enter('label')\n  const tracker = state.createTracker(info)\n  let value = tracker.move('![')\n  value += tracker.move(\n    state.safe(node.alt, {before: value, after: ']', ...tracker.current()})\n  )\n  value += tracker.move('](')\n\n  subexit()\n\n  if (\n    // If there’s no url but there is a title…\n    (!node.url && node.title) ||\n    // If there are control characters or whitespace.\n    /[\\0- \\u007F]/.test(node.url)\n  ) {\n    subexit = state.enter('destinationLiteral')\n    value += tracker.move('<')\n    value += tracker.move(\n      state.safe(node.url, {before: value, after: '>', ...tracker.current()})\n    )\n    value += tracker.move('>')\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = state.enter('destinationRaw')\n    value += tracker.move(\n      state.safe(node.url, {\n        before: value,\n        after: node.title ? ' ' : ')',\n        ...tracker.current()\n      })\n    )\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = state.enter(`title${suffix}`)\n    value += tracker.move(' ' + quote)\n    value += tracker.move(\n      state.safe(node.title, {\n        before: value,\n        after: quote,\n        ...tracker.current()\n      })\n    )\n    value += tracker.move(quote)\n    subexit()\n  }\n\n  value += tracker.move(')')\n  exit()\n\n  return value\n}\n\n/**\n * @returns {string}\n */\nfunction imagePeek() {\n  return '!'\n}\n","/**\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimageReference.peek = imageReferencePeek\n\n/**\n * @param {ImageReference} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function imageReference(node, _, state, info) {\n  const type = node.referenceType\n  const exit = state.enter('imageReference')\n  let subexit = state.enter('label')\n  const tracker = state.createTracker(info)\n  let value = tracker.move('![')\n  const alt = state.safe(node.alt, {\n    before: value,\n    after: ']',\n    ...tracker.current()\n  })\n  value += tracker.move(alt + '][')\n\n  subexit()\n  // Hide the fact that we’re in phrasing, because escapes don’t work.\n  const stack = state.stack\n  state.stack = []\n  subexit = state.enter('reference')\n  // Note: for proper tracking, we should reset the output positions when we end\n  // up making a `shortcut` reference, because then there is no brace output.\n  // Practically, in that case, there is no content, so it doesn’t matter that\n  // we’ve tracked one too many characters.\n  const reference = state.safe(state.associationId(node), {\n    before: value,\n    after: ']',\n    ...tracker.current()\n  })\n  subexit()\n  state.stack = stack\n  exit()\n\n  if (type === 'full' || !alt || alt !== reference) {\n    value += tracker.move(reference + ']')\n  } else if (type === 'shortcut') {\n    // Remove the unwanted `[`.\n    value = value.slice(0, -1)\n  } else {\n    value += tracker.move(']')\n  }\n\n  return value\n}\n\n/**\n * @returns {string}\n */\nfunction imageReferencePeek() {\n  return '!'\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').State} State\n */\n\ninlineCode.peek = inlineCodePeek\n\n/**\n * @param {InlineCode} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @returns {string}\n */\nexport function inlineCode(node, _, state) {\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 < state.unsafe.length) {\n    const pattern = state.unsafe[index]\n    const expression = state.compilePattern(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 * @returns {string}\n */\nfunction inlineCodePeek() {\n  return '`'\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('../types.js').State} State\n */\n\nimport {toString} from 'mdast-util-to-string'\n\n/**\n * @param {Link} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatLinkAsAutolink(node, state) {\n  const raw = toString(node)\n\n  return Boolean(\n    !state.options.resourceLink &&\n      // If there’s a url…\n      node.url &&\n      // And there’s a no title…\n      !node.title &&\n      // And the content of `node` is a single text node…\n      node.children &&\n      node.children.length === 1 &&\n      node.children[0].type === 'text' &&\n      // And if the url is the same as the content…\n      (raw === node.url || 'mailto:' + raw === node.url) &&\n      // And that starts w/ a protocol…\n      /^[a-z][a-z+.-]+:/i.test(node.url) &&\n      // And that doesn’t contain ASCII control codes (character escapes and\n      // references don’t work), space, or angle brackets…\n      !/[\\0- <>\\u007F]/.test(node.url)\n  )\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Exit} Exit\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkQuote} from '../util/check-quote.js'\nimport {formatLinkAsAutolink} from '../util/format-link-as-autolink.js'\n\nlink.peek = linkPeek\n\n/**\n * @param {Link} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function link(node, _, state, info) {\n  const quote = checkQuote(state)\n  const suffix = quote === '\"' ? 'Quote' : 'Apostrophe'\n  const tracker = state.createTracker(info)\n  /** @type {Exit} */\n  let exit\n  /** @type {Exit} */\n  let subexit\n\n  if (formatLinkAsAutolink(node, state)) {\n    // Hide the fact that we’re in phrasing, because escapes don’t work.\n    const stack = state.stack\n    state.stack = []\n    exit = state.enter('autolink')\n    let value = tracker.move('<')\n    value += tracker.move(\n      state.containerPhrasing(node, {\n        before: value,\n        after: '>',\n        ...tracker.current()\n      })\n    )\n    value += tracker.move('>')\n    exit()\n    state.stack = stack\n    return value\n  }\n\n  exit = state.enter('link')\n  subexit = state.enter('label')\n  let value = tracker.move('[')\n  value += tracker.move(\n    state.containerPhrasing(node, {\n      before: value,\n      after: '](',\n      ...tracker.current()\n    })\n  )\n  value += tracker.move('](')\n  subexit()\n\n  if (\n    // If there’s no url but there is a title…\n    (!node.url && node.title) ||\n    // If there are control characters or whitespace.\n    /[\\0- \\u007F]/.test(node.url)\n  ) {\n    subexit = state.enter('destinationLiteral')\n    value += tracker.move('<')\n    value += tracker.move(\n      state.safe(node.url, {before: value, after: '>', ...tracker.current()})\n    )\n    value += tracker.move('>')\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = state.enter('destinationRaw')\n    value += tracker.move(\n      state.safe(node.url, {\n        before: value,\n        after: node.title ? ' ' : ')',\n        ...tracker.current()\n      })\n    )\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = state.enter(`title${suffix}`)\n    value += tracker.move(' ' + quote)\n    value += tracker.move(\n      state.safe(node.title, {\n        before: value,\n        after: quote,\n        ...tracker.current()\n      })\n    )\n    value += tracker.move(quote)\n    subexit()\n  }\n\n  value += tracker.move(')')\n\n  exit()\n  return value\n}\n\n/**\n * @param {Link} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @returns {string}\n */\nfunction linkPeek(node, _, state) {\n  return formatLinkAsAutolink(node, state) ? '<' : '['\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nlinkReference.peek = linkReferencePeek\n\n/**\n * @param {LinkReference} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function linkReference(node, _, state, info) {\n  const type = node.referenceType\n  const exit = state.enter('linkReference')\n  let subexit = state.enter('label')\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[')\n  const text = state.containerPhrasing(node, {\n    before: value,\n    after: ']',\n    ...tracker.current()\n  })\n  value += tracker.move(text + '][')\n\n  subexit()\n  // Hide the fact that we’re in phrasing, because escapes don’t work.\n  const stack = state.stack\n  state.stack = []\n  subexit = state.enter('reference')\n  // Note: for proper tracking, we should reset the output positions when we end\n  // up making a `shortcut` reference, because then there is no brace output.\n  // Practically, in that case, there is no content, so it doesn’t matter that\n  // we’ve tracked one too many characters.\n  const reference = state.safe(state.associationId(node), {\n    before: value,\n    after: ']',\n    ...tracker.current()\n  })\n  subexit()\n  state.stack = stack\n  exit()\n\n  if (type === 'full' || !text || text !== reference) {\n    value += tracker.move(reference + ']')\n  } else if (type === 'shortcut') {\n    // Remove the unwanted `[`.\n    value = value.slice(0, -1)\n  } else {\n    value += tracker.move(']')\n  }\n\n  return value\n}\n\n/**\n * @returns {string}\n */\nfunction linkReferencePeek() {\n  return '['\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bullet'], null | undefined>}\n */\nexport function checkBullet(state) {\n  const marker = state.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 {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkBullet} from './check-bullet.js'\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bullet'], null | undefined>}\n */\nexport function checkBulletOther(state) {\n  const bullet = checkBullet(state)\n  const bulletOther = state.options.bulletOther\n\n  if (!bulletOther) {\n    return bullet === '*' ? '-' : '*'\n  }\n\n  if (bulletOther !== '*' && bulletOther !== '+' && bulletOther !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        bulletOther +\n        '` for `options.bulletOther`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  if (bulletOther === bullet) {\n    throw new Error(\n      'Expected `bullet` (`' +\n        bullet +\n        '`) and `bulletOther` (`' +\n        bulletOther +\n        '`) to be different'\n    )\n  }\n\n  return bulletOther\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bulletOrdered'], null | undefined>}\n */\nexport function checkBulletOrdered(state) {\n  const marker = state.options.bulletOrdered || '.'\n\n  if (marker !== '.' && marker !== ')') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bulletOrdered`, expected `.` or `)`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['rule'], null | undefined>}\n */\nexport function checkRule(state) {\n  const marker = state.options.rule || '*'\n\n  if (marker !== '*' && marker !== '-' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize rules with `' +\n        marker +\n        '` for `options.rule`, expected `*`, `-`, or `_`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkBullet} from '../util/check-bullet.js'\nimport {checkBulletOther} from '../util/check-bullet-other.js'\nimport {checkBulletOrdered} from '../util/check-bullet-ordered.js'\nimport {checkRule} from '../util/check-rule.js'\n\n/**\n * @param {List} node\n * @param {Parents | undefined} parent\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function list(node, parent, state, info) {\n  const exit = state.enter('list')\n  const bulletCurrent = state.bulletCurrent\n  /** @type {string} */\n  let bullet = node.ordered ? checkBulletOrdered(state) : checkBullet(state)\n  /** @type {string} */\n  const bulletOther = node.ordered\n    ? bullet === '.'\n      ? ')'\n      : '.'\n    : checkBulletOther(state)\n  let useDifferentMarker =\n    parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false\n\n  if (!node.ordered) {\n    const firstListItem = node.children ? node.children[0] : undefined\n\n    // If there’s an empty first list item directly in two list items,\n    // we have to use a different bullet:\n    //\n    // ```markdown\n    // * - *\n    // ```\n    //\n    // …because otherwise it would become one big thematic break.\n    if (\n      // Bullet could be used as a thematic break marker:\n      (bullet === '*' || bullet === '-') &&\n      // Empty first list item:\n      firstListItem &&\n      (!firstListItem.children || !firstListItem.children[0]) &&\n      // Directly in two other list items:\n      state.stack[state.stack.length - 1] === 'list' &&\n      state.stack[state.stack.length - 2] === 'listItem' &&\n      state.stack[state.stack.length - 3] === 'list' &&\n      state.stack[state.stack.length - 4] === 'listItem' &&\n      // That are each the first child.\n      state.indexStack[state.indexStack.length - 1] === 0 &&\n      state.indexStack[state.indexStack.length - 2] === 0 &&\n      state.indexStack[state.indexStack.length - 3] === 0\n    ) {\n      useDifferentMarker = true\n    }\n\n    // If there’s a thematic break at the start of the first list item,\n    // we have to use a different bullet:\n    //\n    // ```markdown\n    // * ---\n    // ```\n    //\n    // …because otherwise it would become one big thematic break.\n    if (checkRule(state) === bullet && firstListItem) {\n      let index = -1\n\n      while (++index < node.children.length) {\n        const item = node.children[index]\n\n        if (\n          item &&\n          item.type === 'listItem' &&\n          item.children &&\n          item.children[0] &&\n          item.children[0].type === 'thematicBreak'\n        ) {\n          useDifferentMarker = true\n          break\n        }\n      }\n    }\n  }\n\n  if (useDifferentMarker) {\n    bullet = bulletOther\n  }\n\n  state.bulletCurrent = bullet\n  const value = state.containerFlow(node, info)\n  state.bulletLastUsed = bullet\n  state.bulletCurrent = bulletCurrent\n  exit()\n  return value\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['listItemIndent'], null | undefined>}\n */\nexport function checkListItemIndent(state) {\n  const style = state.options.listItemIndent || 'one'\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('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').Map} Map\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkBullet} from '../util/check-bullet.js'\nimport {checkListItemIndent} from '../util/check-list-item-indent.js'\n\n/**\n * @param {ListItem} node\n * @param {Parents | undefined} parent\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function listItem(node, parent, state, info) {\n  const listItemIndent = checkListItemIndent(state)\n  let bullet = state.bulletCurrent || checkBullet(state)\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      (state.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 = state.createTracker(info)\n  tracker.move(bullet + ' '.repeat(size - bullet.length))\n  tracker.shift(size)\n  const exit = state.enter('listItem')\n  const value = state.indentLines(\n    state.containerFlow(node, 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('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {Paragraph} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function paragraph(node, _, state, info) {\n  const exit = state.enter('paragraph')\n  const subexit = state.enter('phrasing')\n  const value = state.containerPhrasing(node, info)\n  subexit()\n  exit()\n  return value\n}\n","/**\n * @typedef {import('mdast').Html} Html\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n */\n\nimport {convert} from 'unist-util-is'\n\n/**\n * Check if the given value is *phrasing content*.\n *\n * > 👉 **Note**: Excludes `html`, which can be both phrasing or flow.\n *\n * @param node\n *   Thing to check, typically `Node`.\n * @returns\n *   Whether `value` is phrasing content.\n */\n\nexport const phrasing =\n  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */\n  (\n    convert([\n      'break',\n      'delete',\n      'emphasis',\n      // To do: next major: removed since footnotes were added to GFM.\n      'footnote',\n      'footnoteReference',\n      'image',\n      'imageReference',\n      'inlineCode',\n      // Enabled by `mdast-util-math`:\n      'inlineMath',\n      'link',\n      'linkReference',\n      // Enabled by `mdast-util-mdx`:\n      'mdxJsxTextElement',\n      // Enabled by `mdast-util-mdx`:\n      'mdxTextExpression',\n      'strong',\n      'text',\n      // Enabled by `mdast-util-directive`:\n      'textDirective'\n    ])\n  )\n","/**\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {phrasing} from 'mdast-util-phrasing'\n\n/**\n * @param {Root} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function root(node, _, state, info) {\n  // Note: `html` nodes are ambiguous.\n  const hasPhrasing = node.children.some(function (d) {\n    return phrasing(d)\n  })\n  const fn = hasPhrasing ? state.containerPhrasing : state.containerFlow\n  return fn.call(state, node, info)\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['strong'], null | undefined>}\n */\nexport function checkStrong(state) {\n  const marker = state.options.strong || '*'\n\n  if (marker !== '*' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize strong with `' +\n        marker +\n        '` for `options.strong`, expected `*`, or `_`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkStrong} from '../util/check-strong.js'\n\nstrong.peek = strongPeek\n\n// To do: there are cases where emphasis cannot “form” depending on the\n// previous or next character of sequences.\n// There’s no way around that though, except for injecting zero-width stuff.\n// Do we need to safeguard against that?\n/**\n * @param {Strong} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function strong(node, _, state, info) {\n  const marker = checkStrong(state)\n  const exit = state.enter('strong')\n  const tracker = state.createTracker(info)\n  let value = tracker.move(marker + marker)\n  value += tracker.move(\n    state.containerPhrasing(node, {\n      before: value,\n      after: marker,\n      ...tracker.current()\n    })\n  )\n  value += tracker.move(marker + marker)\n  exit()\n  return value\n}\n\n/**\n * @param {Strong} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @returns {string}\n */\nfunction strongPeek(_, _1, state) {\n  return state.options.strong || '*'\n}\n","/**\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').Text} Text\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {Text} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function text(node, _, state, info) {\n  return state.safe(node.value, info)\n}\n","/**\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['ruleRepetition'], null | undefined>}\n */\nexport function checkRuleRepetition(state) {\n  const repetition = state.options.ruleRepetition || 3\n\n  if (repetition < 3) {\n    throw new Error(\n      'Cannot serialize rules with repetition `' +\n        repetition +\n        '` for `options.ruleRepetition`, expected `3` or more'\n    )\n  }\n\n  return repetition\n}\n","/**\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../types.js').State} State\n */\n\nimport {checkRuleRepetition} from '../util/check-rule-repetition.js'\nimport {checkRule} from '../util/check-rule.js'\n\n/**\n * @param {ThematicBreak} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @returns {string}\n */\nexport function thematicBreak(_, _1, state) {\n  const value = (\n    checkRule(state) + (state.options.ruleSpaces ? ' ' : '')\n  ).repeat(checkRuleRepetition(state))\n\n  return state.options.ruleSpaces ? value.slice(0, -1) : value\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {definition} from './definition.js'\nimport {emphasis} from './emphasis.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {image} from './image.js'\nimport {imageReference} from './image-reference.js'\nimport {inlineCode} from './inline-code.js'\nimport {link} from './link.js'\nimport {linkReference} from './link-reference.js'\nimport {list} from './list.js'\nimport {listItem} from './list-item.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default (CommonMark) handlers.\n */\nexport const handle = {\n  blockquote,\n  break: hardBreak,\n  code,\n  definition,\n  emphasis,\n  hardBreak,\n  heading,\n  html,\n  image,\n  imageReference,\n  inlineCode,\n  link,\n  linkReference,\n  list,\n  listItem,\n  paragraph,\n  root,\n  strong,\n  text,\n  thematicBreak\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('mdast').TableRow} TableRow\n *\n * @typedef {import('markdown-table').Options} MarkdownTableOptions\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n *\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').State} State\n * @typedef {import('mdast-util-to-markdown').Info} Info\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [tableCellPadding=true]\n *   Whether to add a space of padding between delimiters and cells (default:\n *   `true`).\n * @property {boolean | null | undefined} [tablePipeAlign=true]\n *   Whether to align the delimiters (default: `true`).\n * @property {MarkdownTableOptions['stringLength'] | null | undefined} [stringLength]\n *   Function to detect the length of table cell content, used when aligning\n *   the delimiters between cells (optional).\n */\n\nimport {ok as assert} from 'devlop'\nimport {markdownTable} from 'markdown-table'\nimport {defaultHandlers} from 'mdast-util-to-markdown'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM tables in\n * markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM tables.\n */\nexport function gfmTableFromMarkdown() {\n  return {\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\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterTable(token) {\n  const align = token._align\n  assert(align, 'expected `_align` on table')\n  this.enter(\n    {\n      type: 'table',\n      align: align.map(function (d) {\n        return d === 'none' ? null : d\n      }),\n      children: []\n    },\n    token\n  )\n  this.data.inTable = true\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitTable(token) {\n  this.exit(token)\n  this.data.inTable = undefined\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterRow(token) {\n  this.enter({type: 'tableRow', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exit(token) {\n  this.exit(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\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/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitCodeText(token) {\n  let value = this.resume()\n\n  if (this.data.inTable) {\n    value = value.replace(/\\\\([\\\\|])/g, replace)\n  }\n\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'inlineCode')\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 * Create an extension for `mdast-util-to-markdown` to enable GFM tables in\n * markdown.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM tables.\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      inlineCode: inlineCodeWithTable,\n      table: handleTable,\n      tableCell: handleTableCell,\n      tableRow: handleTableRow\n    }\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {Table} node\n   */\n  function handleTable(node, _, state, info) {\n    return serializeData(handleTableAsData(node, state, info), node.align)\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, _, state, info) {\n    const row = handleTableRowAsData(node, state, info)\n    const value = serializeData([row])\n    // `markdown-table` will always add an align row\n    return value.slice(0, value.indexOf('\\n'))\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {TableCell} node\n   */\n  function handleTableCell(node, _, state, info) {\n    const exit = state.enter('tableCell')\n    const subexit = state.enter('phrasing')\n    const value = state.containerPhrasing(node, {\n      ...info,\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 | null | undefined> | null | undefined} [align]\n   */\n  function serializeData(matrix, align) {\n    return markdownTable(matrix, {\n      align,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      alignDelimiters,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      padding,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      stringLength\n    })\n  }\n\n  /**\n   * @param {Table} node\n   * @param {State} state\n   * @param {Info} info\n   */\n  function handleTableAsData(node, state, info) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<Array<string>>} */\n    const result = []\n    const subexit = state.enter('table')\n\n    while (++index < children.length) {\n      result[index] = handleTableRowAsData(children[index], state, info)\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @param {TableRow} node\n   * @param {State} state\n   * @param {Info} info\n   */\n  function handleTableRowAsData(node, state, info) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<string>} */\n    const result = []\n    const subexit = state.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(children[index], node, state, info)\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {InlineCode} node\n   */\n  function inlineCodeWithTable(node, parent, state) {\n    let value = defaultHandlers.inlineCode(node, parent, state)\n\n    if (state.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').Paragraph} Paragraph\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\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 {ok as assert} from 'devlop'\nimport {defaultHandlers} from 'mdast-util-to-markdown'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM task\n * list items in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM task list items.\n */\nexport function gfmTaskListItemFromMarkdown() {\n  return {\n    exit: {\n      taskListCheckValueChecked: exitCheck,\n      taskListCheckValueUnchecked: exitCheck,\n      paragraph: exitParagraphWithTaskListItem\n    }\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM task list\n * items in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM task list items.\n */\nexport function gfmTaskListItemToMarkdown() {\n  return {\n    unsafe: [{atBreak: true, character: '-', after: '[:|-]'}],\n    handlers: {listItem: listItemWithTaskListItem}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitCheck(token) {\n  // We’re always in a paragraph, in a list item.\n  const node = this.stack[this.stack.length - 2]\n  assert(node.type === 'listItem')\n  node.checked = token.type === 'taskListCheckValueChecked'\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitParagraphWithTaskListItem(token) {\n  const parent = this.stack[this.stack.length - 2]\n\n  if (\n    parent &&\n    parent.type === 'listItem' &&\n    typeof parent.checked === 'boolean'\n  ) {\n    const node = this.stack[this.stack.length - 1]\n    assert(node.type === 'paragraph')\n    const head = node.children[0]\n\n    if (head && head.type === 'text') {\n      const siblings = parent.children\n      let index = -1\n      /** @type {Paragraph | undefined} */\n      let firstParaghraph\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\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {ListItem} node\n */\nfunction listItemWithTaskListItem(node, parent, state, info) {\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 = state.createTracker(info)\n\n  if (checkable) {\n    tracker.move(checkbox)\n  }\n\n  let value = defaultHandlers.listItem(node, parent, state, {\n    ...info,\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\n/**\n * @typedef {import('mdast-util-gfm-table').Options} Options\n *   Configuration.\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 * Create an extension for `mdast-util-from-markdown` to enable GFM (autolink\n * literals, footnotes, strikethrough, tables, tasklists).\n *\n * @returns {Array<FromMarkdownExtension>}\n *   Extension for `mdast-util-from-markdown` to enable GFM (autolink literals,\n *   footnotes, strikethrough, tables, tasklists).\n */\nexport function gfmFromMarkdown() {\n  return [\n    gfmAutolinkLiteralFromMarkdown(),\n    gfmFootnoteFromMarkdown(),\n    gfmStrikethroughFromMarkdown(),\n    gfmTableFromMarkdown(),\n    gfmTaskListItemFromMarkdown()\n  ]\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM (autolink\n * literals, footnotes, strikethrough, tables, tasklists).\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM (autolink literals,\n *   footnotes, strikethrough, tables, tasklists).\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 * @import {Code, ConstructRecord, Event, Extension, Previous, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { asciiAlpha, asciiAlphanumeric, asciiControl, markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\nconst wwwPrefix = {\n  tokenize: tokenizeWwwPrefix,\n  partial: true\n};\nconst domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n};\nconst path = {\n  tokenize: tokenizePath,\n  partial: true\n};\nconst trail = {\n  tokenize: tokenizeTrail,\n  partial: true\n};\nconst emailDomainDotTrail = {\n  tokenize: tokenizeEmailDomainDotTrail,\n  partial: true\n};\nconst wwwAutolink = {\n  name: 'wwwAutolink',\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n};\nconst protocolAutolink = {\n  name: 'protocolAutolink',\n  tokenize: tokenizeProtocolAutolink,\n  previous: previousProtocol\n};\nconst emailAutolink = {\n  name: 'emailAutolink',\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n};\n\n/** @type {ConstructRecord} */\nconst text = {};\n\n/**\n * Create an extension for `micromark` to support GitHub autolink literal\n * syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   autolink literal syntax.\n */\nexport function gfmAutolinkLiteral() {\n  return {\n    text\n  };\n}\n\n/** @type {Code} */\nlet code = 48;\n\n// Add alphanumerics.\nwhile (code < 123) {\n  text[code] = emailAutolink;\n  code++;\n  if (code === 58) code = 65;else if (code === 91) code = 97;\n}\ntext[43] = emailAutolink;\ntext[45] = emailAutolink;\ntext[46] = emailAutolink;\ntext[95] = emailAutolink;\ntext[72] = [emailAutolink, protocolAutolink];\ntext[104] = [emailAutolink, protocolAutolink];\ntext[87] = [emailAutolink, wwwAutolink];\ntext[119] = [emailAutolink, wwwAutolink];\n\n// To do: perform email autolink literals on events, afterwards.\n// That’s where `markdown-rs` and `cmark-gfm` perform it.\n// It should look for `@`, then for atext backwards, and then for a label\n// forwards.\n// To do: `mailto:`, `xmpp:` protocol as prefix.\n\n/**\n * Email autolink literal.\n *\n * ```markdown\n * > | a contact@example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  const self = this;\n  /** @type {boolean | undefined} */\n  let dot;\n  /** @type {boolean} */\n  let data;\n  return start;\n\n  /**\n   * Start of email autolink literal.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (!gfmAtext(code) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events)) {\n      return nok(code);\n    }\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkEmail');\n    return atext(code);\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code);\n      return atext;\n    }\n    if (code === 64) {\n      effects.consume(code);\n      return emailDomain;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In email domain.\n   *\n   * The reference code is a bit overly complex as it handles the `@`, of which\n   * there may be just one.\n   * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomain(code) {\n    // Dot followed by alphanumerical (not `-` or `_`).\n    if (code === 46) {\n      return effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code);\n    }\n\n    // Alphanumerical, `-`, and `_`.\n    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {\n      data = true;\n      effects.consume(code);\n      return emailDomain;\n    }\n\n    // To do: `/` if xmpp.\n\n    // Note: normally we’d truncate trailing punctuation from the link.\n    // However, email autolink literals cannot contain any of those markers,\n    // except for `.`, but that can only occur if it isn’t trailing.\n    // So we can ignore truncating!\n    return emailDomainAfter(code);\n  }\n\n  /**\n   * In email domain, on dot that is not a trail.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainDot(code) {\n    effects.consume(code);\n    dot = true;\n    return emailDomain;\n  }\n\n  /**\n   * After email domain.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainAfter(code) {\n    // Domain must not be empty, must include a dot, and must end in alphabetical.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.\n    if (data && dot && asciiAlpha(self.previous)) {\n      effects.exit('literalAutolinkEmail');\n      effects.exit('literalAutolink');\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * `www` autolink literal.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  const self = this;\n  return wwwStart;\n\n  /**\n   * Start of www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwStart(code) {\n    if (code !== 87 && code !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events)) {\n      return nok(code);\n    }\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkWww');\n    // Note: we *check*, so we can discard the `www.` we parsed.\n    // If it worked, we consider it as a part of the domain.\n    return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path, wwwAfter), nok), nok)(code);\n  }\n\n  /**\n   * After a www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwAfter(code) {\n    effects.exit('literalAutolinkWww');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\n/**\n * Protocol autolink literal.\n *\n * ```markdown\n * > | a https://example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeProtocolAutolink(effects, ok, nok) {\n  const self = this;\n  let buffer = '';\n  let seen = false;\n  return protocolStart;\n\n  /**\n   * Start of protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolStart(code) {\n    if ((code === 72 || code === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events)) {\n      effects.enter('literalAutolink');\n      effects.enter('literalAutolinkHttp');\n      buffer += String.fromCodePoint(code);\n      effects.consume(code);\n      return protocolPrefixInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In protocol.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolPrefixInside(code) {\n    // `5` is size of `https`\n    if (asciiAlpha(code) && buffer.length < 5) {\n      // @ts-expect-error: definitely number.\n      buffer += String.fromCodePoint(code);\n      effects.consume(code);\n      return protocolPrefixInside;\n    }\n    if (code === 58) {\n      const protocol = buffer.toLowerCase();\n      if (protocol === 'http' || protocol === 'https') {\n        effects.consume(code);\n        return protocolSlashesInside;\n      }\n    }\n    return nok(code);\n  }\n\n  /**\n   * In slashes.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *           ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolSlashesInside(code) {\n    if (code === 47) {\n      effects.consume(code);\n      if (seen) {\n        return afterProtocol;\n      }\n      seen = true;\n      return protocolSlashesInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After protocol, before domain.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterProtocol(code) {\n    // To do: this is different from `markdown-rs`:\n    // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182\n    return code === null || asciiControl(code) || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || unicodePunctuation(code) ? nok(code) : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code);\n  }\n\n  /**\n   * After a protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *                              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolAfter(code) {\n    effects.exit('literalAutolinkHttp');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\n/**\n * `www` prefix.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwPrefix(effects, ok, nok) {\n  let size = 0;\n  return wwwPrefixInside;\n\n  /**\n   * In www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *     ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixInside(code) {\n    if ((code === 87 || code === 119) && size < 3) {\n      size++;\n      effects.consume(code);\n      return wwwPrefixInside;\n    }\n    if (code === 46 && size === 3) {\n      effects.consume(code);\n      return wwwPrefixAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixAfter(code) {\n    // If there is *anything*, we can link.\n    return code === null ? nok(code) : ok(code);\n  }\n}\n\n/**\n * Domain.\n *\n * ```markdown\n * > | a https://example.org b\n *               ^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDomain(effects, ok, nok) {\n  /** @type {boolean | undefined} */\n  let underscoreInLastSegment;\n  /** @type {boolean | undefined} */\n  let underscoreInLastLastSegment;\n  /** @type {boolean | undefined} */\n  let seen;\n  return domainInside;\n\n  /**\n   * In domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *             ^^^^^^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainInside(code) {\n    // Check whether this marker, which is a trailing punctuation\n    // marker, optionally followed by more trailing markers, and then\n    // followed by an end.\n    if (code === 46 || code === 95) {\n      return effects.check(trail, domainAfter, domainAtPunctuation)(code);\n    }\n\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    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.\n    if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || code !== 45 && unicodePunctuation(code)) {\n      return domainAfter(code);\n    }\n    seen = true;\n    effects.consume(code);\n    return domainInside;\n  }\n\n  /**\n   * In domain, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainAtPunctuation(code) {\n    // There is an underscore in the last segment of the domain\n    if (code === 95) {\n      underscoreInLastSegment = true;\n    }\n    // Otherwise, it’s a `.`: save the last segment underscore in the\n    // penultimate segment slot.\n    else {\n      underscoreInLastLastSegment = underscoreInLastSegment;\n      underscoreInLastSegment = undefined;\n    }\n    effects.consume(code);\n    return domainInside;\n  }\n\n  /**\n   * After domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^\n   * ```\n   *\n   * @type {State} */\n  function domainAfter(code) {\n    // Note: that’s GH says a dot is needed, but it’s not true:\n    // <https://github.com/github/cmark-gfm/issues/279>\n    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {\n      return nok(code);\n    }\n    return ok(code);\n  }\n}\n\n/**\n * Path.\n *\n * ```markdown\n * > | a https://example.org/stuff b\n *                          ^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePath(effects, ok) {\n  let sizeOpen = 0;\n  let sizeClose = 0;\n  return pathInside;\n\n  /**\n   * In path.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathInside(code) {\n    if (code === 40) {\n      sizeOpen++;\n      effects.consume(code);\n      return pathInside;\n    }\n\n    // To do: `markdown-rs` also needs this.\n    // If this is a paren, and there are less closings than openings,\n    // we don’t check for a trail.\n    if (code === 41 && sizeClose < sizeOpen) {\n      return pathAtPunctuation(code);\n    }\n\n    // Check whether this trailing punctuation marker is optionally\n    // followed by more trailing markers, and then followed\n    // by an end.\n    if (code === 33 || code === 34 || code === 38 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 60 || code === 63 || code === 93 || code === 95 || code === 126) {\n      return effects.check(trail, ok, pathAtPunctuation)(code);\n    }\n    if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    effects.consume(code);\n    return pathInside;\n  }\n\n  /**\n   * In path, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com/a\"b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathAtPunctuation(code) {\n    // Count closing parens.\n    if (code === 41) {\n      sizeClose++;\n    }\n    effects.consume(code);\n    return pathInside;\n  }\n}\n\n/**\n * Trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the entire trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | https://example.com\").\n *                        ^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTrail(effects, ok, nok) {\n  return trail;\n\n  /**\n   * In trail of domain or path.\n   *\n   * ```markdown\n   * > | https://example.com\").\n   *                        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trail(code) {\n    // Regular trailing punctuation.\n    if (code === 33 || code === 34 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 63 || code === 95 || code === 126) {\n      effects.consume(code);\n      return trail;\n    }\n\n    // `&` followed by one or more alphabeticals and then a `;`, is\n    // as a whole considered as trailing punctuation.\n    // In all other cases, it is considered as continuation of the URL.\n    if (code === 38) {\n      effects.consume(code);\n      return trailCharacterReferenceStart;\n    }\n\n    // Needed because we allow literals after `[`, as we fix:\n    // <https://github.com/github/cmark-gfm/issues/278>.\n    // Check that it is not followed by `(` or `[`.\n    if (code === 93) {\n      effects.consume(code);\n      return trailBracketAfter;\n    }\n    if (\n    // `<` is an end.\n    code === 60 ||\n    // So is whitespace.\n    code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In trail, after `]`.\n   *\n   * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.\n   * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.\n   *\n   * ```markdown\n   * > | https://example.com](\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailBracketAfter(code) {\n    // Whitespace or something that could start a resource or reference is the end.\n    // Switch back to trail otherwise.\n    if (code === null || code === 40 || code === 91 || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    return trail(code);\n  }\n\n  /**\n   * In character-reference like trail, after `&`.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharacterReferenceStart(code) {\n    // When non-alpha, it’s not a trail.\n    return asciiAlpha(code) ? trailCharacterReferenceInside(code) : nok(code);\n  }\n\n  /**\n   * In character-reference like trail.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharacterReferenceInside(code) {\n    // Switch back to trail if this is well-formed.\n    if (code === 59) {\n      effects.consume(code);\n      return trail;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return trailCharacterReferenceInside;\n    }\n\n    // It’s not a trail.\n    return nok(code);\n  }\n}\n\n/**\n * Dot in email domain trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | contact@example.org.\n *                        ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailDomainDotTrail(effects, ok, nok) {\n  return start;\n\n  /**\n   * Dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                    ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Must be dot.\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                     ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Not a trail if alphanumeric.\n    return asciiAlphanumeric(code) ? nok(code) : ok(code);\n  }\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.\n *\n * @type {Previous}\n */\nfunction previousWww(code) {\n  return code === null || code === 40 || code === 42 || code === 95 || code === 91 || code === 93 || code === 126 || markdownLineEndingOrSpace(code);\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.\n *\n * @type {Previous}\n */\nfunction previousProtocol(code) {\n  return !asciiAlpha(code);\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previousEmail(code) {\n  // Do not allow a slash “inside” atext.\n  // The reference code is a bit weird, but that’s what it results in.\n  // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.\n  // Other than slash, every preceding character is allowed.\n  return !(code === 47 || gfmAtext(code));\n}\n\n/**\n * @param {Code} code\n * @returns {boolean}\n */\nfunction gfmAtext(code) {\n  return code === 43 || code === 45 || code === 46 || code === 95 || asciiAlphanumeric(code);\n}\n\n/**\n * @param {Array<Event>} events\n * @returns {boolean}\n */\nfunction previousUnbalanced(events) {\n  let index = events.length;\n  let result = false;\n  while (index--) {\n    const token = events[index][1];\n    if ((token.type === 'labelLink' || token.type === 'labelImage') && !token._balanced) {\n      result = true;\n      break;\n    }\n\n    // If we’ve seen this token, and it was marked as not having any unbalanced\n    // bracket before it, we can exit.\n    if (token._gfmAutolinkLiteralWalkedInto) {\n      result = false;\n      break;\n    }\n  }\n  if (events.length > 0 && !result) {\n    // Mark the last token as “walked into” w/o finding\n    // anything.\n    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;\n  }\n  return result;\n}","/**\n * @import {Event, Exiter, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { blankLine } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nconst indent = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\n// To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only\n// affects label start (image).\n// That will let us drop `tokenizePotentialGfmFootnote*`.\n// It currently has a `_hiddenFootnoteSupport`, which affects that and more.\n// That can be removed when `micromark-extension-footnote` is archived.\n\n/**\n * Create an extension for `micromark` to enable GFM footnote syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to\n *   enable GFM footnote syntax.\n */\nexport function gfmFootnote() {\n  /** @type {Extension} */\n  return {\n    document: {\n      [91]: {\n        name: 'gfmFootnoteDefinition',\n        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        name: 'gfmFootnoteCall',\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        name: 'gfmPotentialFootnoteCall',\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  };\n}\n\n// To do: remove after micromark update.\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {Token} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    const token = self.events[index][1];\n    if (token.type === \"labelImage\") {\n      labelStart = token;\n      break;\n    }\n\n    // Exit if we’ve walked far enough.\n    if (token.type === 'gfmFootnoteCall' || token.type === \"labelLink\" || token.type === \"label\" || token.type === \"image\" || token.type === \"link\") {\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * @type {State}\n   */\n  function start(code) {\n    if (!labelStart || !labelStart._balanced) {\n      return nok(code);\n    }\n    const id = normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    }));\n    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {\n      return nok(code);\n    }\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return ok(code);\n  }\n}\n\n// To do: remove after micromark update.\n/** @type {Resolver} */\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n  let index = events.length;\n  /** @type {Token | undefined} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    if (events[index][1].type === \"labelImage\" && events[index][0] === 'enter') {\n      labelStart = events[index][1];\n      break;\n    }\n  }\n  // Change the `labelImageMarker` to a `data`.\n  events[index + 1][1].type = \"data\";\n  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker';\n\n  // The whole (without `!`):\n  /** @type {Token} */\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  };\n  // The `^` marker\n  /** @type {Token} */\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  };\n  // Increment the end 1 character.\n  marker.end.column++;\n  marker.end.offset++;\n  marker.end._bufferIndex++;\n  /** @type {Token} */\n  const string = {\n    type: 'gfmFootnoteCallString',\n    start: Object.assign({}, marker.end),\n    end: Object.assign({}, events[events.length - 1][1].start)\n  };\n  /** @type {Token} */\n  const chunk = {\n    type: \"chunkString\",\n    contentType: 'string',\n    start: Object.assign({}, string.start),\n    end: Object.assign({}, string.end)\n  };\n\n  /** @type {Array<Event>} */\n  const replacement = [\n  // Take the `labelImageMarker` (now `data`, the `!`)\n  events[index + 1], events[index + 2], ['enter', call, context],\n  // The `[`\n  events[index + 3], events[index + 4],\n  // The `^`.\n  ['enter', marker, context], ['exit', marker, context],\n  // Everything in between.\n  ['enter', string, context], ['enter', chunk, context], ['exit', chunk, context], ['exit', string, context],\n  // The ending (`]`, properly parsed and labelled).\n  events[events.length - 2], events[events.length - 1], ['exit', call, context]];\n  events.splice(index, events.length - index + 1, ...replacement);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  let size = 0;\n  /** @type {boolean} */\n  let data;\n\n  // Note: the implementation of `markdown-rs` is different, because it houses\n  // core *and* extensions in one project.\n  // Therefore, it can include footnote logic inside `label-end`.\n  // We can’t do that, but luckily, we can parse footnotes in a simpler way than\n  // needed for labels.\n  return start;\n\n  /**\n   * Start of footnote label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *       ^\n   * ```\n   *\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\n  /**\n   * After `[`, at `^`.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *        ^\n   * ```\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\n  /**\n   * In label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callData(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteCallString');\n      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {\n        return nok(code);\n      }\n      effects.enter('gfmFootnoteCallLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteCallLabelMarker');\n      effects.exit('gfmFootnoteCall');\n      return ok;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? callEscape : callData;\n  }\n\n  /**\n   * On character after escape.\n   *\n   * ```markdown\n   * > | a [^b\\c] d\n   *           ^\n   * ```\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    return callData(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {string} */\n  let identifier;\n  let size = 0;\n  /** @type {boolean | undefined} */\n  let data;\n  return start;\n\n  /**\n   * Start of GFM footnote definition.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *     ^\n   * ```\n   *\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 labelAtMarker;\n  }\n\n  /**\n   * In label, at caret.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAtMarker(code) {\n    if (code === 94) {\n      effects.enter('gfmFootnoteDefinitionMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionMarker');\n      effects.enter('gfmFootnoteDefinitionLabelString');\n      effects.enter('chunkString').contentType = 'string';\n      return labelInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label.\n   *\n   * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote\n   * > definition labels.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const 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    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:\n   * > <https://github.com/github/cmark-gfm/issues/240>\n   *\n   * ```markdown\n   * > | [^a\\*b]: c\n   *         ^\n   * ```\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 labelInside;\n    }\n    return labelInside(code);\n  }\n\n  /**\n   * After definition label.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *         ^\n   * ```\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');\n      if (!defined.includes(identifier)) {\n        defined.push(identifier);\n      }\n\n      // 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      return factorySpace(effects, whitespaceAfter, 'gfmFootnoteDefinitionWhitespace');\n    }\n    return nok(code);\n  }\n\n  /**\n   * After definition prefix.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function whitespaceAfter(code) {\n    // `markdown-rs` has a wrapping token for the prefix that is closed here.\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n  /// Start of footnote definition continuation.\n  ///\n  /// ```markdown\n  ///   | [^a]: b\n  /// > |     c\n  ///     ^\n  /// ```\n  //\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\n/** @type {Exiter} */\nfunction gfmFootnoteDefinitionEnd(effects) {\n  effects.exit('gfmFootnoteDefinition');\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, 'gfmFootnoteDefinitionIndent', 4 + 1);\n\n  /**\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === 'gfmFootnoteDefinitionIndent' && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok(code) : nok(code);\n  }\n}","/**\n * @import {Options} from 'micromark-extension-gfm-strikethrough'\n * @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create an extension for `micromark` to enable GFM strikethrough syntax.\n *\n * @param {Options | null | undefined} [options={}]\n *   Configuration.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions`, to\n *   enable GFM strikethrough syntax.\n */\nexport function gfmStrikethrough(options) {\n  const options_ = options || {};\n  let single = options_.singleTilde;\n  const tokenizer = {\n    name: 'strikethrough',\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  };\n  if (single === null || single === undefined) {\n    single = true;\n  }\n  return {\n    text: {\n      [126]: tokenizer\n    },\n    insideSpan: {\n      null: [tokenizer]\n    },\n    attentionMarkers: {\n      null: [126]\n    }\n  };\n\n  /**\n   * Take events and resolve strikethrough.\n   *\n   * @type {Resolver}\n   */\n  function resolveAllStrikethrough(events, context) {\n    let index = -1;\n\n    // Walk through all events.\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && events[index][1]._close) {\n        let open = index;\n\n        // Now walk back to find an opener.\n        while (open--) {\n          // Find a token that can open the closer.\n          if (events[open][0] === 'exit' && events[open][1].type === 'strikethroughSequenceTemporary' && events[open][1]._open &&\n          // If the sizes are the same:\n          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {\n            events[index][1].type = 'strikethroughSequence';\n            events[open][1].type = 'strikethroughSequence';\n\n            /** @type {Token} */\n            const strikethrough = {\n              type: 'strikethrough',\n              start: Object.assign({}, events[open][1].start),\n              end: Object.assign({}, events[index][1].end)\n            };\n\n            /** @type {Token} */\n            const text = {\n              type: 'strikethroughText',\n              start: Object.assign({}, events[open][1].end),\n              end: Object.assign({}, events[index][1].start)\n            };\n\n            // Opening.\n            /** @type {Array<Event>} */\n            const nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]];\n            const insideSpan = context.parser.constructs.insideSpan.null;\n            if (insideSpan) {\n              // Between.\n              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));\n            }\n\n            // Closing.\n            splice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);\n            splice(events, open - 1, index - open + 3, nextEvents);\n            index = open + nextEvents.length - 2;\n            break;\n          }\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = \"data\";\n      }\n    }\n    return events;\n  }\n\n  /**\n   * @this {TokenizeContext}\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\n    /** @type {State} */\n    function start(code) {\n      if (previous === 126 && events[events.length - 1][1].type !== \"characterEscape\") {\n        return nok(code);\n      }\n      effects.enter('strikethroughSequenceTemporary');\n      return more(code);\n    }\n\n    /** @type {State} */\n    function more(code) {\n      const before = classifyCharacter(previous);\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      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 * @import {Event} from 'micromark-util-types'\n */\n\n// Port of `edit_map.rs` from `markdown-rs`.\n// This should move to `markdown-js` later.\n\n// Deal with several changes in events, batching them together.\n//\n// Preferably, changes should be kept to a minimum.\n// Sometimes, it’s needed to change the list of events, because parsing can be\n// messy, and it helps to expose a cleaner interface of events to the compiler\n// and other users.\n// It can also help to merge many adjacent similar events.\n// And, in other cases, it’s needed to parse subcontent: pass some events\n// through another tokenizer and inject the result.\n\n/**\n * @typedef {[number, number, Array<Event>]} Change\n * @typedef {[number, number, number]} Jump\n */\n\n/**\n * Tracks a bunch of edits.\n */\nexport class EditMap {\n  /**\n   * Create a new edit map.\n   */\n  constructor() {\n    /**\n     * Record of changes.\n     *\n     * @type {Array<Change>}\n     */\n    this.map = [];\n  }\n\n  /**\n   * Create an edit: a remove and/or add at a certain place.\n   *\n   * @param {number} index\n   * @param {number} remove\n   * @param {Array<Event>} add\n   * @returns {undefined}\n   */\n  add(index, remove, add) {\n    addImplementation(this, index, remove, add);\n  }\n\n  // To do: add this when moving to `micromark`.\n  // /**\n  //  * Create an edit: but insert `add` before existing additions.\n  //  *\n  //  * @param {number} index\n  //  * @param {number} remove\n  //  * @param {Array<Event>} add\n  //  * @returns {undefined}\n  //  */\n  // addBefore(index, remove, add) {\n  //   addImplementation(this, index, remove, add, true)\n  // }\n\n  /**\n   * Done, change the events.\n   *\n   * @param {Array<Event>} events\n   * @returns {undefined}\n   */\n  consume(events) {\n    this.map.sort(function (a, b) {\n      return a[0] - b[0];\n    });\n\n    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n    if (this.map.length === 0) {\n      return;\n    }\n\n    // To do: if links are added in events, like they are in `markdown-rs`,\n    // this is needed.\n    // // Calculate jumps: where items in the current list move to.\n    // /** @type {Array<Jump>} */\n    // const jumps = []\n    // let index = 0\n    // let addAcc = 0\n    // let removeAcc = 0\n    // while (index < this.map.length) {\n    //   const [at, remove, add] = this.map[index]\n    //   removeAcc += remove\n    //   addAcc += add.length\n    //   jumps.push([at, removeAcc, addAcc])\n    //   index += 1\n    // }\n    //\n    // . shiftLinks(events, jumps)\n\n    let index = this.map.length;\n    /** @type {Array<Array<Event>>} */\n    const vecs = [];\n    while (index > 0) {\n      index -= 1;\n      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);\n\n      // Truncate rest.\n      events.length = this.map[index][0];\n    }\n    vecs.push([...events]);\n    events.length = 0;\n    let slice = vecs.pop();\n    while (slice) {\n      events.push(...slice);\n      slice = vecs.pop();\n    }\n\n    // Truncate everything.\n    this.map.length = 0;\n  }\n}\n\n/**\n * Create an edit.\n *\n * @param {EditMap} editMap\n * @param {number} at\n * @param {number} remove\n * @param {Array<Event>} add\n * @returns {undefined}\n */\nfunction addImplementation(editMap, at, remove, add) {\n  let index = 0;\n\n  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n  if (remove === 0 && add.length === 0) {\n    return;\n  }\n  while (index < editMap.map.length) {\n    if (editMap.map[index][0] === at) {\n      editMap.map[index][1] += remove;\n\n      // To do: before not used by tables, use when moving to micromark.\n      // if (before) {\n      //   add.push(...editMap.map[index][2])\n      //   editMap.map[index][2] = add\n      // } else {\n      editMap.map[index][2].push(...add);\n      // }\n\n      return;\n    }\n    index += 1;\n  }\n  editMap.map.push([at, remove, add]);\n}\n\n// /**\n//  * Shift `previous` and `next` links according to `jumps`.\n//  *\n//  * This fixes links in case there are events removed or added between them.\n//  *\n//  * @param {Array<Event>} events\n//  * @param {Array<Jump>} jumps\n//  */\n// function shiftLinks(events, jumps) {\n//   let jumpIndex = 0\n//   let index = 0\n//   let add = 0\n//   let rm = 0\n\n//   while (index < events.length) {\n//     const rmCurr = rm\n\n//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {\n//       add = jumps[jumpIndex][2]\n//       rm = jumps[jumpIndex][1]\n//       jumpIndex += 1\n//     }\n\n//     // Ignore items that will be removed.\n//     if (rm > rmCurr) {\n//       index += rm - rmCurr\n//     } else {\n//       // ?\n//       // if let Some(link) = &events[index].link {\n//       //     if let Some(next) = link.next {\n//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);\n//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {\n//       //             add = jumps[jumpIndex].2;\n//       //             rm = jumps[jumpIndex].1;\n//       //             jumpIndex += 1;\n//       //         }\n//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);\n//       //         index = next;\n//       //         continue;\n//       //     }\n//       // }\n//       index += 1\n//     }\n//   }\n// }","/**\n * @import {Event} from 'micromark-util-types'\n */\n\n/**\n * @typedef {'center' | 'left' | 'none' | 'right'} Align\n */\n\n/**\n * Figure out the alignment of a GFM table.\n *\n * @param {Readonly<Array<Event>>} events\n *   List of events.\n * @param {number} index\n *   Table enter event.\n * @returns {Array<Align>}\n *   List of aligns.\n */\nexport function gfmTableAlign(events, index) {\n  let inDelimiterRow = false;\n  /** @type {Array<Align>} */\n  const align = [];\n  while (index < events.length) {\n    const event = events[index];\n    if (inDelimiterRow) {\n      if (event[0] === 'enter') {\n        // Start of alignment value: set a new column.\n        // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n        if (event[1].type === 'tableContent') {\n          align.push(events[index + 1][1].type === 'tableDelimiterMarker' ? 'left' : 'none');\n        }\n      }\n      // Exits:\n      // End of alignment value: change the column.\n      // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n      else if (event[1].type === 'tableContent') {\n        if (events[index - 1][1].type === 'tableDelimiterMarker') {\n          const alignIndex = align.length - 1;\n          align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right';\n        }\n      }\n      // Done!\n      else if (event[1].type === 'tableDelimiterRow') {\n        break;\n      }\n    } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') {\n      inDelimiterRow = true;\n    }\n    index += 1;\n  }\n  return align;\n}","/**\n * @import {Event, Extension, Point, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\n/**\n * @typedef {[number, number, number, number]} Range\n *   Cell info.\n *\n * @typedef {0 | 1 | 2 | 3} RowKind\n *   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { EditMap } from './edit-map.js';\nimport { gfmTableAlign } from './infer.js';\n\n/**\n * Create an HTML extension for `micromark` to support GitHub tables syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   table syntax.\n */\nexport function gfmTable() {\n  return {\n    flow: {\n      null: {\n        name: 'table',\n        tokenize: tokenizeTable,\n        resolveAll: resolveTable\n      }\n    }\n  };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTable(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  let sizeB = 0;\n  /** @type {boolean | undefined} */\n  let seen;\n  return start;\n\n  /**\n   * Start of a GFM table.\n   *\n   * If there is a valid table row or table head before, then we try to parse\n   * another row.\n   * Otherwise, we try to parse a head.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length - 1;\n    while (index > -1) {\n      const type = self.events[index][1].type;\n      if (type === \"lineEnding\" ||\n      // Note: markdown-rs uses `whitespace` instead of `linePrefix`\n      type === \"linePrefix\") index--;else break;\n    }\n    const tail = index > -1 ? self.events[index][1].type : null;\n    const next = tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore;\n\n    // Don’t allow lazy body rows.\n    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    return next(code);\n  }\n\n  /**\n   * Before table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBefore(code) {\n    effects.enter('tableHead');\n    effects.enter('tableRow');\n    return headRowStart(code);\n  }\n\n  /**\n   * Before table head row, after whitespace.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowStart(code) {\n    if (code === 124) {\n      return headRowBreak(code);\n    }\n\n    // To do: micromark-js should let us parse our own whitespace in extensions,\n    // like `markdown-rs`:\n    //\n    // ```js\n    // // 4+ spaces.\n    // if (markdownSpace(code)) {\n    //   return nok(code)\n    // }\n    // ```\n\n    seen = true;\n    // Count the first character, that isn’t a pipe, double.\n    sizeB += 1;\n    return headRowBreak(code);\n  }\n\n  /**\n   * At break in table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *       ^\n   *         ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBreak(code) {\n    if (code === null) {\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      // If anything other than one pipe (ignoring whitespace) was used, it’s fine.\n      if (sizeB > 1) {\n        sizeB = 0;\n        // To do: check if this works.\n        // Feel free to interrupt:\n        self.interrupt = true;\n        effects.exit('tableRow');\n        effects.enter(\"lineEnding\");\n        effects.consume(code);\n        effects.exit(\"lineEnding\");\n        return headDelimiterStart;\n      }\n\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code);\n    }\n    if (markdownSpace(code)) {\n      // To do: check if this is fine.\n      // effects.attempt(State::Next(StateName::GfmTableHeadRowBreak), State::Nok)\n      // State::Retry(space_or_tab(tokenizer))\n      return factorySpace(effects, headRowBreak, \"whitespace\")(code);\n    }\n    sizeB += 1;\n    if (seen) {\n      seen = false;\n      // Header cell count.\n      size += 1;\n    }\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      // Whether a delimiter was seen.\n      seen = true;\n      return headRowBreak;\n    }\n\n    // Anything else is cell data.\n    effects.enter(\"data\");\n    return headRowData(code);\n  }\n\n  /**\n   * In table head row data.\n   *\n   * ```markdown\n   * > | | a |\n   *       ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"data\");\n      return headRowBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? headRowEscape : headRowData;\n  }\n\n  /**\n   * In table head row escape.\n   *\n   * ```markdown\n   * > | | a\\-b |\n   *         ^\n   *   | | ---- |\n   *   | | c    |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return headRowData;\n    }\n    return headRowData(code);\n  }\n\n  /**\n   * Before delimiter row.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterStart(code) {\n    // Reset `interrupt`.\n    self.interrupt = false;\n\n    // Note: in `markdown-rs`, we need to handle piercing here too.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    effects.enter('tableDelimiterRow');\n    // Track if we’ve seen a `:` or `|`.\n    seen = false;\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return headDelimiterBefore(code);\n  }\n\n  /**\n   * Before delimiter row, after optional whitespace.\n   *\n   * Reused when a `|` is found later, to parse another cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterBefore(code) {\n    if (code === 45 || code === 58) {\n      return headDelimiterValueBefore(code);\n    }\n    if (code === 124) {\n      seen = true;\n      // If we start with a pipe, we open a cell marker.\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return headDelimiterCellBefore;\n    }\n\n    // More whitespace / empty row not allowed at start.\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * After `|`, before delimiter cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellBefore(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterValueBefore, \"whitespace\")(code);\n    }\n    return headDelimiterValueBefore(code);\n  }\n\n  /**\n   * Before delimiter cell value.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterValueBefore(code) {\n    // Align: left.\n    if (code === 58) {\n      sizeB += 1;\n      seen = true;\n      effects.enter('tableDelimiterMarker');\n      effects.consume(code);\n      effects.exit('tableDelimiterMarker');\n      return headDelimiterLeftAlignmentAfter;\n    }\n\n    // Align: none.\n    if (code === 45) {\n      sizeB += 1;\n      // To do: seems weird that this *isn’t* left aligned, but that state is used?\n      return headDelimiterLeftAlignmentAfter(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return headDelimiterCellAfter(code);\n    }\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * After delimiter cell left alignment marker.\n   *\n   * ```markdown\n   *   | | a  |\n   * > | | :- |\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterLeftAlignmentAfter(code) {\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller');\n      return headDelimiterFiller(code);\n    }\n\n    // Anything else is not ok after the left-align colon.\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * In delimiter cell filler.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterFiller(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return headDelimiterFiller;\n    }\n\n    // Align is `center` if it was `left`, `right` otherwise.\n    if (code === 58) {\n      seen = true;\n      effects.exit('tableDelimiterFiller');\n      effects.enter('tableDelimiterMarker');\n      effects.consume(code);\n      effects.exit('tableDelimiterMarker');\n      return headDelimiterRightAlignmentAfter;\n    }\n    effects.exit('tableDelimiterFiller');\n    return headDelimiterRightAlignmentAfter(code);\n  }\n\n  /**\n   * After delimiter cell right alignment marker.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterRightAlignmentAfter(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterCellAfter, \"whitespace\")(code);\n    }\n    return headDelimiterCellAfter(code);\n  }\n\n  /**\n   * After delimiter cell.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellAfter(code) {\n    if (code === 124) {\n      return headDelimiterBefore(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      // Exit when:\n      // * there was no `:` or `|` at all (it’s a thematic break or setext\n      //   underline instead)\n      // * the header cell count is not the delimiter cell count\n      if (!seen || size !== sizeB) {\n        return headDelimiterNok(code);\n      }\n\n      // Note: in markdown-rs`, a reset is needed here.\n      effects.exit('tableDelimiterRow');\n      effects.exit('tableHead');\n      // To do: in `markdown-rs`, resolvers need to be registered manually.\n      // effects.register_resolver(ResolveName::GfmTable)\n      return ok(code);\n    }\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * In delimiter row, at a disallowed byte.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | x |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterNok(code) {\n    // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n    return nok(code);\n  }\n\n  /**\n   * Before table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowStart(code) {\n    // Note: in `markdown-rs` we need to manually take care of a prefix,\n    // but in `micromark-js` that is done for us, so if we’re here, we’re\n    // never at whitespace.\n    effects.enter('tableRow');\n    return bodyRowBreak(code);\n  }\n\n  /**\n   * At break in table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   *       ^\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowBreak(code) {\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return bodyRowBreak;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('tableRow');\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, bodyRowBreak, \"whitespace\")(code);\n    }\n\n    // Anything else is cell content.\n    effects.enter(\"data\");\n    return bodyRowData(code);\n  }\n\n  /**\n   * In table body row data.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"data\");\n      return bodyRowBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? bodyRowEscape : bodyRowData;\n  }\n\n  /**\n   * In table body row escape.\n   *\n   * ```markdown\n   *   | | a    |\n   *   | | ---- |\n   * > | | b\\-c |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return bodyRowData;\n    }\n    return bodyRowData(code);\n  }\n}\n\n/** @type {Resolver} */\n\nfunction resolveTable(events, context) {\n  let index = -1;\n  let inFirstCellAwaitingPipe = true;\n  /** @type {RowKind} */\n  let rowKind = 0;\n  /** @type {Range} */\n  let lastCell = [0, 0, 0, 0];\n  /** @type {Range} */\n  let cell = [0, 0, 0, 0];\n  let afterHeadAwaitingFirstBodyRow = false;\n  let lastTableEnd = 0;\n  /** @type {Token | undefined} */\n  let currentTable;\n  /** @type {Token | undefined} */\n  let currentBody;\n  /** @type {Token | undefined} */\n  let currentCell;\n  const map = new EditMap();\n  while (++index < events.length) {\n    const event = events[index];\n    const token = event[1];\n    if (event[0] === 'enter') {\n      // Start of head.\n      if (token.type === 'tableHead') {\n        afterHeadAwaitingFirstBodyRow = false;\n\n        // Inject previous (body end and) table end.\n        if (lastTableEnd !== 0) {\n          flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);\n          currentBody = undefined;\n          lastTableEnd = 0;\n        }\n\n        // Inject table start.\n        currentTable = {\n          type: 'table',\n          start: Object.assign({}, token.start),\n          // Note: correct end is set later.\n          end: Object.assign({}, token.end)\n        };\n        map.add(index, 0, [['enter', currentTable, context]]);\n      } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') {\n        inFirstCellAwaitingPipe = true;\n        currentCell = undefined;\n        lastCell = [0, 0, 0, 0];\n        cell = [0, index + 1, 0, 0];\n\n        // Inject table body start.\n        if (afterHeadAwaitingFirstBodyRow) {\n          afterHeadAwaitingFirstBodyRow = false;\n          currentBody = {\n            type: 'tableBody',\n            start: Object.assign({}, token.start),\n            // Note: correct end is set later.\n            end: Object.assign({}, token.end)\n          };\n          map.add(index, 0, [['enter', currentBody, context]]);\n        }\n        rowKind = token.type === 'tableDelimiterRow' ? 2 : currentBody ? 3 : 1;\n      }\n      // Cell data.\n      else if (rowKind && (token.type === \"data\" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) {\n        inFirstCellAwaitingPipe = false;\n\n        // First value in cell.\n        if (cell[2] === 0) {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1];\n            currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell);\n            lastCell = [0, 0, 0, 0];\n          }\n          cell[2] = index;\n        }\n      } else if (token.type === 'tableCellDivider') {\n        if (inFirstCellAwaitingPipe) {\n          inFirstCellAwaitingPipe = false;\n        } else {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1];\n            currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell);\n          }\n          lastCell = cell;\n          cell = [lastCell[1], index, 0, 0];\n        }\n      }\n    }\n    // Exit events.\n    else if (token.type === 'tableHead') {\n      afterHeadAwaitingFirstBodyRow = true;\n      lastTableEnd = index;\n    } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') {\n      lastTableEnd = index;\n      if (lastCell[1] !== 0) {\n        cell[0] = cell[1];\n        currentCell = flushCell(map, context, lastCell, rowKind, index, currentCell);\n      } else if (cell[1] !== 0) {\n        currentCell = flushCell(map, context, cell, rowKind, index, currentCell);\n      }\n      rowKind = 0;\n    } else if (rowKind && (token.type === \"data\" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) {\n      cell[3] = index;\n    }\n  }\n  if (lastTableEnd !== 0) {\n    flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);\n  }\n  map.consume(context.events);\n\n  // To do: move this into `html`, when events are exposed there.\n  // That’s what `markdown-rs` does.\n  // That needs updates to `mdast-util-gfm-table`.\n  index = -1;\n  while (++index < context.events.length) {\n    const event = context.events[index];\n    if (event[0] === 'enter' && event[1].type === 'table') {\n      event[1]._align = gfmTableAlign(context.events, index);\n    }\n  }\n  return events;\n}\n\n/**\n * Generate a cell.\n *\n * @param {EditMap} map\n * @param {Readonly<TokenizeContext>} context\n * @param {Readonly<Range>} range\n * @param {RowKind} rowKind\n * @param {number | undefined} rowEnd\n * @param {Token | undefined} previousCell\n * @returns {Token | undefined}\n */\n// eslint-disable-next-line max-params\nfunction flushCell(map, context, range, rowKind, rowEnd, previousCell) {\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCell' : 'tableCell'\n  const groupName = rowKind === 1 ? 'tableHeader' : rowKind === 2 ? 'tableDelimiter' : 'tableData';\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCellValue' : 'tableCellText'\n  const valueName = 'tableContent';\n\n  // Insert an exit for the previous cell, if there is one.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //          ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[0] !== 0) {\n    previousCell.end = Object.assign({}, getPoint(context.events, range[0]));\n    map.add(range[0], 0, [['exit', previousCell, context]]);\n  }\n\n  // Insert enter of this cell.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //           ^-- enter\n  //           ^^^^-- this cell\n  // ```\n  const now = getPoint(context.events, range[1]);\n  previousCell = {\n    type: groupName,\n    start: Object.assign({}, now),\n    // Note: correct end is set later.\n    end: Object.assign({}, now)\n  };\n  map.add(range[1], 0, [['enter', previousCell, context]]);\n\n  // Insert text start at first data start and end at last data end, and\n  // remove events between.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //            ^-- enter\n  //             ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[2] !== 0) {\n    const relatedStart = getPoint(context.events, range[2]);\n    const relatedEnd = getPoint(context.events, range[3]);\n    /** @type {Token} */\n    const valueToken = {\n      type: valueName,\n      start: Object.assign({}, relatedStart),\n      end: Object.assign({}, relatedEnd)\n    };\n    map.add(range[2], 0, [['enter', valueToken, context]]);\n    if (rowKind !== 2) {\n      // Fix positional info on remaining events\n      const start = context.events[range[2]];\n      const end = context.events[range[3]];\n      start[1].end = Object.assign({}, end[1].end);\n      start[1].type = \"chunkText\";\n      start[1].contentType = \"text\";\n\n      // Remove if needed.\n      if (range[3] > range[2] + 1) {\n        const a = range[2] + 1;\n        const b = range[3] - range[2] - 1;\n        map.add(a, b, []);\n      }\n    }\n    map.add(range[3] + 1, 0, [['exit', valueToken, context]]);\n  }\n\n  // Insert an exit for the last cell, if at the row end.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //                    ^-- exit\n  //               ^^^^^^-- this cell (the last one contains two “between” parts)\n  // ```\n  if (rowEnd !== undefined) {\n    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));\n    map.add(rowEnd, 0, [['exit', previousCell, context]]);\n    previousCell = undefined;\n  }\n  return previousCell;\n}\n\n/**\n * Generate table end (and table body end).\n *\n * @param {Readonly<EditMap>} map\n * @param {Readonly<TokenizeContext>} context\n * @param {number} index\n * @param {Token} table\n * @param {Token | undefined} tableBody\n */\n// eslint-disable-next-line max-params\nfunction flushTableEnd(map, context, index, table, tableBody) {\n  /** @type {Array<Event>} */\n  const exits = [];\n  const related = getPoint(context.events, index);\n  if (tableBody) {\n    tableBody.end = Object.assign({}, related);\n    exits.push(['exit', tableBody, context]);\n  }\n  table.end = Object.assign({}, related);\n  exits.push(['exit', table, context]);\n  map.add(index + 1, 0, exits);\n}\n\n/**\n * @param {Readonly<Array<Event>>} events\n * @param {number} index\n * @returns {Readonly<Point>}\n */\nfunction getPoint(events, index) {\n  const event = events[index];\n  const side = event[0] === 'enter' ? 'start' : 'end';\n  return event[1][side];\n}","/**\n * @import {Extension, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nconst tasklistCheck = {\n  name: 'tasklistCheck',\n  tokenize: tokenizeTasklistCheck\n};\n\n/**\n * Create an HTML extension for `micromark` to support GFM task list items\n * syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM task list items when serializing to HTML.\n */\nexport function gfmTaskListItem() {\n  return {\n    text: {\n      [91]: tasklistCheck\n    }\n  };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  const self = this;\n  return open;\n\n  /**\n   * At start of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (\n    // Exit if there’s stuff before.\n    self.previous !== null ||\n    // Exit if not in the first content that is the first child of a list\n    // item.\n    !self._gfmTasklistFirstContentOfListItem) {\n      return nok(code);\n    }\n    effects.enter('taskListCheck');\n    effects.enter('taskListCheckMarker');\n    effects.consume(code);\n    effects.exit('taskListCheckMarker');\n    return inside;\n  }\n\n  /**\n   * In task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // Currently we match how GH works in files.\n    // To match how GH works in comments, use `markdownSpace` (`[\\t ]`) instead\n    // of `markdownLineEndingOrSpace` (`[\\t\\n\\r ]`).\n    if (markdownLineEndingOrSpace(code)) {\n      effects.enter('taskListCheckValueUnchecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueUnchecked');\n      return close;\n    }\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueChecked');\n      return close;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At close of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *         ^\n   * ```\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 after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   */\n  function after(code) {\n    // EOL in paragraph means there must be something else after it.\n    if (markdownLineEnding(code)) {\n      return ok(code);\n    }\n\n    // Space or tab?\n    // Check what comes after.\n    if (markdownSpace(code)) {\n      return effects.check({\n        tokenize: spaceThenNonSpace\n      }, ok, nok)(code);\n    }\n\n    // EOF, or non-whitespace, both wrong.\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction spaceThenNonSpace(effects, ok, nok) {\n  return factorySpace(effects, after, \"whitespace\");\n\n  /**\n   * After whitespace, after task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // EOF means there was nothing, so bad.\n    // EOL means there’s content after it, so good.\n    // Impossible to have more spaces.\n    // Anything else is good.\n    return code === null ? nok(code) : ok(code);\n  }\n}","/**\n * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions\n * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\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 * Create an extension for `micromark` to enable GFM syntax.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n *\n *   Passed to `micromark-extens-gfm-strikethrough`.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   syntax.\n */\nexport function gfm(options) {\n  return combineExtensions([\n    gfmAutolinkLiteral(),\n    gfmFootnote(),\n    gfmStrikethrough(options),\n    gfmTable(),\n    gfmTaskListItem()\n  ])\n}\n\n/**\n * Create an extension for `micromark` to support GFM when serializing to HTML.\n *\n * @param {HtmlOptions | null | undefined} [options]\n *   Configuration (optional).\n *\n *   Passed to `micromark-extens-gfm-footnote`.\n * @returns {HtmlExtension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM when serializing to HTML.\n */\nexport function gfmHtml(options) {\n  return combineHtmlExtensions([\n    gfmAutolinkLiteralHtml(),\n    gfmFootnoteHtml(options),\n    gfmStrikethroughHtml(),\n    gfmTableHtml(),\n    gfmTagfilterHtml(),\n    gfmTaskListItemHtml()\n  ])\n}\n","/// <reference types=\"remark-parse\" />\n/// <reference types=\"remark-stringify\" />\n\n/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-gfm').Options} MdastOptions\n * @typedef {import('micromark-extension-gfm').Options} MicromarkOptions\n * @typedef {import('unified').Processor<Root>} Processor\n */\n\n/**\n * @typedef {MicromarkOptions & MdastOptions} Options\n *   Configuration.\n */\n\nimport {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'\nimport {gfm} from 'micromark-extension-gfm'\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Add support GFM (autolink literals, footnotes, strikethrough, tables,\n * tasklists).\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkGfm(options) {\n  // @ts-expect-error: TS is wrong about `this`.\n  // eslint-disable-next-line unicorn/no-this-assignment\n  const self = /** @type {Processor} */ (this)\n  const settings = options || emptyOptions\n  const data = self.data()\n\n  const micromarkExtensions =\n    data.micromarkExtensions || (data.micromarkExtensions = [])\n  const fromMarkdownExtensions =\n    data.fromMarkdownExtensions || (data.fromMarkdownExtensions = [])\n  const toMarkdownExtensions =\n    data.toMarkdownExtensions || (data.toMarkdownExtensions = [])\n\n  micromarkExtensions.push(gfm(settings))\n  fromMarkdownExtensions.push(gfmFromMarkdown())\n  toMarkdownExtensions.push(gfmToMarkdown(settings))\n}\n","/**\n * Parse space-separated tokens to an array of strings.\n *\n * @param {string} value\n *   Space-separated tokens.\n * @returns {Array<string>}\n *   List of 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\n *   List of tokens.\n * @returns {string}\n *   Space-separated tokens.\n */\nexport function stringify(values) {\n  return values.join(' ').trim()\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((node?: null | undefined) => false) &\n   *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (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      return looksLikeANode(node)\n        ? check.call(context, node, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => 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 if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return ok\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\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   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propsFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n      /** @type {unknown} */ (node)\n    )\n\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\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 * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeANode(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Get the ending point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointEnd = point('end')\n\n/**\n * Get the starting point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointStart = point('start')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'end' | 'start'} type\n *   Side.\n * @returns\n *   Getter.\n */\nfunction point(type) {\n  return point\n\n  /**\n   * Get the point info of `node` at a bound side.\n   *\n   * @param {Node | NodeLike | null | undefined} [node]\n   * @returns {Point | undefined}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    if (\n      typeof point.line === 'number' &&\n      point.line > 0 &&\n      typeof point.column === 'number' &&\n      point.column > 0\n    ) {\n      return {\n        line: point.line,\n        column: point.column,\n        offset:\n          typeof point.offset === 'number' && point.offset > -1\n            ? point.offset\n            : undefined\n      }\n    }\n  }\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {Node | NodeLike | null | undefined} [node]\n *   Node.\n * @returns {Position | undefined}\n *   Position.\n */\nexport function position(node) {\n  const start = pointStart(node)\n  const end = pointEnd(node)\n\n  if (start && end) {\n    return {start, end}\n  }\n}\n","/**\n * @param {string} d\n * @returns {string}\n */\nexport function color(d) {\n  return d\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\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  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n          typeof value.name === 'string'\n          ? value.name\n          : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, 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\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\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 === null || value === undefined ? empty : [value]\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n"],"names":["hasOwn","Object","prototype","hasOwnProperty","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","value","newValue","writable","getProperty","module","exports","extend","src","copy","copyIsArray","clone","arguments","i","length","deep","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","trim","str","replace","style","lineno","column","updatePosition","lines","match","lastIndexOf","position","start","line","node","Position","end","source","content","errorsList","error","msg","err","reason","filename","silent","push","re","m","exec","slice","comments","rules","c","comment","pos","FORWARD_SLASH","charAt","ASTERISK","EMPTY_STRING","type","declarations","decl","decls","declaration","prop","val","ret","property","__importDefault","mod","__esModule","inline_style_parser_1","__webpack_require__","iterator","styleObject","default","hasIterator","forEach","cachedSetTimeout","cachedClearTimeout","currentQueue","process","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","e","clearTimeout","queue","draining","queueIndex","cleanUpNextTick","concat","drainQueue","timeout","len","run","runClearTimeout","marker","Item","array","noop","nextTick","args","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","$5b160d28a433310d$var$cachedGlobalStrings","pickChildren","children","targetChild","_a","react","Children","map","isValidElement","item","filter","Boolean","$8229b34715874f89$exports","$5b160d28a433310d$var$localeSymbol","Symbol","for","$5b160d28a433310d$var$stringsSymbol","$5b160d28a433310d$export$c17fa47878dc55b6","getStringForLocale","locale","string","strings","getStringsForLocale","$5b160d28a433310d$var$getStringsForLocale","defaultLocale","language","Locale","Intl","split","startsWith","getGlobalDictionaryForPackage","packageName","window","undefined","globalStrings","pkg","dictionary","messages","fromEntries","entries","v","$6db58dc88e78b024$var$pluralRulesCache","Map","$6db58dc88e78b024$var$numberFormatCache","$6db58dc88e78b024$export$2f817fcdc4b89ae0","format","variables","message","plural","count","opt","pluralRules","get","PluralRules","set","select","other","number","numberFormat","NumberFormat","$fca6afa0e843324b$var$cache","WeakMap","ChevronRightIcon","jsx_runtime","jsx","fill","focusable","height","role","stroke","strokeLinecap","strokeLinejoin","strokeWidth","viewBox","width","props","d","EllipsisIcon","jsxs","shapeRendering","cx","cy","r","warningStack","Breadcrumbs","forwardRef","ref","Component","childCount","itemProps","separator","maxItems","itemsBeforeCollapse","itemsAfterCollapse","isDisabled","renderEllipsis","getBaseProps","getListProps","getEllipsisProps","getSeparatorProps","onAction","useBreadcrumbs","originalProps","_b","globalContext","useProviderContext","disableAnimation","variantProps","mapPropsVariants","breadcrumbs","variantKeys","as","color","underline","childrenProp","hideSeparator","className","classNames","itemClasses","otherProps","shouldFilterDOMProps","navProps","useAriaBreadcrumbs","a","ariaLabel","context","j","useMemo","filterDOMProps","z","labelable","breadcrumb_item_default","domRef","useDOMRef","slots","objectToDeps","baseStyles","clsx","base","size","class","mergeProps","enabled","list","ellipsis","dataAttr","items","child","isLast","itemKey","cloneElement","isCurrent","onPress","chain","warn","component","tag","log","console","NODE_ENV","itemsInEllipsis","ellipsisIcon","collapsedItem","ellipsisItem","displayName","breadcrumbs_default","WrapperComponent","startContent","endContent","getItemProps","useBreadcrumbItem","breadcrumbItem","href","useAriaBreadcrumbItem","ariaCurrent","elementType","linkProps","useLink","n","isHeading","test","tabIndex","autoFocus","isFocusVisible","isFocused","focusProps","useFocusRing","DOMPropNames","Set","DOMEventNames","propRe","ariaRe","funcRe","opts","propNames","omitPropNames","omitEventNames","omitDataProps","omitEventProps","filteredProps","has","useRef","useImperativeHandle","current","document","createElement","tmp","x","toVal","mix","k","y","condition","JSON","stringify","chunk_LDBYFTHC_image","chunk_GMMETTYU","tv","wrapper","zoomedWrapper","img","blurredImg","variants","radius","none","sm","md","lg","full","shadow","isZoomed","true","showSkeleton","false","defaultVariants","isBlurred","compoundSlots","useSafeLayoutEffect","globalThis","useLayoutEffect","useEffect","Image","fallbackSrc","removeWrapper","disableSkeleton","getImgProps","getWrapperProps","getBlurredImgProps","useImage","image","loading","isLoading","isLoadingProp","onError","onLoad","srcSet","sizes","crossOrigin","imageStatus","useImageBase","ignoreFallback","status","setStatus","useState","imageRef","load","useCallback","flush","srcset","onload","event","onerror","isImgLoaded","w","h","showFallback","fallbackStyle","backgroundImage","maxWidth","props2","imgStyles","zoomed","image_default","_chunk_GMMETTYU_mjs__WEBPACK_IMPORTED_MODULE_0__","_chunk_XHQUSKIE_mjs__WEBPACK_IMPORTED_MODULE_1__","Dh","foreground","primary","secondary","success","warning","danger","hover","always","active","focus","compoundVariants","variant","solid","bordered","light","$148a7a147e38ea7f$var$RTL_SCRIPTS","$148a7a147e38ea7f$var$RTL_LANGS","$148a7a147e38ea7f$export$702d680b21cbd764","localeString","maximize","textInfo","getTextInfo","direction","script","lang","$1e5a04cdaf7d1af8$var$localeSymbol","$1e5a04cdaf7d1af8$export$f09106e7c6677ec5","navigator","userLanguage","DateTimeFormat","supportedLocalesOf","_err","$1e5a04cdaf7d1af8$var$currentLocale","$1e5a04cdaf7d1af8$var$listeners","$1e5a04cdaf7d1af8$var$updateLocale","listener","$1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a","isSSR","SSRProvider","Av","setDefaultLocale","addEventListener","add","delete","removeEventListener","$18f2051aff69b9bf$var$I18nContext","createContext","$18f2051aff69b9bf$export$a54013f0d02a8f82","Provider","$18f2051aff69b9bf$export$43bb16f9c6d9e3f7","useContext","$b5e257d569688ac6$var$defaultContext","prefix","String","Math","round","random","$b5e257d569688ac6$var$IsSSRContext","$b5e257d569688ac6$var$getSnapshot","$b5e257d569688ac6$var$getServerSnapshot","$b5e257d569688ac6$var$subscribe","onStoreChange","$b5e257d569688ac6$export$535bd6ca7f90a273","react__WEBPACK_IMPORTED_MODULE_0__","self","deserializer","$","_","out","index","unpair","object","Date","flags","RegExp","BigInt","deserialize","serialized","serialize_toString","keys","typeOf","asString","includes","shouldSkip","TYPE","serializer","strict","json","pair","entry","valueOf","toJSON","toISOString","serialize","lossy","esm","structuredClone","any","parse","tokens","input","indexOf","token","values","settings","join","padRight","padLeft","ok","unreachable","findAndReplace","tree","ignored","unist_util_is_lib","O","ignore","pairs","toPairs","tupleOrList","result","find","tuple","escapeStringRegexp","toFunction","pairIndex","lib","S4","visitor","parents","grandparent","parent","siblings","handler","change","nodes","lastIndex","matchObject","stack","global","splice","emptyOptions","one","includeImageAlt","includeHtml","alt","all","blankLine","tokenize","effects","nok","code","micromark_util_character__WEBPACK_IMPORTED_MODULE_0__","xz","micromark_factory_space__WEBPACK_IMPORTED_MODULE_1__","f","after","Ch","partial","factorySpace","max","limit","Number","POSITIVE_INFINITY","enter","consume","exit","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","fromCharCode","remove","parameters","chunkStart","from","unshift","classifyCharacter","z3","B8","Xh","combineExtensions","extensions","syntaxExtension","extension","hook","left","maybe","right","constructs","existing","before","micromark_util_chunked__WEBPACK_IMPORTED_MODULE_0__","normalizeIdentifier","toLowerCase","toUpperCase","resolveAll","events","called","resolve","Schema","normal","space","merge","definitions","assign","own","create","definition","properties","info","defined_info","I","transform","attributes","mustUseProperty","normalize","F","attribute","xlink","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xml","xmlLang","xmlBase","xmlSpace","caseSensitiveTransform","caseInsensitiveTransform","xmlns","xmlnsxlink","xmlnsXLink","aria","ariaActiveDescendant","ariaAtomic","types","booleanish","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","spaceSeparated","ariaDescribedBy","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","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","html","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","commaSeparated","acceptCharset","accessKey","action","allow","allowFullScreen","boolean","allowPaymentRequest","allowUserMedia","async","autoCapitalize","autoComplete","autoPlay","blocking","capture","charSet","checked","cite","cols","colSpan","contentEditable","controls","controlsList","coords","data","dateTime","decoding","defer","dirName","disabled","download","overloadedBoolean","draggable","encType","enterKeyHint","fetchPriority","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","hidden","high","hrefLang","htmlFor","httpEquiv","id","imageSizes","imageSrcSet","inert","inputMode","integrity","is","isMap","itemId","itemProp","itemRef","itemScope","itemType","kind","label","loop","low","manifest","maxLength","media","method","min","minLength","multiple","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforeMatch","onBeforePrint","onBeforeToggle","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onChange","onClick","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseOver","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onScroll","onScrollEnd","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","open","optimum","pattern","ping","placeholder","playsInline","popover","popoverTarget","popoverTargetAction","poster","preload","readOnly","referrerPolicy","rel","required","reversed","rows","rowSpan","sandbox","scope","scoped","seamless","selected","shadowRootClonable","shadowRootDelegatesFocus","shadowRootMode","shape","slot","span","spellCheck","srcDoc","srcLang","step","translate","typeMustMatch","useMap","wrap","writingSuggestions","align","aLink","archive","axis","background","bgColor","border","borderColor","bottomMargin","cellPadding","cellSpacing","char","charOff","classId","clear","codeBase","codeType","compact","declare","face","frame","frameBorder","hSpace","leftMargin","link","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","text","topMargin","valueType","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","results","security","unselectable","svg","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dataType","dominantBaseline","enableBackground","fillOpacity","fillRule","floodColor","floodOpacity","fontFamily","fontSize","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","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","strokeOpacity","textAnchor","textDecoration","textRendering","transformOrigin","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","commaOrSpaceSeparated","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","begin","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cursor","defaultAction","descent","diffuseConstant","display","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","mode","numOctaves","observer","offset","opacity","operator","order","orient","orientation","origin","overflow","overlay","path","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","resource","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","startOffset","stdDeviation","stemh","stemv","stitchTiles","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","to","u1","u2","unicode","viewTarget","visibility","widths","x1","x2","xChannelSelector","y1","y2","yChannelSelector","zoomAndPan","property_information_html","property_information_svg","valid","dash","cap","schema","_normalize_js__WEBPACK_IMPORTED_MODULE_0__","Type","_util_info_js__WEBPACK_IMPORTED_MODULE_1__","rest","camelcase","dashes","kebab","_util_defined_info_js__WEBPACK_IMPORTED_MODULE_2__","$0","checks","_types_js__WEBPACK_IMPORTED_MODULE_0__","DefinedInfo","_info_js__WEBPACK_IMPORTED_MODULE_1__","check","defined","Info","powers","increment","nameRe","nameReJsx","lib_name","empty","hastToReact","cjs","stringifyPosition","point","VFileMessage","Error","causeOrReason","optionsOrParentOrPlace","legacyCause","place","ancestors","cause","ruleId","fatal","file","actual","expected","note","url","emptyMap","dashSomething","tableElements","tableCellElement","docs","state","lib_element","parentSchema","tagName","property_information","YP","findComponentFromName","createElementProps","alignValue","createProperty","s","isNaN","comma_separated_tokens","P","space_separated_tokens","parseStyle","toCamel","ignoreInvalidStyle","filePath","stylePropertyNameCase","transformStylesToCssCasing","domCasing","cssCasing","transformStyleToCssCasing","toDash","elementAttributeNameCase","tableCellAlignToStyle","createChildren","thing","addNode","addChildren","pop","mdxExpression","estree","evaluater","expression","program","body","lib_default","evaluateExpression","crashEstree","mdxJsxElement","Fragment","createJsxElementProps","objectExpression","argument","mdxEsm","evaluateProgram","root","passNode","countsByName","passKeys","allowExpression","identifiers","computed","optional","components","$1","urlAttributes","icon","SpliceBuffer","initial","shift","setCursor","stop","reverse","deleteCount","trunc","removed","chunkedPush","pushMany","unshiftMany","subtokenize","eventsArray","lineIndex","otherIndex","otherEvent","subevents","more","jumps","_tokenizer","_isInFirstContentOfListItem","contentType","subcontent","eventIndex","stream","previous","startPosition","startPositions","tokenizer","parser","childEvents","gaps","adjust","breaks","sliceStream","next","defineSkip","_gfmTasklistFirstContentOfListItem","write","_container","micromark_util_chunked","contentStart","attempt","contentInitial","micromark_factory_space","lineStart","micromark_util_character","document_document","childFlow","childToken","lineStartOffset","continued","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","containerContinue","flow","flowContinue","writeToChild","eof","seen","disable","null","content_content","chunkInside","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","blank_line","flowInitial","afterConstruct","resolver","createResolver","initializeFactory","text_text","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","tabs","chunks","bufferIndex","chunk","charCodeAt","_index","_bufferIndex","thematicBreak","sequence","initialSize","pY","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","contBefore","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","escape","factoryWhitespace","titleBefore","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","setextUnderline","paragraph","resolveTo","heading","htmlBlockNames","htmlRawNames","blankLineBefore","nonLazyContinuationStart","nonLazyContinuation","codeFenced","closeStart","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","beforeSequenceOpen","sequenceOpen","infoBefore","atNonLazyBreak","metaBefore","meta","contentBefore","beforeContentChunk","contentChunk","index_dom_element","decodeNamedCharacterReference","characterReference","innerHTML","textContent","numeric","H$","AF","characterEscape","sR","lineEnding","labelEnd","labelStart","_balanced","_inactive","labelEndNok","micromark_util_normalize_identifier","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","close","group","V","micromark_util_resolve_all","C","insideSpan","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","attention","attentionMarkers","micromark_util_classify_character","_open","_close","openingSequence","closingSequence","use","nextEvents","movePoint","labelStartLink","constructs_document","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","afterWhitespace","constructs_flow","sequenceFurther","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","jv","commentOpenInside","cdataOpenInside","slash","basicSelfClosing","completeClosingTagAfter","completeEnd","completeAttributeNameBefore","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationAfter","continuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","constructs_string","constructs_text","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","n9","emailLabel","emailValue","returnState","instruction","tagOpen","commentEnd","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","between","tailExitIndex","headEnterIndex","search","decodeNumericCharacterReference","parseInt","fromCodePoint","characterEscapeOrReference","decode","$2","head","hex","lib_own","lib_point","defaultOnError","remarkParse","doc","encoding","atCarriageReturn","mdastExtensions","compiler","config","transforms","canContainEols","autolink","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeText","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","htmlFlowData","htmlText","htmlTextData","listItem","spread","_spread","listItemValue","expectingFirstListItemValue","ancestor","listOrdered","listUnordered","reference","referenceType","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","depth","onexitdata","characterEscapeValue","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","characterReferenceType","resume","flowCodeInside","codeFencedFence","onexithardbreak","inReference","fragment","labelText","atHardBreak","setextHeadingSlurpLineEnding","setextHeadingLineSequence","codePointAt","setextHeadingText","configure","combined","tokenStack","listStack","prepareList","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","and","errorHandler","onExitError","mdast_util_to_string_lib","B","ordered","postprocess","micromark_util_combine_extensions","W","constructs_namespaceObject","createTokenizer","initialize","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","expandTabs","serializeChunks","atTab","main","chunkIndex","go","sliceChunks","view","startIndex","startBufferIndex","endIndex","endBufferIndex","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","def","handleConstruct","store","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","preprocess","endPosition","TextDecoder","ceil","normalizeUri","skip","encodeURIComponent","defaultFootnoteBackContent","rereferenceIndex","defaultFootnoteBackLabel","referenceIndex","revert","subtype","suffix","contents","listItemLoose","trimLine","handlers_handlers","blockquote","patch","applyData","break","footnoteReference","counter","clobberPrefix","safeId","footnoteOrder","reuseCounter","footnoteCounts","dataFootnoteRef","sup","allowDangerousHtml","imageReference","definitionById","inlineCode","linkReference","loose","listLoose","table","firstRow","tableContent","Pk","rb","tableCell","tableRow","rowIndex","cellIndex","cells","cell","trimLines","last","toml","yaml","footnoteDefinition","state_own","state_emptyOptions","FK","hName","hChildren","hProperties","structured_clone_esm","ZP","trimMarkdownSpaceStart","toHast","createState","footnoteById","handlers","handle","passThrough","shallow","unknown","unknownHandler","unist_util_visit_lib","Vn","foot","footer","footnoteBackContent","footnoteBackLabel","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","listItems","backReferences","counts","dataFootnoteBackref","tailTail","dataFootnotes","remarkRehype","destination","hastTree","bail","getPrototypeOf","toStringTag","minpath","basename","extname","seenNonSlash","assertPath","firstNonSlashEnd","extnameIndex","dirname","unmatchedSlash","startPart","startDot","preDotState","segments","joined","absolute","normalizeString","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","sep","minproc","isUrl","fileUrlOrPath","protocol","auth","VFile","history","stored","assertNonEmpty","assertPart","lib_assertPath","stem","urlToPath","URL","getPathFromURLPosix","hostname","pathname","third","decodeURIComponent","fail","decoder","part","CallableInstance","proto","constr","setPrototypeOf","unified_lib_own","Processor","Compiler","Parser","attachers","freezeIndex","frozen","namespace","transformers","trough","fns","pipeline","middlewareIndex","callback","output","fn","lib_wrap","middleware","fnExpectsCallback","done","then","middelware","attacher","assertUnfrozen","freeze","transformer","realFile","vfile","assertParser","assertCompiler","executor","Promise","reject","parseTree","realDone","compileResult","processSync","complete","assertDone","assertNode","outputTree","resultingTree","runSync","addPlugin","addList","addPreset","plugins","plugin","entryIndex","currentPrimary","unified","asyncName","looksLikeAVFile","emptyPlugins","emptyRemarkRehypeOptions","safeProtocol","deprecations","Markdown","allowedElements","allowElement","disallowedElements","rehypePlugins","remarkPlugins","remarkRehypeOptions","skipHtml","unwrapDisallowed","urlTransform","defaultUrlTransform","processor","deprecation","t1","mdastTree","toJsxRuntime","jsxDEV","development","isStaticChildren","columnNumber","fileName","lineNumber","createEvaluater","colon","questionMark","numberSign","CODE_POINTS","ERR","TokenType","CharCodes","BinTrieFlags","EntityDecoderState","DecodingMode","NS","ATTRS","DOCUMENT_MODE","TAG_NAMES","TAG_ID","State","EntryType","InsertionMode","html_NS","buttonTypes","createH","defaultTagName","caseSensitive","createAdjustMap","selector","parseSelector","subvalue","addProperty","Q","parsePrimitive","finalResult","addChild","cr","lf","webNamespaces","mathml","nodeName","quirksMode","lib_all","childNodes","location","loc","lib_location","indices","toOffset","eol","toPoint","namespaceURI","attrs","sourceCodeLocation","startTag","endTag","createLocation","verbose","opening","closing","startLine","startCol","endLine","endCol","endOffset","zwitch_own","zwitch","invalid","hast_util_to_parse5_lib_own","lib_one","hast_util_to_parse5_lib_all","lib_patch","element","currentSchema","parentNode","doctype","publicId","systemId","htmlVoidElements","UNDEFINED_CODE_POINTS","SEQUENCES","DASH_DASH","CDATA_START","DOCTYPE","SCRIPT","PUBLIC","SYSTEM","isSurrogate","cp","isControlCodePoint","isUndefinedCodePoint","Preprocessor","lastGapPos","gapStack","skipNextNewLine","lastChunkWritten","endOfChunkHit","bufferWaterline","isEol","lineStartPos","droppedBufferSize","lastErrOffset","col","getError","onParseError","_addGap","_processSurrogate","nextCp","cp1","EOF","surrogateInInputStream","willDropParsedChunk","dropParsedChunk","substring","isLastChunk","insertHtmlAtCurrentPos","peek","CARRIAGE_RETURN","LINE_FEED","advance","_checkForProblematicCharacters","controlCharacterInInputStream","noncharacterInInputStream","retreat","getTokenAttr","attrName","decode_data_html","Uint16Array","decode_data_xml","decodeMap","codePoint","isNumber","ZERO","NINE","EntityDecoder","decodeTree","emitCodePoint","errors","EntityStart","consumed","treeIndex","excess","decodeMode","Strict","startEntity","NUM","NumericStart","stateNumericStart","NamedEntity","stateNamedEntity","NumericDecimal","stateNumericDecimal","NumericHex","stateNumericHex","LOWER_X","addToNumericResult","digitCount","pow","substr","startIdx","UPPER_A","UPPER_F","LOWER_A","LOWER_F","emitNumericEntity","lastCp","expectedLength","absenceOfDigitsInNumericCharacterReference","SEMI","missingSemicolonAfterCharacterReference","validateNumericCharacterReference","valueLength","VALUE_LENGTH","determineBranch","Attribute","isEntityInAttributeInvalidEnd","EQUALS","UPPER_Z","LOWER_Z","emitNotTerminatedNamedEntity","emitNamedEntityData","getDecoder","nodeIdx","branchCount","BRANCH_LENGTH","jumpOffset","JUMP_TABLE","lo","hi","mid","midVal","TAG_NAME_TO_ID","A","ADDRESS","ANNOTATION_XML","APPLET","AREA","ARTICLE","ASIDE","BASE","BASEFONT","BGSOUND","BIG","BLOCKQUOTE","BODY","BR","BUTTON","CAPTION","CENTER","CODE","COL","COLGROUP","DD","DESC","DETAILS","DIALOG","DIR","DIV","DL","DT","EM","EMBED","FIELDSET","FIGCAPTION","FIGURE","FONT","FOOTER","FOREIGN_OBJECT","FORM","FRAME","FRAMESET","H1","H2","H3","H4","H5","H6","HEAD","HEADER","HGROUP","HR","HTML","IMG","IMAGE","INPUT","IFRAME","KEYGEN","LABEL","LI","LINK","LISTING","MAIN","MALIGNMARK","MARQUEE","MATH","MENU","META","MGLYPH","MI","MO","MN","MS","MTEXT","NAV","NOBR","NOFRAMES","NOEMBED","NOSCRIPT","OBJECT","OL","OPTGROUP","OPTION","PARAM","PLAINTEXT","PRE","RB","RP","RT","RTC","RUBY","S","SECTION","SELECT","SOURCE","SMALL","SPAN","STRIKE","STRONG","STYLE","SUB","SUMMARY","SUP","TABLE","TBODY","TEMPLATE","TEXTAREA","TFOOT","TD","TH","THEAD","TITLE","TR","TRACK","TT","U","UL","SVG","VAR","WBR","XMP","getTagID","UNKNOWN","html_$","SPECIAL_ELEMENTS","MATHML","XLINK","XML","XMLNS","isNumberedHeader","tn","C1_CONTROLS_REFERENCE_REPLACEMENTS","TokenizerMode","DATA","RCDATA","RAWTEXT","SCRIPT_DATA","CDATA_SECTION","isAsciiDigit","DIGIT_0","DIGIT_9","isAsciiUpper","LATIN_CAPITAL_A","LATIN_CAPITAL_Z","isAsciiLetter","isAsciiLower","LATIN_SMALL_A","LATIN_SMALL_Z","tokenizer_isAsciiAlphaNumeric","isAsciiUpperHexDigit","LATIN_CAPITAL_F","isAsciiLowerHexDigit","LATIN_SMALL_F","isWhitespace","SPACE","TABULATION","FORM_FEED","isScriptDataDoubleEscapeSequenceEnd","SOLIDUS","GREATER_THAN_SIGN","Tokenizer","paused","inLoop","inForeignNode","lastStartTagName","charRefCode","consumedAfterSnapshot","currentCharacterToken","currentToken","currentAttr","preprocessor","currentLocation","getCurrentLocation","sourceCodeLocationInfo","_runParsingLoop","_consume","_ensureHibernation","_callState","pause","writeCallback","_unconsume","_reconsumeInState","_advanceBy","_consumeSequenceIfMatch","_createStartTagToken","START_TAG","tagID","selfClosing","ackSelfClosing","_createEndTagToken","END_TAG","_createCommentToken","COMMENT","_createDoctypeToken","initialName","forceQuirks","_createCharacterToken","chars","_createAttr","attrNameFirstCh","_leaveAttrName","attrLocations","_leaveAttrValue","duplicateAttribute","prepareToken","ct","_emitCurrentCharacterToken","emitCurrentTagToken","onStartTag","endTagWithAttributes","endTagWithTrailingSolidus","onEndTag","emitCurrentComment","onComment","emitCurrentDoctype","onDoctype","nextLocation","CHARACTER","onCharacter","NULL_CHARACTER","onNullCharacter","WHITESPACE_CHARACTER","onWhitespaceCharacter","_emitEOFToken","onEof","_appendCharToCurrentCharacterToken","ch","_emitCodePoint","NULL","_emitChars","_matchNamedCharacterReference","withoutSemicolon","masked","SEMICOLON","_isCharacterReferenceInAttribute","EQUALS_SIGN","AMPERSAND","ATTRIBUTE_VALUE_DOUBLE_QUOTED","ATTRIBUTE_VALUE_SINGLE_QUOTED","ATTRIBUTE_VALUE_UNQUOTED","_flushCodePointConsumedAsCharacterReference","_stateData","_stateRcdata","_stateRawtext","_stateScriptData","_statePlaintext","TAG_OPEN","_stateTagOpen","END_TAG_OPEN","_stateEndTagOpen","TAG_NAME","_stateTagName","RCDATA_LESS_THAN_SIGN","_stateRcdataLessThanSign","RCDATA_END_TAG_OPEN","_stateRcdataEndTagOpen","RCDATA_END_TAG_NAME","_stateRcdataEndTagName","RAWTEXT_LESS_THAN_SIGN","_stateRawtextLessThanSign","RAWTEXT_END_TAG_OPEN","_stateRawtextEndTagOpen","RAWTEXT_END_TAG_NAME","_stateRawtextEndTagName","SCRIPT_DATA_LESS_THAN_SIGN","_stateScriptDataLessThanSign","SCRIPT_DATA_END_TAG_OPEN","_stateScriptDataEndTagOpen","SCRIPT_DATA_END_TAG_NAME","_stateScriptDataEndTagName","SCRIPT_DATA_ESCAPE_START","_stateScriptDataEscapeStart","SCRIPT_DATA_ESCAPE_START_DASH","_stateScriptDataEscapeStartDash","SCRIPT_DATA_ESCAPED","_stateScriptDataEscaped","SCRIPT_DATA_ESCAPED_DASH","_stateScriptDataEscapedDash","SCRIPT_DATA_ESCAPED_DASH_DASH","_stateScriptDataEscapedDashDash","SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN","_stateScriptDataEscapedLessThanSign","SCRIPT_DATA_ESCAPED_END_TAG_OPEN","_stateScriptDataEscapedEndTagOpen","SCRIPT_DATA_ESCAPED_END_TAG_NAME","_stateScriptDataEscapedEndTagName","SCRIPT_DATA_DOUBLE_ESCAPE_START","_stateScriptDataDoubleEscapeStart","SCRIPT_DATA_DOUBLE_ESCAPED","_stateScriptDataDoubleEscaped","SCRIPT_DATA_DOUBLE_ESCAPED_DASH","_stateScriptDataDoubleEscapedDash","SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH","_stateScriptDataDoubleEscapedDashDash","SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN","_stateScriptDataDoubleEscapedLessThanSign","SCRIPT_DATA_DOUBLE_ESCAPE_END","_stateScriptDataDoubleEscapeEnd","BEFORE_ATTRIBUTE_NAME","_stateBeforeAttributeName","ATTRIBUTE_NAME","_stateAttributeName","AFTER_ATTRIBUTE_NAME","_stateAfterAttributeName","BEFORE_ATTRIBUTE_VALUE","_stateBeforeAttributeValue","_stateAttributeValueDoubleQuoted","_stateAttributeValueSingleQuoted","_stateAttributeValueUnquoted","AFTER_ATTRIBUTE_VALUE_QUOTED","_stateAfterAttributeValueQuoted","SELF_CLOSING_START_TAG","_stateSelfClosingStartTag","BOGUS_COMMENT","_stateBogusComment","MARKUP_DECLARATION_OPEN","_stateMarkupDeclarationOpen","COMMENT_START","_stateCommentStart","COMMENT_START_DASH","_stateCommentStartDash","_stateComment","COMMENT_LESS_THAN_SIGN","_stateCommentLessThanSign","COMMENT_LESS_THAN_SIGN_BANG","_stateCommentLessThanSignBang","COMMENT_LESS_THAN_SIGN_BANG_DASH","_stateCommentLessThanSignBangDash","COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH","_stateCommentLessThanSignBangDashDash","COMMENT_END_DASH","_stateCommentEndDash","COMMENT_END","_stateCommentEnd","COMMENT_END_BANG","_stateCommentEndBang","_stateDoctype","BEFORE_DOCTYPE_NAME","_stateBeforeDoctypeName","DOCTYPE_NAME","_stateDoctypeName","AFTER_DOCTYPE_NAME","_stateAfterDoctypeName","AFTER_DOCTYPE_PUBLIC_KEYWORD","_stateAfterDoctypePublicKeyword","BEFORE_DOCTYPE_PUBLIC_IDENTIFIER","_stateBeforeDoctypePublicIdentifier","DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED","_stateDoctypePublicIdentifierDoubleQuoted","DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED","_stateDoctypePublicIdentifierSingleQuoted","AFTER_DOCTYPE_PUBLIC_IDENTIFIER","_stateAfterDoctypePublicIdentifier","BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS","_stateBetweenDoctypePublicAndSystemIdentifiers","AFTER_DOCTYPE_SYSTEM_KEYWORD","_stateAfterDoctypeSystemKeyword","BEFORE_DOCTYPE_SYSTEM_IDENTIFIER","_stateBeforeDoctypeSystemIdentifier","DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED","_stateDoctypeSystemIdentifierDoubleQuoted","DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED","_stateDoctypeSystemIdentifierSingleQuoted","AFTER_DOCTYPE_SYSTEM_IDENTIFIER","_stateAfterDoctypeSystemIdentifier","BOGUS_DOCTYPE","_stateBogusDoctype","_stateCdataSection","CDATA_SECTION_BRACKET","_stateCdataSectionBracket","CDATA_SECTION_END","_stateCdataSectionEnd","CHARACTER_REFERENCE","_stateCharacterReference","NAMED_CHARACTER_REFERENCE","_stateNamedCharacterReference","AMBIGUOUS_AMPERSAND","_stateAmbiguousAmpersand","NUMERIC_CHARACTER_REFERENCE","_stateNumericCharacterReference","HEXADEMICAL_CHARACTER_REFERENCE_START","_stateHexademicalCharacterReferenceStart","HEXADEMICAL_CHARACTER_REFERENCE","_stateHexademicalCharacterReference","DECIMAL_CHARACTER_REFERENCE","_stateDecimalCharacterReference","NUMERIC_CHARACTER_REFERENCE_END","_stateNumericCharacterReferenceEnd","LESS_THAN_SIGN","unexpectedNullCharacter","EXCLAMATION_MARK","QUESTION_MARK","unexpectedQuestionMarkInsteadOfTagName","eofBeforeTagName","invalidFirstCharacterOfTagName","missingEndTagName","eofInTag","handleSpecialEndTag","_cp","HYPHEN_MINUS","eofInScriptHtmlCommentLikeText","unexpectedEqualsSignBeforeAttributeName","QUOTATION_MARK","APOSTROPHE","unexpectedCharacterInAttributeName","missingAttributeValue","GRAVE_ACCENT","unexpectedCharacterInUnquotedAttributeValue","missingWhitespaceBetweenAttributes","unexpectedSolidusInTag","cdataInHtmlContent","incorrectlyOpenedComment","abruptClosingOfEmptyComment","eofInComment","nestedComment","incorrectlyClosedComment","eofInDoctype","missingWhitespaceBeforeDoctypeName","missingDoctypeName","invalidCharacterSequenceAfterDoctypeName","missingWhitespaceAfterDoctypePublicKeyword","missingDoctypePublicIdentifier","missingQuoteBeforeDoctypePublicIdentifier","abruptDoctypePublicIdentifier","missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers","missingQuoteBeforeDoctypeSystemIdentifier","missingWhitespaceAfterDoctypeSystemKeyword","missingDoctypeSystemIdentifier","abruptDoctypeSystemIdentifier","unexpectedCharacterAfterDoctypeSystemIdentifier","RIGHT_SQUARE_BRACKET","eofInCdata","NUMBER_SIGN","matchResult","unknownNamedCharacterReference","LATIN_SMALL_X","LATIN_CAPITAL_X","nullCharacterReference","REPLACEMENT_CHARACTER","characterReferenceOutsideUnicodeRange","surrogateCharacterReference","noncharacterCharacterReference","controlCharacterReference","replacement","IMPLICIT_END_TAG_REQUIRED","IMPLICIT_END_TAG_REQUIRED_THOROUGHLY","SCOPING_ELEMENT_NS","NAMED_HEADERS","TABLE_ROW_CONTEXT","TABLE_BODY_CONTEXT","TABLE_CONTEXT","TABLE_CELLS","OpenElementStack","currentTmplContentOrNode","_isInTemplate","treeAdapter","getTemplateContent","tagIDs","stackTop","tmplCount","currentTagId","_indexOf","getNamespaceURI","_updateCurrentElement","onItemPush","popped","onItemPop","oldElement","newElement","idx","insertAfter","referenceElement","newElementID","insertionIdx","popUntilTagNamePopped","targetIdx","shortenToLength","popUntilElementPopped","popUntilPopped","tagNames","targetNS","_indexOfTagNames","popUntilNumberedHeaderPopped","popUntilTableCellPopped","popAllUpToHtmlElement","clearBackTo","clearBackToTableContext","clearBackToTableBodyContext","clearBackToTableRowContext","tryPeekProperlyNestedBodyElement","contains","getCommonAncestor","elementIdx","isRootHtmlElementCurrent","hasInScope","ns","hasNumberedHeaderInScope","hasInListItemScope","hasInButtonScope","hasInTableScope","hasTableBodyContextInTableScope","hasInSelectScope","generateImpliedEndTags","generateImpliedEndTagsThoroughly","generateImpliedEndTagsWithExclusion","exclusionId","MARKER","Marker","FormattingElementList","bookmark","_getNoahArkConditionCandidates","neAttrs","candidates","neAttrsLength","neTagName","getTagName","neNamespaceURI","elementAttrs","getAttrList","_ensureNoahArkCondition","neAttrsMap","neAttr","validCandidates","candidate","every","cAttr","insertMarker","pushElement","Element","insertElementAfterBookmark","bookmarkIdx","removeEntry","clearToLastMarker","markerIdx","getElementEntryInScopeWithTagName","getElementEntry","createTextNode","defaultTreeAdapter","createDocument","NO_QUIRKS","createDocumentFragment","createCommentNode","appendChild","newNode","insertBefore","referenceNode","setTemplateContent","templateElement","contentElement","setDocumentType","doctypeNode","setDocumentMode","getDocumentMode","detachNode","insertText","prevNode","isTextNode","insertTextBefore","adoptAttributes","recipient","recipientAttrsMap","attr","getFirstChild","getChildNodes","getParentNode","getTextNodeContent","textNode","getCommentNodeContent","commentNode","getDocumentTypeNodeName","getDocumentTypeNodePublicId","getDocumentTypeNodeSystemId","isCommentNode","isDocumentTypeNode","isElementNode","setNodeSourceCodeLocation","getNodeSourceCodeLocation","updateNodeSourceCodeLocation","endLocation","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","hasPrefix","prefixes","some","MIME_TYPES","TEXT_HTML","APPLICATION_XML","SVG_ATTRS_ADJUSTMENT_MAP","XML_ATTRS_ADJUSTMENT_MAP","SVG_TAG_NAMES_ADJUSTMENT_MAP","EXITS_FOREIGN_CONTENT","adjustTokenMathMLAttrs","adjustTokenSVGAttrs","adjustedAttrName","adjustTokenXMLAttrs","adjustedAttrEntry","BASE_LOC","TABLE_STRUCTURE_TAGS","defaultParserOptions","scriptingEnabled","parser_Parser","fragmentContext","scriptHandler","stopped","insertionMode","INITIAL","originalInsertionMode","headElement","formElement","currentNotInHTML","tmplInsertionModeStack","pendingCharacterTokens","hasNonWhitespacePendingCharacterToken","framesetOk","fosterParentingEnabled","activeFormattingElements","fragmentContextID","_setContextModes","openElements","getFragmentParser","documentMock","IN_TEMPLATE","_initTokenizerForFragmentParsing","_insertFakeRootElement","_resetInsertionMode","_findFormInFragmentContext","getFragment","rootElement","_adoptNodes","beforeToken","tid","isTop","_setEndLocation","isHTML","_isIntegrationPoint","_switchToTextParsing","nextTokenizerState","_insertElement","TEXT","switchToPlaintextParsing","IN_BODY","_getAdjustedCurrentElement","_setDocumentType","docTypeNode","documentChildren","_attachElementToTree","_shouldFosterParentOnInsertion","_fosterParentElement","_appendElement","_insertFakeElement","_insertTemplate","tmpl","_appendCommentNode","_insertCharacters","beforeElement","_findFosterParentingLocation","textNodeIdx","donor","closingToken","ctLoc","endLoc","shouldProcessStartTagTokenInForeignContent","_processToken","_processStartTag","foreignNS","isHtmlIntegrationPoint","ENCODING","_reconstructActiveFormattingElements","listLength","findIndex","unopenIdx","_closeTableCell","IN_ROW","_closePElement","IN_TABLE_BODY","IN_CAPTION","IN_COLUMN_GROUP","IN_TABLE","IN_FRAMESET","_resetInsertionModeForSelect","AFTER_HEAD","BEFORE_HEAD","IN_CELL","IN_HEAD","selectIdx","IN_SELECT_IN_TABLE","IN_SELECT","_isElementCausesFosterParenting","openElement","_isSpecialElement","p","tokenInInitialMode","BEFORE_HTML","tokenBeforeHtml","tokenBeforeHead","tokenInHead","IN_HEAD_NO_SCRIPT","tokenInHeadNoScript","tokenAfterHead","characterInBody","characterInTable","IN_TABLE_TEXT","characterInTableText","tokenInColumnGroup","AFTER_BODY","tokenAfterBody","AFTER_AFTER_BODY","tokenAfterAfterBody","appendComment","AFTER_FRAMESET","tokenInTableText","appendCommentToRootHtmlElement","AFTER_AFTER_FRAMESET","appendCommentToDocument","doctypeInInitialMode","QUIRKS","LIMITED_QUIRKS","nonConformingDoctype","misplacedDoctype","nonVoidHtmlElementStartTagWithTrailingSolidus","startTagInForeignContent","causesExit","startTagToken","isFontWithAttrs","COLOR","SIZE","FACE","popUntilHtmlOrIntegrationPoint","_startTagOutsideForeignContent","currentNs","adjustTokenSVGTagName","adjustedTagName","startTagBeforeHead","startTagInBody","startTagInHead","startTagInHeadNoScript","nestedNoscriptInHead","startTagAfterHead","abandonedHeadElementChild","misplacedStartTagForHeadElement","startTagInTable","startTagInCaption","TABLE_VOID_ELEMENTS","startTagInColumnGroup","startTagInTableBody","startTagInRow","startTagInCell","startTagInSelect","startTagInSelectInTable","startTagInTemplate","startTagInFrameset","startTagAfterFrameset","startTagAfterAfterFrameset","endTagInForeignContent","_endTagOutsideForeignContent","endTagBeforeHtml","endTagBeforeHead","endTagWithoutMatchingOpenElement","endTagInHead","templateEndTagInHead","endTagInHeadNoScript","endTagAfterHead","endTagInBody","endTagInTable","endTagInCaption","endTagInColumnGroup","endTagInTableBody","endTagInRow","endTagInCell","endTagInSelect","endTagInSelectInTable","endTagAfterBody","eofInBody","eofInElementThatCanContainOnlyText","eofInTemplate","stopParsing","whitespaceCharacterInBody","whitespaceCharacterInTableText","callAdoptionAgency","formattingElementEntry","aaObtainFormattingElementEntry","genericEndTagInBody","furthestBlock","aaObtainFurthestBlock","lastElement","aaInnerLoop","formattingElement","nextElement","elementEntry","counterOverflow","aaRecreateElementFromEntry","commonAncestor","aaInsertLastNodeInCommonAncestor","aaReplaceFormattingElement","htmlElement","htmlLocation","bodyElement","bodyLocation","missingDoctype","closingOfElementWithOpenChildElements","errCode","openElementsLeftAfterEof","disallowedContentInNoscriptInHead","modeInBody","areaStartTagInBody","isHiddenInput","inputType","noembedStartTagInBody","genericStartTagInBody","aStartTagInBody","activeElementEntry","listItemStartTagInBody","elementId","bodyStartTagInBody","formStartTagInBody","inTemplate","framesetStartTagInBody","addressEndTagInBody","ddEndTagInBody","bodyEndTagInBody","formEndTagInBody","appletEndTagInBody","tokenInTable","savedFosterParentingState","xmlCodeMap","getEscaper","lastIdx","knownMdxNames","parseOptions","documentMode","lib_root","hast_util_raw_lib_element","hast_util_raw_lib_text","lib_comment","lib_doctype","handleRaw","stitches","resetTokenizer","fromParse5","stitch","hast_util_raw_lib_all","createParse5Location","setPoint","node_","fakeRoot","extra","rehypeRaw","remarkBreaks","ccount","character","inConstruct","notInConstruct","enterLiteralAutolink","enterLiteralAutolinkValue","exitLiteralAutolinkHttp","exitLiteralAutolinkWww","exitLiteralAutolinkEmail","exitLiteralAutolink","transformGfmAutolinkLiterals","findUrl","findEmail","domain","isCorrectDomain","parts","splitUrl","trailExec","trail","closingParenIndex","openingParens","closingParens","atext","email","enterFootnoteDefinition","enterFootnoteDefinitionLabelString","exitFootnoteDefinitionLabelString","exitFootnoteDefinition","enterFootnoteCall","enterFootnoteCallString","exitFootnoteCallString","exitFootnoteCall","tracker","createTracker","move","subexit","safe","associationId","indentLines","containerFlow","blank","constructsWithoutStrikethrough","enterStrikethrough","exitStrikethrough","handleDelete","containerPhrasing","defaultStringLength","toAlignment","unsafe","compilePattern","listItemIndent","checkListItemIndent","bullet","bulletCurrent","checkBullet","incrementListMarker","repeat","enterTable","_align","inTable","exitTable","enterRow","enterCell","exitCodeText","exitCheck","exitParagraphWithTaskListItem","firstParaghraph","sibling","listItemWithTaskListItem","checkable","checkbox","wwwPrefix","wwwPrefixInside","wwwPrefixAfter","underscoreInLastSegment","underscoreInLastLastSegment","domainInside","domainAfter","domainAtPunctuation","sizeClose","pathInside","pathAtPunctuation","trailCharacterReferenceStart","trailBracketAfter","trailCharacterReferenceInside","emailDomainDotTrail","wwwAutolink","previousWww","previousUnbalanced","wwwAfter","protocolAutolink","previousProtocol","protocolPrefixInside","protocolSlashesInside","afterProtocol","protocolAfter","emailAutolink","dot","gfmAtext","previousEmail","emailDomain","emailDomainAfter","emailDomainDot","syntax_text","syntax_code","_gfmAutolinkLiteralWalkedInto","indent","tokenizePotentialGfmFootnoteCall","gfmFootnotes","resolveToPotentialGfmFootnoteCall","tokenizeGfmFootnoteCall","callStart","callData","callEscape","tokenizeDefinitionStart","labelAtMarker","whitespaceAfter","tokenizeDefinitionContinuation","gfmFootnoteDefinitionEnd","EditMap","addImplementation","editMap","at","sort","b","vecs","tokenizeTable","sizeB","bodyRowStart","headRowBefore","headRowBreak","headDelimiterStart","headRowData","headRowEscape","headDelimiterBefore","headDelimiterValueBefore","headDelimiterCellBefore","headDelimiterLeftAlignmentAfter","headDelimiterCellAfter","headDelimiterFiller","headDelimiterRightAlignmentAfter","bodyRowBreak","bodyRowData","bodyRowEscape","resolveTable","currentTable","currentBody","currentCell","inFirstCellAwaitingPipe","rowKind","lastCell","afterHeadAwaitingFirstBodyRow","lastTableEnd","flushTableEnd","flushCell","gfmTableAlign","inDelimiterRow","alignIndex","range","rowEnd","previousCell","getPoint","relatedStart","relatedEnd","valueToken","tableBody","exits","related","tasklistCheck","spaceThenNonSpace","remarkGfm","micromarkExtensions","fromMarkdownExtensions","toMarkdownExtensions","gfmStrikethrough","single","options_","singleTilde","strikethrough","literalAutolink","literalAutolinkEmail","literalAutolinkHttp","literalAutolinkWww","gfmFootnoteDefinition","gfmFootnoteDefinitionLabelString","gfmFootnoteCall","gfmFootnoteCallString","tableData","tableHeader","taskListCheckValueChecked","taskListCheckValueUnchecked","gfmTableToMarkdown","padding","tableCellPadding","alignDelimiters","tablePipeAlign","stringLength","around","serializeData","handleTableAsData","handleTableRowAsData","handleTableCell","matrix","markdownTable","alignments","cellMatrix","sizeMatrix","longestCellByColumn","mostCellsPerRow","row","columnIndex","delimiterStart","delimiterEnd","convert","castFactory","anyFactory","tests","nodeAsRecord","checkAsRecord","testFunction","looksLikeANode","pointEnd","pointStart","EXIT","visitParents","factory","visit","subresult","grandparents","nodeAsParent","testOrVisitor","visitorOrReverse","maybeReverse","unist_util_visit_parents__WEBPACK_IMPORTED_MODULE_0__"],"sourceRoot":""}